Rocstar  1.0
Rocstar multiphysics simulation application
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Namespaces | Macros | Functions | Variables
CImg.h File Reference
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <cstring>
#include <cmath>
#include <ctime>
Include dependency graph for CImg.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  CImg< T >
 Class representing an image (up to 4 dimensions wide), each pixel being of type T. More...
 
struct  CImgList< T >
 Class representing list of images CImg<T>. More...
 
struct  CImgException
 Instances of this class are thrown when errors occur during a CImg library function call. More...
 
struct  CImgInstanceException
 
struct  CImgArgumentException
 
struct  CImgIOException
 
struct  CImgDisplayException
 
struct  CImgWarningException
 
struct  type< T >
 
struct  type< bool >
 
struct  type< unsigned char >
 
struct  type< char >
 
struct  type< signed char >
 
struct  type< unsigned short >
 
struct  type< short >
 
struct  type< unsigned int >
 
struct  type< int >
 
struct  type< unsigned long >
 
struct  type< long >
 
struct  type< float >
 
struct  type< double >
 
struct  superset< T, t >
 
struct  superset< bool, unsigned char >
 
struct  superset< bool, char >
 
struct  superset< bool, signed char >
 
struct  superset< bool, unsigned short >
 
struct  superset< bool, short >
 
struct  superset< bool, unsigned int >
 
struct  superset< bool, int >
 
struct  superset< bool, unsigned long >
 
struct  superset< bool, long >
 
struct  superset< bool, float >
 
struct  superset< bool, double >
 
struct  superset< unsigned char, char >
 
struct  superset< unsigned char, signed char >
 
struct  superset< unsigned char, unsigned short >
 
struct  superset< unsigned char, short >
 
struct  superset< unsigned char, unsigned int >
 
struct  superset< unsigned char, int >
 
struct  superset< unsigned char, unsigned long >
 
struct  superset< unsigned char, long >
 
struct  superset< unsigned char, float >
 
struct  superset< unsigned char, double >
 
struct  superset< signed char, unsigned char >
 
struct  superset< signed char, char >
 
struct  superset< signed char, unsigned short >
 
struct  superset< signed char, short >
 
struct  superset< signed char, unsigned int >
 
struct  superset< signed char, int >
 
struct  superset< signed char, unsigned long >
 
struct  superset< signed char, long >
 
struct  superset< signed char, float >
 
struct  superset< signed char, double >
 
struct  superset< char, unsigned char >
 
struct  superset< char, signed char >
 
struct  superset< char, unsigned short >
 
struct  superset< char, short >
 
struct  superset< char, unsigned int >
 
struct  superset< char, int >
 
struct  superset< char, unsigned long >
 
struct  superset< char, long >
 
struct  superset< char, float >
 
struct  superset< char, double >
 
struct  superset< unsigned short, char >
 
struct  superset< unsigned short, signed char >
 
struct  superset< unsigned short, short >
 
struct  superset< unsigned short, unsigned int >
 
struct  superset< unsigned short, int >
 
struct  superset< unsigned short, unsigned long >
 
struct  superset< unsigned short, long >
 
struct  superset< unsigned short, float >
 
struct  superset< unsigned short, double >
 
struct  superset< short, unsigned short >
 
struct  superset< short, unsigned int >
 
struct  superset< short, int >
 
struct  superset< short, unsigned long >
 
struct  superset< short, long >
 
struct  superset< short, float >
 
struct  superset< short, double >
 
struct  superset< unsigned int, char >
 
struct  superset< unsigned int, signed char >
 
struct  superset< unsigned int, short >
 
struct  superset< unsigned int, int >
 
struct  superset< unsigned int, unsigned long >
 
struct  superset< unsigned int, long >
 
struct  superset< unsigned int, float >
 
struct  superset< unsigned int, double >
 
struct  superset< int, unsigned int >
 
struct  superset< int, unsigned long >
 
struct  superset< int, long >
 
struct  superset< int, float >
 
struct  superset< int, double >
 
struct  superset< unsigned long, char >
 
struct  superset< unsigned long, signed char >
 
struct  superset< unsigned long, short >
 
struct  superset< unsigned long, int >
 
struct  superset< unsigned long, long >
 
struct  superset< unsigned long, float >
 
struct  superset< unsigned long, double >
 
struct  superset< long, float >
 
struct  superset< long, double >
 
struct  superset< float, double >
 
struct  superset2< t1, t2, t3 >
 
struct  superset3< t1, t2, t3, t4 >
 
struct  last< t1, t2 >
 
struct  CImgDisplay
 This class represents a window which can display CImg images and handles mouse and keyboard events. More...
 
struct  CImg< T >
 Class representing an image (up to 4 dimensions wide), each pixel being of type T. More...
 
struct  CImg< T >::_cimg_math_parser
 
struct  CImg< T >::_marching2d_func
 
struct  CImg< T >::_marching2d_func_float
 
struct  CImg< T >::_marching2d_func_expr
 
struct  CImg< T >::_marching3d_func
 
struct  CImg< T >::_marching3d_func_float
 
struct  CImg< T >::_marching3d_func_expr
 
struct  CImgList< T >
 Class representing list of images CImg<T>. More...
 

Namespaces

 cimg_library
 This namespace encompasses all classes and functions of the CImg library.
 
 cimg_library::cimg
 Namespace that encompasses low-level functions and variables of the CImg Library.
 

Macros

#define cimg_version   132
 
#define cimg_OS   0
 
#define cimg_stdout   stderr
 
#define cimg_file_separator   '/'
 
#define cimg_debug   2
 
#define cimg_display   0
 
#define cimg_usage(usage)   cimg_library::cimg::option((char*)0,argc,argv,(char*)0,usage)
 
#define cimg_help(str)   cimg_library::cimg::option((char*)0,argc,argv,str,(char*)0)
 
#define cimg_option(name, defaut, usage)   cimg_library::cimg::option(name,argc,argv,defaut,usage)
 
#define cimg_argument(pos)   cimg_library::cimg::argument(pos,argc,argv)
 
#define cimg_argument1(pos, s0)   cimg_library::cimg::argument(pos,argc,argv,1,s0)
 
#define cimg_argument2(pos, s0, s1)   cimg_library::cimg::argument(pos,argc,argv,2,s0,s1)
 
#define cimg_argument3(pos, s0, s1, s2)   cimg_library::cimg::argument(pos,argc,argv,3,s0,s1,s2)
 
#define cimg_argument4(pos, s0, s1, s2, s3)   cimg_library::cimg::argument(pos,argc,argv,4,s0,s1,s2,s3)
 
#define cimg_argument5(pos, s0, s1, s2, s3, s4)   cimg_library::cimg::argument(pos,argc,argv,5,s0,s1,s2,s3,s4)
 
#define cimg_argument6(pos, s0, s1, s2, s3, s4, s5)   cimg_library::cimg::argument(pos,argc,argv,6,s0,s1,s2,s3,s4,s5)
 
#define cimg_argument7(pos, s0, s1, s2, s3, s4, s5, s6)   cimg_library::cimg::argument(pos,argc,argv,7,s0,s1,s2,s3,s4,s5,s6)
 
#define cimg_argument8(pos, s0, s1, s2, s3, s4, s5, s6, s7)   cimg_library::cimg::argument(pos,argc,argv,8,s0,s1,s2,s3,s4,s5,s6,s7)
 
#define cimg_argument9(pos, s0, s1, s2, s3, s4, s5, s6, s7, s8)   cimg_library::cimg::argument(pos,argc,argv,9,s0,s1,s2,s3,s4,s5,s6,s7,s8)
 
#define CImg_2x2(I, T)
 
#define CImg_3x3(I, T)
 
#define CImg_4x4(I, T)
 
#define CImg_5x5(I, T)
 
#define CImg_2x2x2(I, T)
 
#define CImg_3x3x3(I, T)
 
#define cimg_get2x2(img, x, y, z, v, I)   I[0] = (img)(x,y,z,v), I[1] = (img)(_n1##x,y,z,v), I[2] = (img)(x,_n1##y,z,v), I[3] = (img)(_n1##x,_n1##y,z,v)
 
#define cimg_get3x3(img, x, y, z, v, I)
 
#define cimg_get4x4(img, x, y, z, v, I)
 
#define cimg_get5x5(img, x, y, z, v, I)
 
#define cimg_get6x6(img, x, y, z, v, I)
 
#define cimg_get7x7(img, x, y, z, v, I)
 
#define cimg_get8x8(img, x, y, z, v, I)
 
#define cimg_get9x9(img, x, y, z, v, I)
 
#define cimg_get2x2x2(img, x, y, z, v, I)
 
#define cimg_get3x3x3(img, x, y, z, v, I)
 
#define cimg_for(img, ptr, T_ptr)   for (T_ptr *ptr = (img).data + (img).size(); (ptr--)>(img).data; )
 
#define cimg_foroff(img, off)   for (unsigned int off = 0, _max##off = (unsigned int)(img).size(); off<_max##off; ++off)
 
#define cimg_for1(bound, i)   for (int i = 0; i<(int)(bound); ++i)
 
#define cimg_forX(img, x)   cimg_for1((img).width,x)
 
#define cimg_forY(img, y)   cimg_for1((img).height,y)
 
#define cimg_forZ(img, z)   cimg_for1((img).depth,z)
 
#define cimg_forV(img, v)   cimg_for1((img).dim,v)
 
#define cimg_forXY(img, x, y)   cimg_forY(img,y) cimg_forX(img,x)
 
#define cimg_forXZ(img, x, z)   cimg_forZ(img,z) cimg_forX(img,x)
 
#define cimg_forYZ(img, y, z)   cimg_forZ(img,z) cimg_forY(img,y)
 
#define cimg_forXV(img, x, v)   cimg_forV(img,v) cimg_forX(img,x)
 
#define cimg_forYV(img, y, v)   cimg_forV(img,v) cimg_forY(img,y)
 
#define cimg_forZV(img, z, v)   cimg_forV(img,v) cimg_forZ(img,z)
 
#define cimg_forXYZ(img, x, y, z)   cimg_forZ(img,z) cimg_forXY(img,x,y)
 
#define cimg_forXYV(img, x, y, v)   cimg_forV(img,v) cimg_forXY(img,x,y)
 
#define cimg_forXZV(img, x, z, v)   cimg_forV(img,v) cimg_forXZ(img,x,z)
 
#define cimg_forYZV(img, y, z, v)   cimg_forV(img,v) cimg_forYZ(img,y,z)
 
#define cimg_forXYZV(img, x, y, z, v)   cimg_forV(img,v) cimg_forXYZ(img,x,y,z)
 
#define cimg_for_in1(bound, i0, i1, i)   for (int i = (int)(i0)<0?0:(int)(i0), _max##i = (int)(i1)<(int)(bound)?(int)(i1):(int)(bound)-1; i<=_max##i; ++i)
 
#define cimg_for_inX(img, x0, x1, x)   cimg_for_in1((img).width,x0,x1,x)
 
#define cimg_for_inY(img, y0, y1, y)   cimg_for_in1((img).height,y0,y1,y)
 
#define cimg_for_inZ(img, z0, z1, z)   cimg_for_in1((img).depth,z0,z1,z)
 
#define cimg_for_inV(img, v0, v1, v)   cimg_for_in1((img).dim,v0,v1,v)
 
#define cimg_for_inXY(img, x0, y0, x1, y1, x, y)   cimg_for_inY(img,y0,y1,y) cimg_for_inX(img,x0,x1,x)
 
#define cimg_for_inXZ(img, x0, z0, x1, z1, x, z)   cimg_for_inZ(img,z0,z1,z) cimg_for_inX(img,x0,x1,x)
 
#define cimg_for_inXV(img, x0, v0, x1, v1, x, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inX(img,x0,x1,x)
 
#define cimg_for_inYZ(img, y0, z0, y1, z1, y, z)   cimg_for_inZ(img,x0,z1,z) cimg_for_inY(img,y0,y1,y)
 
#define cimg_for_inYV(img, y0, v0, y1, v1, y, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inY(img,y0,y1,y)
 
#define cimg_for_inZV(img, z0, v0, z1, v1, z, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inZ(img,z0,z1,z)
 
#define cimg_for_inXYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_inZ(img,z0,z1,z) cimg_for_inXY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_inXYV(img, x0, y0, v0, x1, y1, v1, x, y, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inXY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_inXZV(img, x0, z0, v0, x1, z1, v1, x, z, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inXZ(img,x0,z0,x1,z1,x,z)
 
#define cimg_for_inYZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inYZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_inXYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_inV(img,v0,v1,v) cimg_for_inXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for_insideX(img, x, n)   cimg_for_inX(img,n,(img).width-1-(n),x)
 
#define cimg_for_insideY(img, y, n)   cimg_for_inY(img,n,(img).height-1-(n),y)
 
#define cimg_for_insideZ(img, z, n)   cimg_for_inZ(img,n,(img).depth-1-(n),z)
 
#define cimg_for_insideV(img, v, n)   cimg_for_inV(img,n,(img).dim-1-(n),v)
 
#define cimg_for_insideXY(img, x, y, n)   cimg_for_inXY(img,n,n,(img).width-1-(n),(img).height-1-(n),x,y)
 
#define cimg_for_insideXYZ(img, x, y, z, n)   cimg_for_inXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)
 
#define cimg_for_insideXYZV(img, x, y, z, v, n)   cimg_for_inXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)
 
#define cimg_for_out1(boundi, i0, i1, i)   for (int i = (int)(i0)>0?0:(int)(i1)+1; i<(int)(boundi); ++i, i = i==(int)(i0)?(int)(i1)+1:i)
 
#define cimg_for_out2(boundi, boundj, i0, j0, i1, j1, i, j)
 
#define cimg_for_out3(boundi, boundj, boundk, i0, j0, k0, i1, j1, k1, i, j, k)
 
#define cimg_for_out4(boundi, boundj, boundk, boundl, i0, j0, k0, l0, i1, j1, k1, l1, i, j, k, l)
 
#define cimg_for_outX(img, x0, x1, x)   cimg_for_out1((img).width,x0,x1,x)
 
#define cimg_for_outY(img, y0, y1, y)   cimg_for_out1((img).height,y0,y1,y)
 
#define cimg_for_outZ(img, z0, z1, z)   cimg_for_out1((img).depth,z0,z1,z)
 
#define cimg_for_outV(img, v0, v1, v)   cimg_for_out1((img).dim,v0,v1,v)
 
#define cimg_for_outXY(img, x0, y0, x1, y1, x, y)   cimg_for_out2((img).width,(img).height,x0,y0,x1,y1,x,y)
 
#define cimg_for_outXZ(img, x0, z0, x1, z1, x, z)   cimg_for_out2((img).width,(img).depth,x0,z0,x1,z1,x,z)
 
#define cimg_for_outXV(img, x0, v0, x1, v1, x, v)   cimg_for_out2((img).width,(img).dim,x0,v0,x1,v1,x,v)
 
#define cimg_for_outYZ(img, y0, z0, y1, z1, y, z)   cimg_for_out2((img).height,(img).depth,y0,z0,y1,z1,y,z)
 
#define cimg_for_outYV(img, y0, v0, y1, v1, y, v)   cimg_for_out2((img).height,(img).dim,y0,v0,y1,v1,y,v)
 
#define cimg_for_outZV(img, z0, v0, z1, v1, z, v)   cimg_for_out2((img).depth,(img).dim,z0,v0,z1,v1,z,v)
 
#define cimg_for_outXYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_out3((img).width,(img).height,(img).depth,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for_outXYV(img, x0, y0, v0, x1, y1, v1, x, y, v)   cimg_for_out3((img).width,(img).height,(img).dim,x0,y0,v0,x1,y1,v1,x,y,v)
 
#define cimg_for_outXZV(img, x0, z0, v0, x1, z1, v1, x, z, v)   cimg_for_out3((img).width,(img).depth,(img).dim,x0,z0,v0,x1,z1,v1,x,z,v)
 
#define cimg_for_outYZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_out3((img).height,(img).depth,(img).dim,y0,z0,v0,y1,z1,v1,y,z,v)
 
#define cimg_for_outXYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_out4((img).width,(img).height,(img).depth,(img).dim,x0,y0,z0,v0,x1,y1,z1,v1,x,y,z,v)
 
#define cimg_for_borderX(img, x, n)   cimg_for_outX(img,n,(img).width-1-(n),x)
 
#define cimg_for_borderY(img, y, n)   cimg_for_outY(img,n,(img).height-1-(n),y)
 
#define cimg_for_borderZ(img, z, n)   cimg_for_outZ(img,n,(img).depth-1-(n),z)
 
#define cimg_for_borderV(img, v, n)   cimg_for_outV(img,n,(img).dim-1-(n),v)
 
#define cimg_for_borderXY(img, x, y, n)   cimg_for_outXY(img,n,n,(img).width-1-(n),(img).height-1-(n),x,y)
 
#define cimg_for_borderXYZ(img, x, y, z, n)   cimg_for_outXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)
 
#define cimg_for_borderXYZV(img, x, y, z, v, n)   cimg_for_outXYZV(img,n,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),(img).dim-1-(n),x,y,z,v)
 
#define cimg_for_spiralXY(img, x, y)
 
#define cimg_for_lineXY(x, y, x0, y0, x1, y1)
 
#define cimg_for2(bound, i)
 
#define cimg_for2X(img, x)   cimg_for2((img).width,x)
 
#define cimg_for2Y(img, y)   cimg_for2((img).height,y)
 
#define cimg_for2Z(img, z)   cimg_for2((img).depth,z)
 
#define cimg_for2V(img, v)   cimg_for2((img).dim,v)
 
#define cimg_for2XY(img, x, y)   cimg_for2Y(img,y) cimg_for2X(img,x)
 
#define cimg_for2XZ(img, x, z)   cimg_for2Z(img,z) cimg_for2X(img,x)
 
#define cimg_for2XV(img, x, v)   cimg_for2V(img,v) cimg_for2X(img,x)
 
#define cimg_for2YZ(img, y, z)   cimg_for2Z(img,z) cimg_for2Y(img,y)
 
#define cimg_for2YV(img, y, v)   cimg_for2V(img,v) cimg_for2Y(img,y)
 
#define cimg_for2ZV(img, z, v)   cimg_for2V(img,v) cimg_for2Z(img,z)
 
#define cimg_for2XYZ(img, x, y, z)   cimg_for2Z(img,z) cimg_for2XY(img,x,y)
 
#define cimg_for2XZV(img, x, z, v)   cimg_for2V(img,v) cimg_for2XZ(img,x,z)
 
#define cimg_for2YZV(img, y, z, v)   cimg_for2V(img,v) cimg_for2YZ(img,y,z)
 
#define cimg_for2XYZV(img, x, y, z, v)   cimg_for2V(img,v) cimg_for2XYZ(img,x,y,z)
 
#define cimg_for_in2(bound, i0, i1, i)
 
#define cimg_for_in2X(img, x0, x1, x)   cimg_for_in2((img).width,x0,x1,x)
 
#define cimg_for_in2Y(img, y0, y1, y)   cimg_for_in2((img).height,y0,y1,y)
 
#define cimg_for_in2Z(img, z0, z1, z)   cimg_for_in2((img).depth,z0,z1,z)
 
#define cimg_for_in2V(img, v0, v1, v)   cimg_for_in2((img).dim,v0,v1,v)
 
#define cimg_for_in2XY(img, x0, y0, x1, y1, x, y)   cimg_for_in2Y(img,y0,y1,y) cimg_for_in2X(img,x0,x1,x)
 
#define cimg_for_in2XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in2Z(img,z0,z1,z) cimg_for_in2X(img,x0,x1,x)
 
#define cimg_for_in2XV(img, x0, v0, x1, v1, x, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2X(img,x0,x1,x)
 
#define cimg_for_in2YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in2Z(img,z0,z1,z) cimg_for_in2Y(img,y0,y1,y)
 
#define cimg_for_in2YV(img, y0, v0, y1, v1, y, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2Y(img,y0,y1,y)
 
#define cimg_for_in2ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2Z(img,z0,z1,z)
 
#define cimg_for_in2XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in2Z(img,z0,z1,z) cimg_for_in2XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in2XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in2YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in2XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in2V(img,v0,v1,v) cimg_for_in2XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for3(bound, i)
 
#define cimg_for3X(img, x)   cimg_for3((img).width,x)
 
#define cimg_for3Y(img, y)   cimg_for3((img).height,y)
 
#define cimg_for3Z(img, z)   cimg_for3((img).depth,z)
 
#define cimg_for3V(img, v)   cimg_for3((img).dim,v)
 
#define cimg_for3XY(img, x, y)   cimg_for3Y(img,y) cimg_for3X(img,x)
 
#define cimg_for3XZ(img, x, z)   cimg_for3Z(img,z) cimg_for3X(img,x)
 
#define cimg_for3XV(img, x, v)   cimg_for3V(img,v) cimg_for3X(img,x)
 
#define cimg_for3YZ(img, y, z)   cimg_for3Z(img,z) cimg_for3Y(img,y)
 
#define cimg_for3YV(img, y, v)   cimg_for3V(img,v) cimg_for3Y(img,y)
 
#define cimg_for3ZV(img, z, v)   cimg_for3V(img,v) cimg_for3Z(img,z)
 
#define cimg_for3XYZ(img, x, y, z)   cimg_for3Z(img,z) cimg_for3XY(img,x,y)
 
#define cimg_for3XZV(img, x, z, v)   cimg_for3V(img,v) cimg_for3XZ(img,x,z)
 
#define cimg_for3YZV(img, y, z, v)   cimg_for3V(img,v) cimg_for3YZ(img,y,z)
 
#define cimg_for3XYZV(img, x, y, z, v)   cimg_for3V(img,v) cimg_for3XYZ(img,x,y,z)
 
#define cimg_for_in3(bound, i0, i1, i)
 
#define cimg_for_in3X(img, x0, x1, x)   cimg_for_in3((img).width,x0,x1,x)
 
#define cimg_for_in3Y(img, y0, y1, y)   cimg_for_in3((img).height,y0,y1,y)
 
#define cimg_for_in3Z(img, z0, z1, z)   cimg_for_in3((img).depth,z0,z1,z)
 
#define cimg_for_in3V(img, v0, v1, v)   cimg_for_in3((img).dim,v0,v1,v)
 
#define cimg_for_in3XY(img, x0, y0, x1, y1, x, y)   cimg_for_in3Y(img,y0,y1,y) cimg_for_in3X(img,x0,x1,x)
 
#define cimg_for_in3XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in3Z(img,z0,z1,z) cimg_for_in3X(img,x0,x1,x)
 
#define cimg_for_in3XV(img, x0, v0, x1, v1, x, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3X(img,x0,x1,x)
 
#define cimg_for_in3YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in3Z(img,z0,z1,z) cimg_for_in3Y(img,y0,y1,y)
 
#define cimg_for_in3YV(img, y0, v0, y1, v1, y, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3Y(img,y0,y1,y)
 
#define cimg_for_in3ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3Z(img,z0,z1,z)
 
#define cimg_for_in3XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in3Z(img,z0,z1,z) cimg_for_in3XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in3XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in3YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in3XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in3V(img,v0,v1,v) cimg_for_in3XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for4(bound, i)
 
#define cimg_for4X(img, x)   cimg_for4((img).width,x)
 
#define cimg_for4Y(img, y)   cimg_for4((img).height,y)
 
#define cimg_for4Z(img, z)   cimg_for4((img).depth,z)
 
#define cimg_for4V(img, v)   cimg_for4((img).dim,v)
 
#define cimg_for4XY(img, x, y)   cimg_for4Y(img,y) cimg_for4X(img,x)
 
#define cimg_for4XZ(img, x, z)   cimg_for4Z(img,z) cimg_for4X(img,x)
 
#define cimg_for4XV(img, x, v)   cimg_for4V(img,v) cimg_for4X(img,x)
 
#define cimg_for4YZ(img, y, z)   cimg_for4Z(img,z) cimg_for4Y(img,y)
 
#define cimg_for4YV(img, y, v)   cimg_for4V(img,v) cimg_for4Y(img,y)
 
#define cimg_for4ZV(img, z, v)   cimg_for4V(img,v) cimg_for4Z(img,z)
 
#define cimg_for4XYZ(img, x, y, z)   cimg_for4Z(img,z) cimg_for4XY(img,x,y)
 
#define cimg_for4XZV(img, x, z, v)   cimg_for4V(img,v) cimg_for4XZ(img,x,z)
 
#define cimg_for4YZV(img, y, z, v)   cimg_for4V(img,v) cimg_for4YZ(img,y,z)
 
#define cimg_for4XYZV(img, x, y, z, v)   cimg_for4V(img,v) cimg_for4XYZ(img,x,y,z)
 
#define cimg_for_in4(bound, i0, i1, i)
 
#define cimg_for_in4X(img, x0, x1, x)   cimg_for_in4((img).width,x0,x1,x)
 
#define cimg_for_in4Y(img, y0, y1, y)   cimg_for_in4((img).height,y0,y1,y)
 
#define cimg_for_in4Z(img, z0, z1, z)   cimg_for_in4((img).depth,z0,z1,z)
 
#define cimg_for_in4V(img, v0, v1, v)   cimg_for_in4((img).dim,v0,v1,v)
 
#define cimg_for_in4XY(img, x0, y0, x1, y1, x, y)   cimg_for_in4Y(img,y0,y1,y) cimg_for_in4X(img,x0,x1,x)
 
#define cimg_for_in4XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in4Z(img,z0,z1,z) cimg_for_in4X(img,x0,x1,x)
 
#define cimg_for_in4XV(img, x0, v0, x1, v1, x, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4X(img,x0,x1,x)
 
#define cimg_for_in4YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in4Z(img,z0,z1,z) cimg_for_in4Y(img,y0,y1,y)
 
#define cimg_for_in4YV(img, y0, v0, y1, v1, y, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4Y(img,y0,y1,y)
 
#define cimg_for_in4ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4Z(img,z0,z1,z)
 
#define cimg_for_in4XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in4Z(img,z0,z1,z) cimg_for_in4XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in4XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in4YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in4XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in4V(img,v0,v1,v) cimg_for_in4XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for5(bound, i)
 
#define cimg_for5X(img, x)   cimg_for5((img).width,x)
 
#define cimg_for5Y(img, y)   cimg_for5((img).height,y)
 
#define cimg_for5Z(img, z)   cimg_for5((img).depth,z)
 
#define cimg_for5V(img, v)   cimg_for5((img).dim,v)
 
#define cimg_for5XY(img, x, y)   cimg_for5Y(img,y) cimg_for5X(img,x)
 
#define cimg_for5XZ(img, x, z)   cimg_for5Z(img,z) cimg_for5X(img,x)
 
#define cimg_for5XV(img, x, v)   cimg_for5V(img,v) cimg_for5X(img,x)
 
#define cimg_for5YZ(img, y, z)   cimg_for5Z(img,z) cimg_for5Y(img,y)
 
#define cimg_for5YV(img, y, v)   cimg_for5V(img,v) cimg_for5Y(img,y)
 
#define cimg_for5ZV(img, z, v)   cimg_for5V(img,v) cimg_for5Z(img,z)
 
#define cimg_for5XYZ(img, x, y, z)   cimg_for5Z(img,z) cimg_for5XY(img,x,y)
 
#define cimg_for5XZV(img, x, z, v)   cimg_for5V(img,v) cimg_for5XZ(img,x,z)
 
#define cimg_for5YZV(img, y, z, v)   cimg_for5V(img,v) cimg_for5YZ(img,y,z)
 
#define cimg_for5XYZV(img, x, y, z, v)   cimg_for5V(img,v) cimg_for5XYZ(img,x,y,z)
 
#define cimg_for_in5(bound, i0, i1, i)
 
#define cimg_for_in5X(img, x0, x1, x)   cimg_for_in5((img).width,x0,x1,x)
 
#define cimg_for_in5Y(img, y0, y1, y)   cimg_for_in5((img).height,y0,y1,y)
 
#define cimg_for_in5Z(img, z0, z1, z)   cimg_for_in5((img).depth,z0,z1,z)
 
#define cimg_for_in5V(img, v0, v1, v)   cimg_for_in5((img).dim,v0,v1,v)
 
#define cimg_for_in5XY(img, x0, y0, x1, y1, x, y)   cimg_for_in5Y(img,y0,y1,y) cimg_for_in5X(img,x0,x1,x)
 
#define cimg_for_in5XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in5Z(img,z0,z1,z) cimg_for_in5X(img,x0,x1,x)
 
#define cimg_for_in5XV(img, x0, v0, x1, v1, x, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5X(img,x0,x1,x)
 
#define cimg_for_in5YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in5Z(img,z0,z1,z) cimg_for_in5Y(img,y0,y1,y)
 
#define cimg_for_in5YV(img, y0, v0, y1, v1, y, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5Y(img,y0,y1,y)
 
#define cimg_for_in5ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5Z(img,z0,z1,z)
 
#define cimg_for_in5XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in5Z(img,z0,z1,z) cimg_for_in5XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in5XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in5YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in5XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in5V(img,v0,v1,v) cimg_for_in5XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for6(bound, i)
 
#define cimg_for6X(img, x)   cimg_for6((img).width,x)
 
#define cimg_for6Y(img, y)   cimg_for6((img).height,y)
 
#define cimg_for6Z(img, z)   cimg_for6((img).depth,z)
 
#define cimg_for6V(img, v)   cimg_for6((img).dim,v)
 
#define cimg_for6XY(img, x, y)   cimg_for6Y(img,y) cimg_for6X(img,x)
 
#define cimg_for6XZ(img, x, z)   cimg_for6Z(img,z) cimg_for6X(img,x)
 
#define cimg_for6XV(img, x, v)   cimg_for6V(img,v) cimg_for6X(img,x)
 
#define cimg_for6YZ(img, y, z)   cimg_for6Z(img,z) cimg_for6Y(img,y)
 
#define cimg_for6YV(img, y, v)   cimg_for6V(img,v) cimg_for6Y(img,y)
 
#define cimg_for6ZV(img, z, v)   cimg_for6V(img,v) cimg_for6Z(img,z)
 
#define cimg_for6XYZ(img, x, y, z)   cimg_for6Z(img,z) cimg_for6XY(img,x,y)
 
#define cimg_for6XZV(img, x, z, v)   cimg_for6V(img,v) cimg_for6XZ(img,x,z)
 
#define cimg_for6YZV(img, y, z, v)   cimg_for6V(img,v) cimg_for6YZ(img,y,z)
 
#define cimg_for6XYZV(img, x, y, z, v)   cimg_for6V(img,v) cimg_for6XYZ(img,x,y,z)
 
#define cimg_for_in6(bound, i0, i1, i)
 
#define cimg_for_in6X(img, x0, x1, x)   cimg_for_in6((img).width,x0,x1,x)
 
#define cimg_for_in6Y(img, y0, y1, y)   cimg_for_in6((img).height,y0,y1,y)
 
#define cimg_for_in6Z(img, z0, z1, z)   cimg_for_in6((img).depth,z0,z1,z)
 
#define cimg_for_in6V(img, v0, v1, v)   cimg_for_in6((img).dim,v0,v1,v)
 
#define cimg_for_in6XY(img, x0, y0, x1, y1, x, y)   cimg_for_in6Y(img,y0,y1,y) cimg_for_in6X(img,x0,x1,x)
 
#define cimg_for_in6XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in6Z(img,z0,z1,z) cimg_for_in6X(img,x0,x1,x)
 
#define cimg_for_in6XV(img, x0, v0, x1, v1, x, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6X(img,x0,x1,x)
 
#define cimg_for_in6YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in6Z(img,z0,z1,z) cimg_for_in6Y(img,y0,y1,y)
 
#define cimg_for_in6YV(img, y0, v0, y1, v1, y, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6Y(img,y0,y1,y)
 
#define cimg_for_in6ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6Z(img,z0,z1,z)
 
#define cimg_for_in6XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in6Z(img,z0,z1,z) cimg_for_in6XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in6XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in6YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in6XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in6V(img,v0,v1,v) cimg_for_in6XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for7(bound, i)
 
#define cimg_for7X(img, x)   cimg_for7((img).width,x)
 
#define cimg_for7Y(img, y)   cimg_for7((img).height,y)
 
#define cimg_for7Z(img, z)   cimg_for7((img).depth,z)
 
#define cimg_for7V(img, v)   cimg_for7((img).dim,v)
 
#define cimg_for7XY(img, x, y)   cimg_for7Y(img,y) cimg_for7X(img,x)
 
#define cimg_for7XZ(img, x, z)   cimg_for7Z(img,z) cimg_for7X(img,x)
 
#define cimg_for7XV(img, x, v)   cimg_for7V(img,v) cimg_for7X(img,x)
 
#define cimg_for7YZ(img, y, z)   cimg_for7Z(img,z) cimg_for7Y(img,y)
 
#define cimg_for7YV(img, y, v)   cimg_for7V(img,v) cimg_for7Y(img,y)
 
#define cimg_for7ZV(img, z, v)   cimg_for7V(img,v) cimg_for7Z(img,z)
 
#define cimg_for7XYZ(img, x, y, z)   cimg_for7Z(img,z) cimg_for7XY(img,x,y)
 
#define cimg_for7XZV(img, x, z, v)   cimg_for7V(img,v) cimg_for7XZ(img,x,z)
 
#define cimg_for7YZV(img, y, z, v)   cimg_for7V(img,v) cimg_for7YZ(img,y,z)
 
#define cimg_for7XYZV(img, x, y, z, v)   cimg_for7V(img,v) cimg_for7XYZ(img,x,y,z)
 
#define cimg_for_in7(bound, i0, i1, i)
 
#define cimg_for_in7X(img, x0, x1, x)   cimg_for_in7((img).width,x0,x1,x)
 
#define cimg_for_in7Y(img, y0, y1, y)   cimg_for_in7((img).height,y0,y1,y)
 
#define cimg_for_in7Z(img, z0, z1, z)   cimg_for_in7((img).depth,z0,z1,z)
 
#define cimg_for_in7V(img, v0, v1, v)   cimg_for_in7((img).dim,v0,v1,v)
 
#define cimg_for_in7XY(img, x0, y0, x1, y1, x, y)   cimg_for_in7Y(img,y0,y1,y) cimg_for_in7X(img,x0,x1,x)
 
#define cimg_for_in7XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in7Z(img,z0,z1,z) cimg_for_in7X(img,x0,x1,x)
 
#define cimg_for_in7XV(img, x0, v0, x1, v1, x, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7X(img,x0,x1,x)
 
#define cimg_for_in7YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in7Z(img,z0,z1,z) cimg_for_in7Y(img,y0,y1,y)
 
#define cimg_for_in7YV(img, y0, v0, y1, v1, y, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7Y(img,y0,y1,y)
 
#define cimg_for_in7ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7Z(img,z0,z1,z)
 
#define cimg_for_in7XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in7Z(img,z0,z1,z) cimg_for_in7XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in7XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in7YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in7XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in7V(img,v0,v1,v) cimg_for_in7XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for8(bound, i)
 
#define cimg_for8X(img, x)   cimg_for8((img).width,x)
 
#define cimg_for8Y(img, y)   cimg_for8((img).height,y)
 
#define cimg_for8Z(img, z)   cimg_for8((img).depth,z)
 
#define cimg_for8V(img, v)   cimg_for8((img).dim,v)
 
#define cimg_for8XY(img, x, y)   cimg_for8Y(img,y) cimg_for8X(img,x)
 
#define cimg_for8XZ(img, x, z)   cimg_for8Z(img,z) cimg_for8X(img,x)
 
#define cimg_for8XV(img, x, v)   cimg_for8V(img,v) cimg_for8X(img,x)
 
#define cimg_for8YZ(img, y, z)   cimg_for8Z(img,z) cimg_for8Y(img,y)
 
#define cimg_for8YV(img, y, v)   cimg_for8V(img,v) cimg_for8Y(img,y)
 
#define cimg_for8ZV(img, z, v)   cimg_for8V(img,v) cimg_for8Z(img,z)
 
#define cimg_for8XYZ(img, x, y, z)   cimg_for8Z(img,z) cimg_for8XY(img,x,y)
 
#define cimg_for8XZV(img, x, z, v)   cimg_for8V(img,v) cimg_for8XZ(img,x,z)
 
#define cimg_for8YZV(img, y, z, v)   cimg_for8V(img,v) cimg_for8YZ(img,y,z)
 
#define cimg_for8XYZV(img, x, y, z, v)   cimg_for8V(img,v) cimg_for8XYZ(img,x,y,z)
 
#define cimg_for_in8(bound, i0, i1, i)
 
#define cimg_for_in8X(img, x0, x1, x)   cimg_for_in8((img).width,x0,x1,x)
 
#define cimg_for_in8Y(img, y0, y1, y)   cimg_for_in8((img).height,y0,y1,y)
 
#define cimg_for_in8Z(img, z0, z1, z)   cimg_for_in8((img).depth,z0,z1,z)
 
#define cimg_for_in8V(img, v0, v1, v)   cimg_for_in8((img).dim,v0,v1,v)
 
#define cimg_for_in8XY(img, x0, y0, x1, y1, x, y)   cimg_for_in8Y(img,y0,y1,y) cimg_for_in8X(img,x0,x1,x)
 
#define cimg_for_in8XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in8Z(img,z0,z1,z) cimg_for_in8X(img,x0,x1,x)
 
#define cimg_for_in8XV(img, x0, v0, x1, v1, x, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8X(img,x0,x1,x)
 
#define cimg_for_in8YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in8Z(img,z0,z1,z) cimg_for_in8Y(img,y0,y1,y)
 
#define cimg_for_in8YV(img, y0, v0, y1, v1, y, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8Y(img,y0,y1,y)
 
#define cimg_for_in8ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8Z(img,z0,z1,z)
 
#define cimg_for_in8XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in8Z(img,z0,z1,z) cimg_for_in8XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in8XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in8YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in8XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in8V(img,v0,v1,v) cimg_for_in8XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for9(bound, i)
 
#define cimg_for9X(img, x)   cimg_for9((img).width,x)
 
#define cimg_for9Y(img, y)   cimg_for9((img).height,y)
 
#define cimg_for9Z(img, z)   cimg_for9((img).depth,z)
 
#define cimg_for9V(img, v)   cimg_for9((img).dim,v)
 
#define cimg_for9XY(img, x, y)   cimg_for9Y(img,y) cimg_for9X(img,x)
 
#define cimg_for9XZ(img, x, z)   cimg_for9Z(img,z) cimg_for9X(img,x)
 
#define cimg_for9XV(img, x, v)   cimg_for9V(img,v) cimg_for9X(img,x)
 
#define cimg_for9YZ(img, y, z)   cimg_for9Z(img,z) cimg_for9Y(img,y)
 
#define cimg_for9YV(img, y, v)   cimg_for9V(img,v) cimg_for9Y(img,y)
 
#define cimg_for9ZV(img, z, v)   cimg_for9V(img,v) cimg_for9Z(img,z)
 
#define cimg_for9XYZ(img, x, y, z)   cimg_for9Z(img,z) cimg_for9XY(img,x,y)
 
#define cimg_for9XZV(img, x, z, v)   cimg_for9V(img,v) cimg_for9XZ(img,x,z)
 
#define cimg_for9YZV(img, y, z, v)   cimg_for9V(img,v) cimg_for9YZ(img,y,z)
 
#define cimg_for9XYZV(img, x, y, z, v)   cimg_for9V(img,v) cimg_for9XYZ(img,x,y,z)
 
#define cimg_for_in9(bound, i0, i1, i)
 
#define cimg_for_in9X(img, x0, x1, x)   cimg_for_in9((img).width,x0,x1,x)
 
#define cimg_for_in9Y(img, y0, y1, y)   cimg_for_in9((img).height,y0,y1,y)
 
#define cimg_for_in9Z(img, z0, z1, z)   cimg_for_in9((img).depth,z0,z1,z)
 
#define cimg_for_in9V(img, v0, v1, v)   cimg_for_in9((img).dim,v0,v1,v)
 
#define cimg_for_in9XY(img, x0, y0, x1, y1, x, y)   cimg_for_in9Y(img,y0,y1,y) cimg_for_in9X(img,x0,x1,x)
 
#define cimg_for_in9XZ(img, x0, z0, x1, z1, x, z)   cimg_for_in9Z(img,z0,z1,z) cimg_for_in9X(img,x0,x1,x)
 
#define cimg_for_in9XV(img, x0, v0, x1, v1, x, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9X(img,x0,x1,x)
 
#define cimg_for_in9YZ(img, y0, z0, y1, z1, y, z)   cimg_for_in9Z(img,z0,z1,z) cimg_for_in9Y(img,y0,y1,y)
 
#define cimg_for_in9YV(img, y0, v0, y1, v1, y, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9Y(img,y0,y1,y)
 
#define cimg_for_in9ZV(img, z0, v0, z1, v1, z, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9Z(img,z0,z1,z)
 
#define cimg_for_in9XYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)   cimg_for_in9Z(img,z0,z1,z) cimg_for_in9XY(img,x0,y0,x1,y1,x,y)
 
#define cimg_for_in9XZV(img, x0, z0, v0, x1, y1, v1, x, z, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9XZ(img,x0,y0,x1,y1,x,z)
 
#define cimg_for_in9YZV(img, y0, z0, v0, y1, z1, v1, y, z, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9YZ(img,y0,z0,y1,z1,y,z)
 
#define cimg_for_in9XYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)   cimg_for_in9V(img,v0,v1,v) cimg_for_in9XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
 
#define cimg_for2x2(img, x, y, z, v, I)
 
#define cimg_for_in2x2(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for3x3(img, x, y, z, v, I)
 
#define cimg_for_in3x3(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for4x4(img, x, y, z, v, I)
 
#define cimg_for_in4x4(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for5x5(img, x, y, z, v, I)
 
#define cimg_for_in5x5(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for6x6(img, x, y, z, v, I)
 
#define cimg_for_in6x6(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for7x7(img, x, y, z, v, I)
 
#define cimg_for_in7x7(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for8x8(img, x, y, z, v, I)
 
#define cimg_for_in8x8(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for9x9(img, x, y, z, v, I)
 
#define cimg_for_in9x9(img, x0, y0, x1, y1, x, y, z, v, I)
 
#define cimg_for2x2x2(img, x, y, z, v, I)
 
#define cimg_for_in2x2x2(img, x0, y0, z0, x1, y1, z1, x, y, z, v, I)
 
#define cimg_for3x3x3(img, x, y, z, v, I)
 
#define cimg_for_in3x3x3(img, x0, y0, z0, x1, y1, z1, x, y, z, v, I)
 
#define cimglist_for(list, l)   for (int l = 0; l<(int)(list).width; ++l)
 
#define cimglist_for_in(list, l0, l1, l)   for (int l = (int)(l0)<0?0:(int)(l0), _max##l = (unsigned int)l1<(list).width?(int)(l1):(int)(list).width-1; l<=_max##l; ++l)
 
#define cimglist_apply(list, fn)   cimglist_for(list,__##fn) (list)[__##fn].fn
 
#define _cimg_exception_err(etype, disp_flag)
 
#define _cimg_Tt   typename cimg::superset<T,t>::type
 
#define _cimg_Tfloat   typename cimg::superset<T,float>::type
 
#define _cimg_Ttfloat   typename cimg::superset2<T,t,float>::type
 
#define cimg_strescape(ci, co)   case ci: *nd = co; ++ns; break;
 
#define _cimg_test_temporary_path(p)
 
#define _cimg_create_ext_operators(typ)
 
#define _cimg_iskey_case(k)   if (key==cimg::key##k) is_key##k = pressed;
 
#define _CImg_stdarg(img, a0, a1, N, t)
 
#define _cimg_freturn(x)   { *se = saved_char; return x; }
 
#define _cimg_fopcode0(op)   _cimg_freturn(opcode(op));
 
#define _cimg_fopcode1(op, i1)   _cimg_freturn(opcode(op,i1));
 
#define _cimg_fopcode2(op, i1, i2)   _cimg_freturn(opcode(op,i1,i2));
 
#define _cimg_fopcode3(op, i1, i2, i3)   _cimg_freturn(opcode(op,i1,i2,i3));
 
#define _cimg_fopcode5(op, i1, i2, i3, i4, i5)   _cimg_freturn(opcode(op,i1,i2,i3,i4,i5));
 
#define _cimg_fill1(x, y, z, v, off, siz, t)
 
#define _cimg_get_label_test(p, q)
 
#define _cimg_Labf(x)   ((x)>=0.008856f?(std::pow(x,(Tfloat)1/3)):(7.787f*(x)+16.0f/116))
 
#define _cimg_Labfi(x)   ((x)>=0.206893f?((x)*(x)*(x)):(((x)-16.0f/116)/7.787f))
 
#define _cimg_gs2x_for3(bound, i)
 
#define _cimg_gs2x_for3x3(img, x, y, z, v, I)
 
#define _cimg_gs3x_for3(bound, i)
 
#define _cimg_gs3x_for3x3(img, x, y, z, v, I)
 
#define _cimg_deriche2_apply
 
#define _cimg_valign2d(i, j)   { Tfloat &u = W(i,j,0,0), &v = W(i,j,0,1); if (u*curru + v*currv<0) { u=-u; v=-v; }}
 
#define _cimg_valign3d(i, j, k)   { Tfloat &u = W(i,j,k,0), &v = W(i,j,k,1), &w = W(i,j,k,2); if (u*curru + v*currv + w*currw<0) { u=-u; v=-v; w=-w; }}
 
#define _cimg_blur_patch3d_fast(N)
 
#define _cimg_blur_patch3d(N)
 
#define _cimg_blur_patch2d_fast(N)
 
#define _cimg_blur_patch2d(N)
 
#define _cimg_median_sort(a, b)   if ((a)>(b)) cimg::swap(a,b)
 
#define _cimg_draw_fill_test(x, y, z, res)
 
#define _cimg_draw_fill_set(x, y, z)
 
#define _cimg_draw_fill_insert(x, y, z)
 
#define _cimg_draw_fill_test_neighbor(x, y, z, cond)
 
#define _cimg_load_inr_case(Tf, sign, pixsize, Ts)
 
#define __cimg_load_pandore_case(nbdim, nwidth, nheight, ndepth, ndim, stype)
 
#define _cimg_load_pandore_case(nbdim, nwidth, nheight, ndepth, dim, stype1, stype2, stype3, ltype)
 
#define __cimg_save_pandore_case(dtype)
 
#define _cimg_save_pandore_case(sy, sz, sv, stype, id)
 
#define _CImgList_stdarg(t)
 
#define _cimgz_load_cimg_case(Tss)
 
#define _cimg_load_cimg_case(Ts, Tss)
 
#define _cimg_load_cimg_case2(Ts, Tss)
 
#define _cimg_save_cimg_case(Ts, Tss)
 
Constructors / Destructor / Instance Management
#define cimg_fitscreen(dx, dy, dz)   CImgDisplay::_fitscreen(dx,dy,dz,128,-85,false),CImgDisplay::_fitscreen(dx,dy,dz,128,-85,true)
 
Drawing Functions
#define _cimg_for_triangle1(img, xl, xr, y, x0, y0, x1, y1, x2, y2)
 
#define _cimg_for_triangle2(img, xl, cl, xr, cr, y, x0, y0, c0, x1, y1, c1, x2, y2, c2)
 
#define _cimg_for_triangle3(img, xl, txl, tyl, xr, txr, tyr, y, x0, y0, tx0, ty0, x1, y1, tx1, ty1, x2, y2, tx2, ty2)
 
#define _cimg_for_triangle4(img, xl, cl, txl, tyl, xr, cr, txr, tyr, y, x0, y0, c0, tx0, ty0, x1, y1, c1, tx1, ty1, x2, y2, c2, tx2, ty2)
 
#define _cimg_for_triangle5(img, xl, txl, tyl, lxl, lyl, xr, txr, tyr, lxr, lyr, y, x0, y0, tx0, ty0, lx0, ly0, x1, y1, tx1, ty1, lx1, ly1, x2, y2, tx2, ty2, lx2, ly2)
 
Instance Checking
#define _cimglist_def_is_same1(axis)
 
#define _cimglist_def_is_same2(axis1, axis2)
 
#define _cimglist_def_is_same3(axis1, axis2, axis3)
 
#define _cimglist_def_is_same(axis)
 

Functions

void info ()
 Print informations about CImg environement variables. More...
 
unsigned int & exception_mode ()
 Get/set the current CImg exception mode. More...
 
int dialog (const char *title, const char *msg, const char *button1_txt="OK", const char *button2_txt=0, const char *button3_txt=0, const char *button4_txt=0, const char *button5_txt=0, const char *button6_txt=0, const bool centering=false)
 
double eval (const char *const expression, const double x=0, const double y=0, const double z=0, const double v=0)
 Evaluate math expression. More...
 
void warn (const char *format,...)
 Display a warning message. More...
 
int system (const char *const command, const char *const module_name=0)
 
template<typename T >
T & temporary (const T &)
 Return a reference to a temporary variable of type T. More...
 
template<typename T >
void swap (T &a, T &b)
 Exchange values of variables a and b. More...
 
template<typename T1 , typename T2 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2)
 Exchange values of variables (a1,a2) and (b1,b2). More...
 
template<typename T1 , typename T2 , typename T3 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3)
 Exchange values of variables (a1,a2,a3) and (b1,b2,b3). More...
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4)
 Exchange values of variables (a1,a2,...,a4) and (b1,b2,...,b4). More...
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4, T5 &a5, T5 &b5)
 Exchange values of variables (a1,a2,...,a5) and (b1,b2,...,b5). More...
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4, T5 &a5, T5 &b5, T6 &a6, T6 &b6)
 Exchange values of variables (a1,a2,...,a6) and (b1,b2,...,b6). More...
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4, T5 &a5, T5 &b5, T6 &a6, T6 &b6, T7 &a7, T7 &b7)
 Exchange values of variables (a1,a2,...,a7) and (b1,b2,...,b7). More...
 
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
void swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4, T5 &a5, T5 &b5, T6 &a6, T6 &b6, T7 &a7, T7 &b7, T8 &a8, T8 &b8)
 Exchange values of variables (a1,a2,...,a8) and (b1,b2,...,b8). More...
 
bool endianness ()
 Return the current endianness of the CPU. More...
 
template<typename T >
void invert_endianness (T *const buffer, const unsigned int size)
 Invert endianness of a memory buffer. More...
 
template<typename T >
T & invert_endianness (T &a)
 Invert endianness of a single variable. More...
 
unsigned long time ()
 Get the value of a system timer with a millisecond precision. More...
 
void sleep (const unsigned int milliseconds)
 Sleep for a certain numbers of milliseconds. More...
 
unsigned int _sleep (const unsigned int milliseconds, unsigned long &timer)
 
unsigned int wait (const unsigned int milliseconds)
 Wait for a certain number of milliseconds since the last call. More...
 
void srand ()
 
template<typename T >
const T rol (const T a, const unsigned int n=1)
 Return a left bitwise-rotated number. More...
 
template<typename T >
const T ror (const T a, const unsigned int n=1)
 Return a right bitwise-rotated number. More...
 
template<typename T >
T abs (const T a)
 Return the absolute value of a number. More...
 
bool abs (const bool a)
 
unsigned char abs (const unsigned char a)
 
unsigned short abs (const unsigned short a)
 
unsigned int abs (const unsigned int a)
 
unsigned long abs (const unsigned long a)
 
double abs (const double a)
 
float abs (const float a)
 
int abs (const int a)
 
template<typename T >
T sqr (const T val)
 Return the square of a number. More...
 
int xln (const int x)
 Return 1 + log_10(x). More...
 
template<typename t1 , typename t2 >
cimg::superset< t1, t2 >::type min (const t1 &a, const t2 &b)
 Return the minimum value between two numbers. More...
 
template<typename t1 , typename t2 , typename t3 >
cimg::superset2< t1, t2, t3 >::type min (const t1 &a, const t2 &b, const t3 &c)
 Return the minimum value between three numbers. More...
 
template<typename t1 , typename t2 , typename t3 , typename t4 >
cimg::superset3< t1, t2, t3,
t4 >::type 		min (const t1 &a, const t2 &b, const t3 &c, const t4 &d)
 Return the minimum value between four numbers. More...
 
template<typename t1 , typename t2 >
cimg::superset< t1, t2 >::type max (const t1 &a, const t2 &b)
 Return the maximum value between two numbers. More...
 
template<typename t1 , typename t2 , typename t3 >
cimg::superset2< t1, t2, t3 >::type max (const t1 &a, const t2 &b, const t3 &c)
 Return the maximum value between three numbers. More...
 
template<typename t1 , typename t2 , typename t3 , typename t4 >
cimg::superset3< t1, t2, t3,
t4 >::type 		max (const t1 &a, const t2 &b, const t3 &c, const t4 &d)
 Return the maximum value between four numbers. More...
 
template<typename T >
T sign (const T x)
 Return the sign of a number. More...
 
template<typename T >
unsigned int nearest_pow2 (const T x)
 Return the nearest power of 2 higher than a given number. More...
 
template<typename T >
T mod (const T &x, const T &m)
 Return the modulo of a number. More...
 
int mod (const bool x, const bool m)
 
int mod (const char x, const char m)
 
int mod (const short x, const short m)
 
int mod (const int x, const int m)
 
int mod (const long x, const long m)
 
int mod (const unsigned char x, const unsigned char m)
 
int mod (const unsigned short x, const unsigned short m)
 
int mod (const unsigned int x, const unsigned int m)
 
int mod (const unsigned long x, const unsigned long m)
 
template<typename T >
T minmod (const T a, const T b)
 Return the minmod of two numbers. More...
 
double rand ()
 Return a random variable between [0,1] with respect to an uniform distribution. More...
 
double crand ()
 Return a random variable between [-1,1] with respect to an uniform distribution. More...
 
double grand ()
 Return a random variable following a gaussian distribution and a standard deviation of 1. More...
 
unsigned int prand (const double z)
 Return a random variable following a Poisson distribution of parameter z. More...
 
double round (const double x, const double y, const int rounding_type=0)
 Return a rounded number. More...
 
double _pythagore (double a, double b)
 
char uncase (const char x)
 Remove the 'case' of an ASCII character. More...
 
void uncase (char *const string)
 Remove the 'case' of a C string. More...
 
float atof (const char *const str)
 Read a float number from a C-string. More...
 
int strncasecmp (const char *const s1, const char *const s2, const int l)
 Compare the first n characters of two C-strings, ignoring the case. More...
 
int strcasecmp (const char *const s1, const char *const s2)
 Compare two C-strings, ignoring the case. More...
 
bool strpare (char *const s, const char delimiter=' ', const bool symmetric=false)
 Remove useless delimiters on the borders of a C-string. More...
 
void strclean (char *const s)
 Remove useless spaces and symmetric delimiters ', " and ` from a C-string. More...
 
void strescape (char *const s)
 Replace explicit escape sequences '' in C-strings. More...
 
const char * basename (const char *const s)
 Compute the basename of a filename. More...
 
const char * filenamerand ()
 
void winformat_string (char *const s)
 
const char * temporary_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to store temporary files. More...
 
const char * imagemagick_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to the ImageMagick's convert tool. More...
 
const char * graphicsmagick_path (const char *const user_path=0, const bool reinit_path=false)
 Return path of the GraphicsMagick's gm tool. More...
 
const char * medcon_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path of the XMedcon tool. More...
 
const char * ffmpeg_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to the 'ffmpeg' command. More...
 
const char * gzip_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to the 'gzip' command. More...
 
const char * gunzip_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to the 'gunzip' command. More...
 
const char * dcraw_path (const char *const user_path=0, const bool reinit_path=false)
 Return or set path to the 'dcraw' command. More...
 
const char * split_filename (const char *const filename, char *const body=0)
 Split a filename into two strings 'body' and 'extension'. More...
 
char * number_filename (const char *const filename, const int number, const unsigned int n, char *const string)
 Create a numbered version of a filename. More...
 
std::FILE * fopen (const char *const path, const char *const mode)
 Open a file, and check for possible errors. More...
 
int fclose (std::FILE *file)
 Close a file, and check for possible errors. More...
 
const char * file_type (std::FILE *const file, const char *const filename)
 Try to guess the image format of a filename, using its magick numbers. More...
 
template<typename T >
int fread (T *const ptr, const unsigned int nmemb, std::FILE *stream)
 Read file data, and check for possible errors. More...
 
template<typename T >
int fwrite (const T *ptr, const unsigned int nmemb, std::FILE *stream)
 Write data to a file, and check for possible errors. More...
 
const char * option (const char *const name, const int argc, const char *const *const argv, const char *defaut, const char *const usage=0)
 
bool option (const char *const name, const int argc, const char *const *const argv, const bool defaut, const char *const usage=0)
 
int option (const char *const name, const int argc, const char *const *const argv, const int defaut, const char *const usage=0)
 
char option (const char *const name, const int argc, const char *const *const argv, const char defaut, const char *const usage=0)
 
float option (const char *const name, const int argc, const char *const *const argv, const float defaut, const char *const usage=0)
 
double option (const char *const name, const int argc, const char *const *const argv, const double defaut, const char *const usage=0)
 
const char * argument (const unsigned int nb, const int argc, const char *const *const argv, const unsigned int nb_singles=0,...)
 
template<typename T >
CImg< _cimg_Tfloat > operator+ (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< _cimg_Tfloat > operator- (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< _cimg_Tfloat > operator* (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< _cimg_Tfloat > operator/ (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< T > operator& (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< T > operator| (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< T > operator^ (const char *const expression, const CImg< T > &img)
 
template<typename T >
CImg< _cimg_Tfloat > sqr (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > sqrt (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > exp (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > log (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > log10 (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > abs (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > cos (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > sin (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > tan (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > acos (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > asin (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > atan (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > cosh (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > sinh (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > tanh (const CImg< T > &instance)
 
template<typename T >
CImg< T > transpose (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > invert (const CImg< T > &instance)
 
template<typename T >
CImg< _cimg_Tfloat > pseudoinvert (const CImg< T > &instance)
 
template<typename t >
int dialog (const char *title, const char *msg, const char *button1_txt, const char *button2_txt, const char *button3_txt, const char *button4_txt, const char *button5_txt, const char *button6_txt, const CImg< t > &logo, const bool centering=false)
 Display a dialog box, where a user can click standard buttons. More...
 

Variables

const char t_normal [] = { 0 }
 
const char *const t_red = cimg::t_normal
 
const char *const *const t_bold = cimg::t_normal
 
const char *const *const *const t_purple = cimg::t_normal
 
const char *const *const
*const *const 		t_green = cimg::t_normal
 
const unsigned int keyESC = 1U
 
const unsigned int keyF1 = 2U
 
const unsigned int keyF2 = 3U
 
const unsigned int keyF3 = 4U
 
const unsigned int keyF4 = 5U
 
const unsigned int keyF5 = 6U
 
const unsigned int keyF6 = 7U
 
const unsigned int keyF7 = 8U
 
const unsigned int keyF8 = 9U
 
const unsigned int keyF9 = 10U
 
const unsigned int keyF10 = 11U
 
const unsigned int keyF11 = 12U
 
const unsigned int keyF12 = 13U
 
const unsigned int keyPAUSE = 14U
 
const unsigned int key1 = 15U
 
const unsigned int key2 = 16U
 
const unsigned int key3 = 17U
 
const unsigned int key4 = 18U
 
const unsigned int key5 = 19U
 
const unsigned int key6 = 20U
 
const unsigned int key7 = 21U
 
const unsigned int key8 = 22U
 
const unsigned int key9 = 23U
 
const unsigned int key0 = 24U
 
const unsigned int keyBACKSPACE = 25U
 
const unsigned int keyINSERT = 26U
 
const unsigned int keyHOME = 27U
 
const unsigned int keyPAGEUP = 28U
 
const unsigned int keyTAB = 29U
 
const unsigned int keyQ = 30U
 
const unsigned int keyW = 31U
 
const unsigned int keyE = 32U
 
const unsigned int keyR = 33U
 
const unsigned int keyT = 34U
 
const unsigned int keyY = 35U
 
const unsigned int keyU = 36U
 
const unsigned int keyI = 37U
 
const unsigned int keyO = 38U
 
const unsigned int keyP = 39U
 
const unsigned int keyDELETE = 40U
 
const unsigned int keyEND = 41U
 
const unsigned int keyPAGEDOWN = 42U
 
const unsigned int keyCAPSLOCK = 43U
 
const unsigned int keyA = 44U
 
const unsigned int keyS = 45U
 
const unsigned int keyD = 46U
 
const unsigned int keyF = 47U
 
const unsigned int keyG = 48U
 
const unsigned int keyH = 49U
 
const unsigned int keyJ = 50U
 
const unsigned int keyK = 51U
 
const unsigned int keyL = 52U
 
const unsigned int keyENTER = 53U
 
const unsigned int keySHIFTLEFT = 54U
 
const unsigned int keyZ = 55U
 
const unsigned int keyX = 56U
 
const unsigned int keyC = 57U
 
const unsigned int keyV = 58U
 
const unsigned int keyB = 59U
 
const unsigned int keyN = 60U
 
const unsigned int keyM = 61U
 
const unsigned int keySHIFTRIGHT = 62U
 
const unsigned int keyARROWUP = 63U
 
const unsigned int keyCTRLLEFT = 64U
 
const unsigned int keyAPPLEFT = 65U
 
const unsigned int keyALT = 66U
 
const unsigned int keySPACE = 67U
 
const unsigned int keyALTGR = 68U
 
const unsigned int keyAPPRIGHT = 69U
 
const unsigned int keyMENU = 70U
 
const unsigned int keyCTRLRIGHT = 71U
 
const unsigned int keyARROWLEFT = 72U
 
const unsigned int keyARROWDOWN = 73U
 
const unsigned int keyARROWRIGHT = 74U
 
const unsigned int keyPAD0 = 75U
 
const unsigned int keyPAD1 = 76U
 
const unsigned int keyPAD2 = 77U
 
const unsigned int keyPAD3 = 78U
 
const unsigned int keyPAD4 = 79U
 
const unsigned int keyPAD5 = 80U
 
const unsigned int keyPAD6 = 81U
 
const unsigned int keyPAD7 = 82U
 
const unsigned int keyPAD8 = 83U
 
const unsigned int keyPAD9 = 84U
 
const unsigned int keyPADADD = 85U
 
const unsigned int keyPADSUB = 86U
 
const unsigned int keyPADMUL = 87U
 
const unsigned int keyPADDIV = 88U
 
const double valuePI = 3.14159265358979323846
 Definition of the mathematical constant PI. More...
 
const unsigned int font7x11 [7 *11 *256/32]
 
const unsigned int font10x13 [256 *10 *13/32]
 
const unsigned int font8x17 [8 *17 *256/32]
 
const unsigned int font10x19 [10 *19 *256/32]
 
const unsigned int font12x24 [12 *24 *256/32]
 
const unsigned int font16x32 [16 *32 *256/32]
 
const unsigned int font19x38 [19 *38 *256/32]
 
const unsigned int font29x57 [29 *57 *256/32]
 
const unsigned char logo40x38 [4576]
 

Macro Definition Documentation

#define __cimg_load_pandore_case (   nbdim,
  nwidth,
  nheight,
  ndepth,
  ndim,
  stype 
)
Value:
cimg::fread(dims,nbdim,nfile); \
if (endian) cimg::invert_endianness(dims,nbdim); \
assign(nwidth,nheight,ndepth,ndim); \
const unsigned int siz = size(); \
stype *buffer = new stype[siz]; \
cimg::fread(buffer,siz,nfile); \
if (endian) cimg::invert_endianness(buffer,siz); \
T *ptrd = data; \
cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++); \
buffer-=siz; \
delete[] buffer
if
if(dy > dx)
Definition: rational_rotation.h:90
cimg_library::cimg::fread
int fread(T *const ptr, const unsigned int nmemb, std::FILE *stream)
Read file data, and check for possible errors.
Definition: CImg.h:5569
cimg_library::cimg::invert_endianness
void invert_endianness(T *const buffer, const unsigned int size)
Invert endianness of a memory buffer.
Definition: CImg.h:4579
CGAL::assign
bool assign(T &t, const Object &o)
Definition: Object.h:138
cimg_foroff
#define cimg_foroff(img, off)
Definition: CImg.h:590
#define __cimg_save_pandore_case (   dtype)
Value:
dtype *buffer = new dtype[size()]; \
const T *ptrs = data; \
cimg_foroff(*this,off) *(buffer++) = (dtype)(*(ptrs++)); \
buffer-=size(); \
cimg::fwrite(buffer,size(),nfile); \
delete[] buffer
cimg_library::cimg::fwrite
int fwrite(const T *ptr, const unsigned int nmemb, std::FILE *stream)
Write data to a file, and check for possible errors.
Definition: CImg.h:5587
cimg_foroff
#define cimg_foroff(img, off)
Definition: CImg.h:590
#define _cimg_blur_patch2d (   N)
Value:
cimg_for##N##XY(res,x,y) { \
cimg_forV(res,k) cimg_get##N##x##N(img,x,y,0,k,P.ptr(N2*k)); \
const int x0 = x-rsize1, y0 = y-rsize1, x1 = x+rsize2, y1 = y+rsize2; \
float sum_weights = 0; \
cimg_for_in##N##XY(res,x0,y0,x1,y1,p,q) { \
cimg_forV(res,k) cimg_get##N##x##N(img,p,q,0,k,Q.ptr(N2*k)); \
float distance2 = 0; \
const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP-(float)*(--pQ); distance2+=dI*dI; } \
distance2/=Pnorm; \
const float dx = (float)p-x, dy = (float)q-y, \
alldist = distance2 + (dx*dx+dy*dy)/sigma_s2, weight = (float)std::exp(-alldist); \
sum_weights+=weight; \
cimg_forV(res,k) res(x,y,k)+=weight*(*this)(p,q,k); \
} \
if (sum_weights>0) cimg_forV(res,k) res(x,y,k)/=sum_weights; \
else cimg_forV(res,k) res(x,y,k) = (Tfloat)((*this)(x,y,k)); \
}
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
cimg_for
#define cimg_for(img, ptr, T_ptr)
Definition: CImg.h:589
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::get_blur_patch().

#define _cimg_blur_patch2d_fast (   N)
Value:
cimg_for##N##XY(res,x,y) { \
cimg_forV(res,k) cimg_get##N##x##N(img,x,y,0,k,P.ptr(N2*k)); \
const int x0 = x-rsize1, y0 = y-rsize1, x1 = x+rsize2, y1 = y+rsize2; \
float sum_weights = 0; \
cimg_for_in##N##XY(res,x0,y0,x1,y1,p,q) if (cimg::abs(img(x,y,0,0)-img(p,q,0,0))<sigma_p3) { \
cimg_forV(res,k) cimg_get##N##x##N(img,p,q,0,k,Q.ptr(N2*k)); \
float distance2 = 0; \
const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP-(float)*(--pQ); distance2+=dI*dI; } \
distance2/=Pnorm; \
const float dx = (float)p-x, dy = (float)q-y, \
alldist = distance2 + (dx*dx+dy*dy)/sigma_s2, weight = alldist>3?0.0f:1.0f; \
sum_weights+=weight; \
cimg_forV(res,k) res(x,y,k)+=weight*(*this)(p,q,k); \
} \
if (sum_weights>0) cimg_forV(res,k) res(x,y,k)/=sum_weights; \
else cimg_forV(res,k) res(x,y,k) = (Tfloat)((*this)(x,y,k)); \
}
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
cimg_for
#define cimg_for(img, ptr, T_ptr)
Definition: CImg.h:589
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::get_blur_patch().

#define _cimg_blur_patch3d (   N)
Value:
cimg_for##N##XYZ(res,x,y,z) { \
cimg_forV(res,k) cimg_get##N##x##N##x##N(img,x,y,z,k,P.ptr(N3*k)); \
const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2; \
float sum_weights = 0; \
cimg_for_in##N##XYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) { \
cimg_forV(res,k) cimg_get##N##x##N##x##N(img,p,q,r,k,Q.ptr(N3*k)); \
float distance2 = 0; \
const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP - (float)*(--pQ); distance2+=dI*dI; } \
distance2/=Pnorm; \
const float dx = (float)p - x, dy = (float)q - y, dz = (float)r - z, \
alldist = distance2 + (dx*dx + dy*dy + dz*dz)/sigma_s2, weight = (float)std::exp(-alldist); \
sum_weights+=weight; \
cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k); \
} \
if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights; \
else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k)); \
}
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
cimg_for
#define cimg_for(img, ptr, T_ptr)
Definition: CImg.h:589
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::get_blur_patch().

#define _cimg_blur_patch3d_fast (   N)
Value:
cimg_for##N##XYZ(res,x,y,z) { \
cimg_forV(res,k) cimg_get##N##x##N##x##N(img,x,y,z,k,P.ptr(N3*k)); \
const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2; \
float sum_weights = 0; \
cimg_for_in##N##XYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) if (cimg::abs(img(x,y,z,0)-img(p,q,r,0))<sigma_p3) { \
cimg_forV(res,k) cimg_get##N##x##N##x##N(img,p,q,r,k,Q.ptr(N3*k)); \
float distance2 = 0; \
const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP - (float)*(--pQ); distance2+=dI*dI; } \
distance2/=Pnorm; \
const float dx = (float)p - x, dy = (float)q - y, dz = (float)r - z, \
alldist = distance2 + (dx*dx + dy*dy + dz*dz)/sigma_s2, weight = alldist>3?0.0f:1.0f; \
sum_weights+=weight; \
cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k); \
} \
if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights; \
else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k)); \
}
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
cimg_for
#define cimg_for(img, ptr, T_ptr)
Definition: CImg.h:589
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::get_blur_patch().

#define _cimg_create_ext_operators (   typ)
Value:
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator+(const typ val, const CImg<T>& img) { \
return img + val; \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator-(const typ val, const CImg<T>& img) { \
typedef typename cimg::superset<T,typ>::type Tt; \
return CImg<Tt>(img.width,img.height,img.depth,img.dim,val)-=img; \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator*(const typ val, const CImg<T>& img) { \
return img*val; \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator/(const typ val, const CImg<T>& img) { \
return val*img.get_invert(); \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator&(const typ val, const CImg<T>& img) { \
return img & val; \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator|(const typ val, const CImg<T>& img) { \
return img | val; \
} \
template<typename T> \
inline CImg<typename cimg::superset<T,typ>::type> operator^(const typ val, const CImg<T>& img) { \
return img ^ val; \
} \
operator*
Vector_3< T > operator*(T t, const Vector_3< T > &v)
Definition: mapbasic.h:139
operator+
Iterator_from_circulator< C, Ref, Ptr > operator+(Dist n, const Iterator_from_circulator< C, Ref, Ptr > &circ)
Definition: circulator.h:689
cimg_library::operator|
CImg< T > operator|(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5996
cimg_library::operator^
CImg< T > operator^(const char *const expression, const CImg< T > &img)
Definition: CImg.h:6001
cimg_library::operator&
CImg< T > operator&(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5991
operator/
Vector_n operator/(const Array_n_const &v1, Real a)
Definition: Vector_n.h:323
operator-
Point_2< R > operator-(const Origin &o, const Vector_2< R > &v)
Definition: point_vector_definitions_2.C:98

Definition at line 5926 of file CImg.h.

#define _cimg_deriche2_apply
Value:
Tfloat *ptrY = Y.data, yb = 0, yp = 0; \
T xp = (T)0; \
if (cond) { xp = *ptrX; yb = yp = (Tfloat)(coefp*xp); } \
for (int m = 0; m<N; ++m) { \
const T xc = *ptrX; ptrX+=off; \
const Tfloat yc = *(ptrY++) = (Tfloat)(a0*xc + a1*xp - b1*yp - b2*yb); \
xp = xc; yb = yp; yp = yc; \
} \
T xn = (T)0, xa = (T)0; \
Tfloat yn = 0, ya = 0; \
if (cond) { xn = xa = *(ptrX-off); yn = ya = (Tfloat)coefn*xn; } \
for (int n = N-1; n>=0; --n) { \
const T xc = *(ptrX-=off); \
const Tfloat yc = (Tfloat)(a2*xn + a3*xa - b1*yn - b2*ya); \
xa = xn; xn = xc; ya = yn; yn = yc; \
*ptrX = (T)(*(--ptrY)+yc); \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
n
const NT & n
Definition: rational_rotation.h:72
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::deriche().

#define _cimg_draw_fill_insert (   x,
  y,
  z 
)
Value:
{ \
if (posr1>=remaining.height) remaining.resize(3,remaining.height<<1,1,1,0); \
unsigned int *ptrr = remaining.ptr(0,posr1); \
*(ptrr++) = x; *(ptrr++) = y; *(ptrr++) = z; ++posr1; \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
#define _cimg_draw_fill_set (   x,
  y,
  z 
)
Value:
{ \
const tc *col = color; \
T *ptrd = ptr(x,y,z); \
if (opacity>=1) cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=whz; } \
else cimg_forV(*this,k) { *ptrd = (T)(*(col++)*nopacity + *ptrd*copacity); ptrd+=whz; } \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
else
else
Definition: rational_rotation.h:103
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::draw_fill().

#define _cimg_draw_fill_test (   x,
  y,
  z,
  res 
)
Value:
if (region(x,y,z)) res = false; else { \
res = true; \
const T *reference_col = reference_color.ptr() + dim, *ptrs = ptr(x,y,z) + siz; \
for (unsigned int i = dim; res && i; --i) { ptrs-=whz; res = (cimg::abs(*ptrs - *(--reference_col))<=sigma); } \
region(x,y,z) = (t)(res?1:noregion); \
}
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
i
blockLoc i
Definition: read.cpp:79
x
void int int REAL * x
Definition: read.cpp:74
NTS::abs
NT abs(const NT &x)
Definition: number_utils.h:130
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::draw_fill().

#define _cimg_draw_fill_test_neighbor (   x,
  y,
  z,
  cond 
)
Value:
if (cond) { \
const unsigned int tx = x, ty = y, tz = z; \
_cimg_draw_fill_test(tx,ty,tz,res); if (res) _cimg_draw_fill_insert(tx,ty,tz); \
}
y
void int int REAL REAL * y
Definition: read.cpp:74
_cimg_draw_fill_test
#define _cimg_draw_fill_test(x, y, z, res)
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
_cimg_draw_fill_insert
#define _cimg_draw_fill_insert(x, y, z)

Referenced by CImg< uintT >::draw_fill().

#define _cimg_exception_err (   etype,
  disp_flag 
)
Value:
std::va_list ap; va_start(ap,format); std::vsprintf(message,format,ap); va_end(ap); \
switch (cimg::exception_mode()) { \
case 0 : break; \
case 2 : case 4 : try { cimg::dialog(etype,message,"Abort"); } catch (CImgException&) { \
std::fprintf(cimg_stdout,"\n%s# %s%s :\n%s\n\n",cimg::t_red,etype,cimg::t_normal,message); \
} break; \
default : std::fprintf(cimg_stdout,"\n%s# %s%s :\n%s\n\n",cimg::t_red,etype,cimg::t_normal,message); \
} \
if (cimg::exception_mode()>=3) cimg_library::cimg::info();
if
if(dy > dx)
Definition: rational_rotation.h:90
cimg_library::cimg::t_normal
const char t_normal[]
Definition: CImg.h:1923
cimg_library::cimg::exception_mode
unsigned int & exception_mode()
Get/set the current CImg exception mode.
Definition: CImg.h:1940
cimg_library::cimg::t_red
const char *const t_red
Definition: CImg.h:1924
cimg_stdout
#define cimg_stdout
Definition: CImg.h:136
cimg_library::cimg::dialog
int dialog(const char *title, const char *msg, const char *button1_txt="OK", const char *button2_txt=0, const char *button3_txt=0, const char *button4_txt=0, const char *button5_txt=0, const char *button6_txt=0, const bool centering=false)
Definition: CImg.h:37329
cimg_library::cimg::info
void info()
Print informations about CImg environement variables.
Definition: CImg.h:5702

Definition at line 2021 of file CImg.h.

Referenced by CImgArgumentException::CImgArgumentException(), CImgDisplayException::CImgDisplayException(), CImgException::CImgException(), CImgInstanceException::CImgInstanceException(), CImgIOException::CImgIOException(), and CImgWarningException::CImgWarningException().

#define _cimg_fill1 (   x,
  y,
  z,
  v,
  off,
  siz,
  t 
)
Value:
{ \
va_list ap; va_start(ap,a0); T *ptrd = ptr(x,y,z,v); *ptrd = (T)a0; \
for (unsigned int k = 1; k<siz; ++k) { ptrd+=off; *ptrd = (T)va_arg(ap,t); } \
va_end(ap); }
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::fillV(), CImg< uintT >::fillX(), CImg< uintT >::fillY(), and CImg< uintT >::fillZ().

#define _cimg_fopcode0 (   op)    _cimg_freturn(opcode(op));

Definition at line 12225 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_fopcode1 (   op,
  i1 
)    _cimg_freturn(opcode(op,i1));

Definition at line 12226 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_fopcode2 (   op,
  i1,
  i2 
)    _cimg_freturn(opcode(op,i1,i2));

Definition at line 12227 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_fopcode3 (   op,
  i1,
  i2,
  i3 
)    _cimg_freturn(opcode(op,i1,i2,i3));

Definition at line 12228 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_fopcode5 (   op,
  i1,
  i2,
  i3,
  i4,
  i5 
)    _cimg_freturn(opcode(op,i1,i2,i3,i4,i5));

Definition at line 12229 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_for_triangle1 (   img,
  xl,
  xr,
  y,
  x0,
  y0,
  x1,
  y1,
  x2,
  y2 
)
Value:
for (int y = y0<0?0:y0, \
xr = y0>=0?x0:(x0-y0*(x2-x0)/(y2-y0)), \
xl = y1>=0?(y0>=0?(y0==y1?x1:x0):(x0-y0*(x1-x0)/(y1-y0))):(x1-y1*(x2-x1)/(y2-y1)), \
_sxn=1, \
_sxr=1, \
_sxl=1, \
_dxn = x2>x1?x2-x1:(_sxn=-1,x1-x2), \
_dxr = x2>x0?x2-x0:(_sxr=-1,x0-x2), \
_dxl = x1>x0?x1-x0:(_sxl=-1,x0-x1), \
_dyn = y2-y1, \
_dyr = y2-y0, \
_dyl = y1-y0, \
_counter = (_dxn-=_dyn?_dyn*(_dxn/_dyn):0, \
_dxr-=_dyr?_dyr*(_dxr/_dyr):0, \
_dxl-=_dyl?_dyl*(_dxl/_dyl):0, \
cimg::min((int)(img).height-y-1,y2-y)), \
_errn = _dyn/2, \
_errr = _dyr/2, \
_errl = _dyl/2, \
_rxn = _dyn?(x2-x1)/_dyn:0, \
_rxr = _dyr?(x2-x0)/_dyr:0, \
_rxl = (y0!=y1 && y1>0)?(_dyl?(x1-x0)/_dyl:0): \
(_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxn); \
_counter>=0; --_counter, ++y, \
xr+=_rxr+((_errr-=_dxr)<0?_errr+=_dyr,_sxr:0), \
xl+=(y!=y1)?_rxl+((_errl-=_dxl)<0?(_errl+=_dyl,_sxl):0): \
(_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxl=_rxn, x1-xl))
y
void int int REAL REAL * y
Definition: read.cpp:74
min
Vector_n min(const Array_n_const &v1, const Array_n_const &v2)
Definition: Vector_n.h:346

Definition at line 23480 of file CImg.h.

Referenced by CImg< uintT >::_draw_triangle(), and CImg< uintT >::draw_triangle().

#define _cimg_for_triangle2 (   img,
  xl,
  cl,
  xr,
  cr,
  y,
  x0,
  y0,
  c0,
  x1,
  y1,
  c1,
  x2,
  y2,
  c2 
)

Definition at line 23509 of file CImg.h.

Referenced by CImg< uintT >::draw_triangle().

#define _cimg_for_triangle3 (   img,
  xl,
  txl,
  tyl,
  xr,
  txr,
  tyr,
  y,
  x0,
  y0,
  tx0,
  ty0,
  x1,
  y1,
  tx1,
  ty1,
  x2,
  y2,
  tx2,
  ty2 
)

Definition at line 23553 of file CImg.h.

Referenced by CImg< uintT >::draw_triangle().

#define _cimg_for_triangle4 (   img,
  xl,
  cl,
  txl,
  tyl,
  xr,
  cr,
  txr,
  tyr,
  y,
  x0,
  y0,
  c0,
  tx0,
  ty0,
  x1,
  y1,
  c1,
  tx1,
  ty1,
  x2,
  y2,
  c2,
  tx2,
  ty2 
)

Definition at line 23612 of file CImg.h.

Referenced by CImg< uintT >::draw_triangle().

#define _cimg_for_triangle5 (   img,
  xl,
  txl,
  tyl,
  lxl,
  lyl,
  xr,
  txr,
  tyr,
  lxr,
  lyr,
  y,
  x0,
  y0,
  tx0,
  ty0,
  lx0,
  ly0,
  x1,
  y1,
  tx1,
  ty1,
  lx1,
  ly1,
  x2,
  y2,
  tx2,
  ty2,
  lx2,
  ly2 
)

Definition at line 23686 of file CImg.h.

Referenced by CImg< uintT >::draw_triangle().

#define _cimg_freturn (   x)    { *se = saved_char; return x; }

Definition at line 12224 of file CImg.h.

Referenced by CImg< T >::_cimg_math_parser::compile().

#define _cimg_get_label_test (   p,
  q 
)
Value:
{ \
flag = true; \
const T *ptr1 = ptr(x,y) + siz, *ptr2 = ptr(p,q) + siz; \
for (unsigned int i = dim; flag && i; --i) { ptr1-=wh; ptr2-=wh; flag = (*ptr1==*ptr2); } \
}
y
void int int REAL REAL * y
Definition: read.cpp:74
i
blockLoc i
Definition: read.cpp:79
x
void int int REAL * x
Definition: read.cpp:74
q
NT q
Definition: rational_rotation.h:105
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::get_label_regions().

#define _cimg_gs2x_for3 (   bound,
  i 
)
Value:
for (int i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1; \
_n1##i<(int)(bound) || i==--_n1##i; \
_p1##i = i++, ++_n1##i, ptrd1+=(res).width, ptrd2+=(res).width)
i
blockLoc i
Definition: read.cpp:79
#define _cimg_gs2x_for3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
_cimg_gs2x_for3((img).height,y) for (int x = 0, \
_p1##x = 0, \
_n1##x = (int)( \
(I[1] = (img)(0,_p1##y,z,v)), \
(I[3] = I[4] = (img)(0,y,z,v)), \
(I[7] = (img)(0,_n1##y,z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[5] = (img)(_n1##x,y,z,v)), \
(I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x; \
I[1] = I[2], \
I[3] = I[4], I[4] = I[5], \
I[7] = I[8], \
_p1##x = x++, ++_n1##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
_cimg_gs2x_for3
#define _cimg_gs2x_for3(bound, i)
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::get_resize_doubleXY().

#define _cimg_gs3x_for3 (   bound,
  i 
)
Value:
for (int i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1; \
_n1##i<(int)(bound) || i==--_n1##i; \
_p1##i = i++, ++_n1##i, ptrd1+=2*(res).width, ptrd2+=2*(res).width, ptrd3+=2*(res).width)
i
blockLoc i
Definition: read.cpp:79
#define _cimg_gs3x_for3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
_cimg_gs3x_for3((img).height,y) for (int x = 0, \
_p1##x = 0, \
_n1##x = (int)( \
(I[0] = I[1] = (img)(0,_p1##y,z,v)), \
(I[3] = I[4] = (img)(0,y,z,v)), \
(I[6] = I[7] = (img)(0,_n1##y,z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[5] = (img)(_n1##x,y,z,v)), \
(I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x; \
I[0] = I[1], I[1] = I[2], \
I[3] = I[4], I[4] = I[5], \
I[6] = I[7], I[7] = I[8], \
_p1##x = x++, ++_n1##x)
_cimg_gs3x_for3
#define _cimg_gs3x_for3(bound, i)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::get_resize_tripleXY().

#define _cimg_iskey_case (   k)    if (key==cimg::key##k) is_key##k = pressed;

Referenced by CImgDisplay::_update_iskey().

#define _cimg_Labf (   x)    ((x)>=0.008856f?(std::pow(x,(Tfloat)1/3)):(7.787f*(x)+16.0f/116))

Referenced by CImg< uintT >::XYZtoLab().

#define _cimg_Labfi (   x)    ((x)>=0.206893f?((x)*(x)*(x)):(((x)-16.0f/116)/7.787f))

Referenced by CImg< uintT >::LabtoXYZ().

#define _cimg_load_cimg_case (   Ts,
  Tss 
)
Value:
if (!loaded && !cimg::strcasecmp(Ts,str_pixeltype)) { \
for (unsigned int l = 0; l<N; ++l) { \
j = 0; while ((i=std::fgetc(nfile))!='\n' && i>=0) tmp[j++] = (char)i; tmp[j] = 0; \
W = H = D = V = 0; csiz = 0; \
if ((err = std::sscanf(tmp,"%u %u %u %u #%u",&W,&H,&D,&V,&csiz))<4) \
throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Image %u has an invalid size (%u,%u,%u,%u)\n", \
pixel_type(),filename?filename:("(FILE*)"),W,H,D,V); \
if (W*H*D*V>0) { \
CImg<Tss> raw; \
CImg<T> &img = data[l]; \
img.assign(W,H,D,V); \
T *ptrd = img.data; \
if (err==5) _cimgz_load_cimg_case(Tss) \
else for (int toread = (int)img.size(); toread>0; ) { \
raw.assign(cimg::min(toread,cimg_iobuffer)); \
cimg::fread(raw.data,raw.width,nfile); \
if (endian!=cimg::endianness()) cimg::invert_endianness(raw.data,raw.width); \
toread-=raw.width; \
const Tss *ptrs = raw.data; \
for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++); \
} \
} \
} \
loaded = true; \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
cimg_library::cimg::fread
int fread(T *const ptr, const unsigned int nmemb, std::FILE *stream)
Read file data, and check for possible errors.
Definition: CImg.h:5569
cimg_library::cimg::endianness
bool endianness()
Return the current endianness of the CPU.
Definition: CImg.h:4572
else
else
Definition: rational_rotation.h:103
cimg_library::cimg::invert_endianness
void invert_endianness(T *const buffer, const unsigned int size)
Invert endianness of a memory buffer.
Definition: CImg.h:4579
cimg_library::cimg::strcasecmp
int strcasecmp(const char *const s1, const char *const s2)
Compare two C-strings, ignoring the case.
Definition: CImg.h:4928
i
blockLoc i
Definition: read.cpp:79
min
Vector_n min(const Array_n_const &v1, const Array_n_const &v2)
Definition: Vector_n.h:346
_cimgz_load_cimg_case
#define _cimgz_load_cimg_case(Tss)
j
j indices j
Definition: Indexing.h:6
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImgList< uintT >::_load_cimg().

#define _cimg_load_cimg_case2 (   Ts,
  Tss 
)

Referenced by CImgList< uintT >::_load_cimg().

#define _cimg_load_inr_case (   Tf,
  sign,
  pixsize,
  Ts 
)
Value:
if (!loaded && fopt[6]==pixsize && fopt[4]==Tf && fopt[5]==sign) { \
Ts *xval, *val = new Ts[fopt[0]*fopt[3]]; \
cimg_forYZ(*this,y,z) { \
cimg::fread(val,fopt[0]*fopt[3],nfile); \
if (fopt[7]!=endian) cimg::invert_endianness(val,fopt[0]*fopt[3]); \
xval = val; cimg_forX(*this,x) cimg_forV(*this,k) (*this)(x,y,z,k) = (T)*(xval++); \
} \
delete[] val; \
loaded = true; \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
cimg_library::cimg::fread
int fread(T *const ptr, const unsigned int nmemb, std::FILE *stream)
Read file data, and check for possible errors.
Definition: CImg.h:5569
cimg_forX
#define cimg_forX(img, x)
Definition: CImg.h:593
sign
static SURF_BEGIN_NAMESPACE double sign(double x)
Definition: compute_curvature.C:31
k
j indices k indices k
Definition: Indexing.h:6
y
void int int REAL REAL * y
Definition: read.cpp:74
cimg_forYZ
#define cimg_forYZ(img, y, z)
Definition: CImg.h:599
cimg_library::cimg::invert_endianness
void invert_endianness(T *const buffer, const unsigned int size)
Invert endianness of a memory buffer.
Definition: CImg.h:4579
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

Referenced by CImg< uintT >::_load_inr().

#define _cimg_load_pandore_case (   nbdim,
  nwidth,
  nheight,
  ndepth,
  dim,
  stype1,
  stype2,
  stype3,
  ltype 
)
Value:
{ \
if (sizeof(stype1)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype1); } \
else if (sizeof(stype2)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype2); } \
else if (sizeof(stype3)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype3); } \
else throw CImgIOException("CImg<%s>::load_pandore() : File '%s' cannot be read, datatype not supported on this architecture.", \
pixel_type(),filename?filename:"(FILE*)"); }
if
if(dy > dx)
Definition: rational_rotation.h:90
else
else
Definition: rational_rotation.h:103
__cimg_load_pandore_case
#define __cimg_load_pandore_case(nbdim, nwidth, nheight, ndepth, ndim, stype)

Referenced by CImg< uintT >::_load_pandore().

#define _cimg_median_sort (   a,
  b 
)    if ((a)>(b)) cimg::swap(a,b)

Referenced by CImg< uintT >::get_blur_median().

#define _cimg_save_cimg_case (   Ts,
  Tss 
)

Referenced by CImgList< uintT >::_save_cimg().

#define _cimg_save_pandore_case (   sy,
  sz,
  sv,
  stype,
  id 
)
Value:
if (!saved && (sy?(sy==height):true) && (sz?(sz==depth):true) && (sv?(sv==dim):true) && !std::strcmp(stype,pixel_type())) { \
unsigned int *iheader = (unsigned int*)(header+12); \
nbdims = _save_pandore_header_length((*iheader=id),dims,colorspace); \
cimg::fwrite(header,36,nfile); \
if (sizeof(ulong)==4) { ulong ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (ulong)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \
else if (sizeof(uint)==4) { uint ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (uint)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \
else if (sizeof(ushort)==4) { ushort ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (ushort)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \
else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \
"supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \
depth,dim,data); \
if (id==2 || id==5 || id==8 || id==16 || id==19 || id==22 || id==26 || id==30) { \
__cimg_save_pandore_case(uchar); \
} else if (id==3 || id==6 || id==9 || id==17 || id==20 || id==23 || id==27 || id==31) { \
if (sizeof(ulong)==4) { __cimg_save_pandore_case(ulong); } \
else if (sizeof(uint)==4) { __cimg_save_pandore_case(uint); } \
else if (sizeof(ushort)==4) { __cimg_save_pandore_case(ushort); } \
else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \
"supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \
depth,dim,data); \
} else if (id==4 || id==7 || id==10 || id==18 || id==21 || id==25 || id==29 || id==33) { \
if (sizeof(double)==4) { __cimg_save_pandore_case(double); } \
else if (sizeof(float)==4) { __cimg_save_pandore_case(float); } \
else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \
"supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \
depth,dim,data); \
} \
saved = true; \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
d
const NT & d
Definition: rational_rotation.h:73
else
else
Definition: rational_rotation.h:103
cimg_library::cimg::fwrite
int fwrite(const T *ptr, const unsigned int nmemb, std::FILE *stream)
Write data to a file, and check for possible errors.
Definition: CImg.h:5587
__cimg_save_pandore_case
#define __cimg_save_pandore_case(dtype)

Referenced by CImg< uintT >::_save_pandore().

#define _CImg_stdarg (   img,
  a0,
  a1,
  N,
  t 
)
Value:
{ \
unsigned int _siz = (unsigned int)N; \
if (_siz--) { \
va_list ap; \
va_start(ap,a1); \
T *ptrd = (img).data; \
*(ptrd++) = (T)a0; \
if (_siz--) { \
*(ptrd++) = (T)a1; \
for (; _siz; --_siz) *(ptrd++) = (T)va_arg(ap,t); \
} \
va_end(ap); \
}}
if
if(dy > dx)
Definition: rational_rotation.h:90
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImg< uintT >::assign(), and CImg< uintT >::CImg().

#define _cimg_test_temporary_path (   p)
Value:
if (!path_found) { \
std::sprintf(st_path,"%s",p); \
std::sprintf(tmp,"%s%c%s",st_path,cimg_file_separator,filetmp); \
if ((file=std::fopen(tmp,"wb"))!=0) { std::fclose(file); std::remove(tmp); path_found = true; } \
}
cimg_file_separator
#define cimg_file_separator
Definition: CImg.h:144
if
if(dy > dx)
Definition: rational_rotation.h:90
cimg_library::cimg::fclose
int fclose(std::FILE *file)
Close a file, and check for possible errors.
Definition: CImg.h:5507
cimg_library::cimg::fopen
std::FILE * fopen(const char *const path, const char *const mode)
Open a file, and check for possible errors.
Definition: CImg.h:5494

Referenced by cimg_library::cimg::temporary_path().

#define _cimg_Tfloat   typename cimg::superset<T,float>::type

Definition at line 2301 of file CImg.h.

#define _cimg_Tt   typename cimg::superset<T,t>::type

Definition at line 2300 of file CImg.h.

Referenced by CImg< uintT >::get_dilate(), CImg< uintT >::get_erode(), and CImg< uintT >::operator*().

#define _cimg_Ttfloat   typename cimg::superset2<T,t,float>::type

Definition at line 2302 of file CImg.h.

Referenced by CImg< uintT >::_solve(), CImg< uintT >::get_correlate(), CImg< uintT >::solve(), and CImg< uintT >::solve_tridiagonal().

#define _cimg_valign2d (   i,
  j 
)    { Tfloat &u = W(i,j,0,0), &v = W(i,j,0,1); if (u*curru + v*currv<0) { u=-u; v=-v; }}

Referenced by CImg< uintT >::blur_anisotropic().

#define _cimg_valign3d (   i,
  j,
  k 
)    { Tfloat &u = W(i,j,k,0), &v = W(i,j,k,1), &w = W(i,j,k,2); if (u*curru + v*currv + w*currw<0) { u=-u; v=-v; w=-w; }}

Referenced by CImg< uintT >::blur_anisotropic().

#define _cimglist_def_is_same (   axis)
Value:
template<typename t> bool is_same##axis(const CImg<t>& img) const { \
bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis(img); return res; \
} \
template<typename t> bool is_same##axis(const CImgList<t>& list) const { \
const unsigned int lmin = cimg::min(width,list.width); \
bool res = true; for (unsigned int l = 0; l<lmin && res; ++l) res = data[l].is_same##axis(list[l]); return res; \
} \
template<typename t> bool is_sameN##axis(const unsigned int n, const CImg<t>& img) const { \
return (is_sameN(n) && is_same##axis(img)); \
} \
template<typename t> bool is_sameN##axis(const CImgList<t>& list) const { \
return (is_sameN(list) && is_same##axis(list)); \
}
n
const NT & n
Definition: rational_rotation.h:72
min
Vector_n min(const Array_n_const &v1, const Array_n_const &v2)
Definition: Vector_n.h:346

Definition at line 34775 of file CImg.h.

#define _cimglist_def_is_same1 (   axis)
Value:
bool is_same##axis(const unsigned int val) const { \
bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis(val); return res; \
} \
bool is_sameN##axis(const unsigned int n, const unsigned int val) const { \
return is_sameN(n) && is_same##axis(val); \
} \
n
const NT & n
Definition: rational_rotation.h:72

Definition at line 34751 of file CImg.h.

#define _cimglist_def_is_same2 (   axis1,
  axis2 
)
Value:
bool is_same##axis1##axis2(const unsigned int val1, const unsigned int val2) const { \
bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis1##axis2(val1,val2); return res; \
} \
bool is_sameN##axis1##axis2(const unsigned int n, const unsigned int val1, const unsigned int val2) const { \
return is_sameN(n) && is_same##axis1##axis2(val1,val2); \
} \
n
const NT & n
Definition: rational_rotation.h:72

Definition at line 34759 of file CImg.h.

#define _cimglist_def_is_same3 (   axis1,
  axis2,
  axis3 
)
Value:
bool is_same##axis1##axis2##axis3(const unsigned int val1, const unsigned int val2, const unsigned int val3) const { \
bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis1##axis2##axis3(val1,val2,val3); return res; \
} \
bool is_sameN##axis1##axis2##axis3(const unsigned int n, const unsigned int val1, const unsigned int val2, const unsigned int val3) const { \
return is_sameN(n) && is_same##axis1##axis2##axis3(val1,val2,val3); \
} \
n
const NT & n
Definition: rational_rotation.h:72

Definition at line 34767 of file CImg.h.

#define _CImgList_stdarg (   t)
Value:
{ \
assign(n,width,height,depth,dim); \
const unsigned int siz = width*height*depth*dim, nsiz = siz*n; \
T *ptrd = data->data; \
va_list ap; \
va_start(ap,val1); \
for (unsigned int l = 0, s = 0, i = 0; i<nsiz; ++i) { \
*(ptrd++) = (T)(i==0?val0:(i==1?val1:va_arg(ap,t))); \
if ((++s)==siz) { ptrd = data[++l].data; s = 0; } \
} \
va_end(ap); \
}
if
if(dy > dx)
Definition: rational_rotation.h:90
s
double s
Definition: blastest.C:80
CGAL::assign
bool assign(T &t, const Object &o)
Definition: Object.h:138
i
blockLoc i
Definition: read.cpp:79
n
const NT & n
Definition: rational_rotation.h:72
for
for(;;)
Definition: rational_rotation.h:111

Referenced by CImgList< uintT >::assign(), and CImgList< uintT >::CImgList().

#define _cimgz_load_cimg_case (   Tss)
Value:
throw CImgIOException("CImgList<%s>::load_cimg() : File '%s' contains compressed data, zlib must be used",\
pixel_type(),filename?filename:"(FILE*)");
#define CImg_2x2 (   I,
  T 
)
Value:
T I[4]; \
T& I##cc = I[0]; T& I##nc = I[1]; \
T& I##cn = I[2]; T& I##nn = I[3]; \
I##cc = I##nc = \
I##cn = I##nn = 0

Definition at line 415 of file CImg.h.

Referenced by CImg< uintT >::get_gradient().

#define CImg_2x2x2 (   I,
  T 
)
Value:
T I[8]; \
T& I##ccc = I[0]; T& I##ncc = I[1]; \
T& I##cnc = I[2]; T& I##nnc = I[3]; \
T& I##ccn = I[4]; T& I##ncn = I[5]; \
T& I##cnn = I[6]; T& I##nnn = I[7]; \
I##ccc = I##ncc = \
I##cnc = I##nnc = \
I##ccn = I##ncn = \
I##cnn = I##nnn = 0

Definition at line 451 of file CImg.h.

Referenced by CImg< uintT >::get_gradient().

#define CImg_3x3 (   I,
  T 
)
Value:
T I[9]; \
T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; \
T& I##pc = I[3]; T& I##cc = I[4]; T& I##nc = I[5]; \
T& I##pn = I[6]; T& I##cn = I[7]; T& I##nn = I[8]; \
I##pp = I##cp = I##np = \
I##pc = I##cc = I##nc = \
I##pn = I##cn = I##nn = 0

Definition at line 421 of file CImg.h.

Referenced by CImg< uintT >::blur_anisotropic(), CImg< uintT >::distance_hamilton(), CImg< uintT >::get_BayertoRGB(), CImg< uintT >::get_blur_median(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_resize_doubleXY(), CImg< uintT >::get_resize_tripleXY(), CImg< uintT >::get_select_graph(), CImg< uintT >::get_structure_tensor(), and CImg< uintT >::sharpen().

#define CImg_3x3x3 (   I,
  T 
)
Value:
T I[27]; \
T& I##ppp = I[0]; T& I##cpp = I[1]; T& I##npp = I[2]; \
T& I##pcp = I[3]; T& I##ccp = I[4]; T& I##ncp = I[5]; \
T& I##pnp = I[6]; T& I##cnp = I[7]; T& I##nnp = I[8]; \
T& I##ppc = I[9]; T& I##cpc = I[10]; T& I##npc = I[11]; \
T& I##pcc = I[12]; T& I##ccc = I[13]; T& I##ncc = I[14]; \
T& I##pnc = I[15]; T& I##cnc = I[16]; T& I##nnc = I[17]; \
T& I##ppn = I[18]; T& I##cpn = I[19]; T& I##npn = I[20]; \
T& I##pcn = I[21]; T& I##ccn = I[22]; T& I##ncn = I[23]; \
T& I##pnn = I[24]; T& I##cnn = I[25]; T& I##nnn = I[26]; \
I##ppp = I##cpp = I##npp = \
I##pcp = I##ccp = I##ncp = \
I##pnp = I##cnp = I##nnp = \
I##ppc = I##cpc = I##npc = \
I##pcc = I##ccc = I##ncc = \
I##pnc = I##cnc = I##nnc = \
I##ppn = I##cpn = I##npn = \
I##pcn = I##ccn = I##ncn = \
I##pnn = I##cnn = I##nnn = 0

Definition at line 461 of file CImg.h.

Referenced by CImg< uintT >::blur_anisotropic(), CImg< uintT >::distance_hamilton(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_structure_tensor(), and CImg< uintT >::sharpen().

#define CImg_4x4 (   I,
  T 
)
Value:
T I[16]; \
T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; T& I##ap = I[3]; \
T& I##pc = I[4]; T& I##cc = I[5]; T& I##nc = I[6]; T& I##ac = I[7]; \
T& I##pn = I[8]; T& I##cn = I[9]; T& I##nn = I[10]; T& I##an = I[11]; \
T& I##pa = I[12]; T& I##ca = I[13]; T& I##na = I[14]; T& I##aa = I[15]; \
I##pp = I##cp = I##np = I##ap = \
I##pc = I##cc = I##nc = I##ac = \
I##pn = I##cn = I##nn = I##an = \
I##pa = I##ca = I##na = I##aa = 0

Definition at line 429 of file CImg.h.

#define CImg_5x5 (   I,
  T 
)
Value:
T I[25]; \
T& I##bb = I[0]; T& I##pb = I[1]; T& I##cb = I[2]; T& I##nb = I[3]; T& I##ab = I[4]; \
T& I##bp = I[5]; T& I##pp = I[6]; T& I##cp = I[7]; T& I##np = I[8]; T& I##ap = I[9]; \
T& I##bc = I[10]; T& I##pc = I[11]; T& I##cc = I[12]; T& I##nc = I[13]; T& I##ac = I[14]; \
T& I##bn = I[15]; T& I##pn = I[16]; T& I##cn = I[17]; T& I##nn = I[18]; T& I##an = I[19]; \
T& I##ba = I[20]; T& I##pa = I[21]; T& I##ca = I[22]; T& I##na = I[23]; T& I##aa = I[24]; \
I##bb = I##pb = I##cb = I##nb = I##ab = \
I##bp = I##pp = I##cp = I##np = I##ap = \
I##bc = I##pc = I##cc = I##nc = I##ac = \
I##bn = I##pn = I##cn = I##nn = I##an = \
I##ba = I##pa = I##ca = I##na = I##aa = 0

Definition at line 439 of file CImg.h.

Referenced by CImg< uintT >::get_blur_median().

#define cimg_argument (   pos)    cimg_library::cimg::argument(pos,argc,argv)

Definition at line 403 of file CImg.h.

#define cimg_argument1 (   pos,
  s0 
)    cimg_library::cimg::argument(pos,argc,argv,1,s0)

Definition at line 404 of file CImg.h.

#define cimg_argument2 (   pos,
  s0,
  s1 
)    cimg_library::cimg::argument(pos,argc,argv,2,s0,s1)

Definition at line 405 of file CImg.h.

#define cimg_argument3 (   pos,
  s0,
  s1,
  s2 
)    cimg_library::cimg::argument(pos,argc,argv,3,s0,s1,s2)

Definition at line 406 of file CImg.h.

#define cimg_argument4 (   pos,
  s0,
  s1,
  s2,
  s3 
)    cimg_library::cimg::argument(pos,argc,argv,4,s0,s1,s2,s3)

Definition at line 407 of file CImg.h.

#define cimg_argument5 (   pos,
  s0,
  s1,
  s2,
  s3,
  s4 
)    cimg_library::cimg::argument(pos,argc,argv,5,s0,s1,s2,s3,s4)

Definition at line 408 of file CImg.h.

#define cimg_argument6 (   pos,
  s0,
  s1,
  s2,
  s3,
  s4,
  s5 
)    cimg_library::cimg::argument(pos,argc,argv,6,s0,s1,s2,s3,s4,s5)

Definition at line 409 of file CImg.h.

#define cimg_argument7 (   pos,
  s0,
  s1,
  s2,
  s3,
  s4,
  s5,
  s6 
)    cimg_library::cimg::argument(pos,argc,argv,7,s0,s1,s2,s3,s4,s5,s6)

Definition at line 410 of file CImg.h.

#define cimg_argument8 (   pos,
  s0,
  s1,
  s2,
  s3,
  s4,
  s5,
  s6,
  s7 
)    cimg_library::cimg::argument(pos,argc,argv,8,s0,s1,s2,s3,s4,s5,s6,s7)

Definition at line 411 of file CImg.h.

#define cimg_argument9 (   pos,
  s0,
  s1,
  s2,
  s3,
  s4,
  s5,
  s6,
  s7,
  s8 
)    cimg_library::cimg::argument(pos,argc,argv,9,s0,s1,s2,s3,s4,s5,s6,s7,s8)

Definition at line 412 of file CImg.h.

#define cimg_debug   2

Definition at line 160 of file CImg.h.

Referenced by cimg_library::cimg::exception_mode(), and cimg_library::cimg::info().

#define cimg_display   0

Definition at line 172 of file CImg.h.

Referenced by cimg_library::cimg::info().

#define cimg_file_separator   '/'

Definition at line 144 of file CImg.h.

Referenced by cimg_library::cimg::basename(), CImg< uintT >::load_dcraw_external(), CImgList< uintT >::load_ffmpeg_external(), CImg< uintT >::load_graphicsmagick_external(), CImg< uintT >::load_gzip_external(), CImgList< uintT >::load_gzip_external(), CImg< uintT >::load_imagemagick_external(), CImgList< uintT >::save_ffmpeg_external(), CImg< uintT >::save_graphicsmagick_external(), CImg< uintT >::save_gzip_external(), CImgList< uintT >::save_gzip_external(), and CImg< uintT >::save_imagemagick_external().

#define cimg_fitscreen (   dx,
  dy,
  dz 
)    CImgDisplay::_fitscreen(dx,dy,dz,128,-85,false),CImgDisplay::_fitscreen(dx,dy,dz,128,-85,true)

Definition at line 6436 of file CImg.h.

Referenced by CImg< uintT >::_display(), CImg< uintT >::_display_object3d(), CImg< uintT >::_get_select(), CImg< uintT >::display_graph(), and CImg< uintT >::get_select_graph().

#define cimg_for (   img,
  ptr,
  T_ptr 
)    for (T_ptr *ptr = (img).data + (img).size(); (ptr--)>(img).data; )

Definition at line 589 of file CImg.h.

Referenced by CImg< uintT >::_get_select(), CImg< uintT >::abs(), CImg< uintT >::acos(), CImg< uintT >::asin(), CImg< uintT >::assign(), CImg< uintT >::atan(), CImg< uintT >::blur_anisotropic(), CImg< uintT >::CImg(), CImg< uintT >::cos(), CImg< uintT >::cosh(), CImg< uintT >::cut(), CImg< uintT >::draw_fill(), CImg< uintT >::equalize(), CImg< uintT >::exp(), CImg< uintT >::fill(), CImg< uintT >::get_histogram(), CImg< uintT >::get_label_regions(), CImg< uintT >::get_map(), CImg< uintT >::get_stats(), CImg< uintT >::log(), CImg< uintT >::log10(), CImg< uintT >::max(), CImgList< uintT >::max(), CImg< uintT >::maxmin(), CImgList< uintT >::maxmin(), CImg< uintT >::mean(), CImg< uintT >::min(), CImgList< uintT >::min(), CImg< uintT >::minmax(), CImgList< uintT >::minmax(), CImg< uintT >::MSE(), CImg< uintT >::noise(), CImg< uintT >::normalize(), CImg< uintT >::operator%=(), CImg< uintT >::operator&=(), CImg< uintT >::operator*=(), CImg< uintT >::operator++(), CImg< uintT >::operator+=(), CImg< uintT >::operator--(), CImg< uintT >::operator-=(), CImg< uintT >::operator/=(), CImg< uintT >::operator<<=(), CImg< uintT >::operator>>=(), CImg< uintT >::operator^=(), CImg< uintT >::operator|=(), CImg< uintT >::operator~(), CImg< uintT >::pow(), CImg< uintT >::quantize(), CImg< uintT >::rand(), CImg< uintT >::round(), CImg< uintT >::sin(), CImg< uintT >::sinh(), CImg< uintT >::sqr(), CImg< uintT >::sqrt(), CImg< uintT >::sum(), CImg< uintT >::tan(), CImg< uintT >::tanh(), CImg< uintT >::threshold(), and CImg< uintT >::variancemean().

#define cimg_for1 (   bound,
  i 
)    for (int i = 0; i<(int)(bound); ++i)

Definition at line 592 of file CImg.h.

#define cimg_for2 (   bound,
  i 
)
Value:
for (int i = 0, _n1##i = 1>=(bound)?(int)(bound)-1:1; \
_n1##i<(int)(bound) || i==--_n1##i; \
++i, ++_n1##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 691 of file CImg.h.

#define cimg_for2V (   img,
  v 
)    cimg_for2((img).dim,v)

Definition at line 698 of file CImg.h.

#define cimg_for2X (   img,
  x 
)    cimg_for2((img).width,x)

Definition at line 695 of file CImg.h.

#define cimg_for2x2 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for2((img).height,y) for (int x = 0, \
_n1##x = (int)( \
(I[0] = (img)(0,y,z,v)), \
(I[2] = (img)(0,_n1##y,z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[1] = (img)(_n1##x,y,z,v)), \
(I[3] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x; \
I[0] = I[1], \
I[2] = I[3], \
++x, ++_n1##x)
cimg_for2
#define cimg_for2(bound, i)
Definition: CImg.h:691
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1053 of file CImg.h.

Referenced by CImg< uintT >::get_blur_median(), CImg< uintT >::get_correlate(), and CImg< uintT >::get_gradient().

#define cimg_for2x2x2 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for2((img).depth,z) cimg_for2((img).height,y) for (int x = 0, \
_n1##x = (int)( \
(I[0] = (img)(0,y,z,v)), \
(I[2] = (img)(0,_n1##y,z,v)), \
(I[4] = (img)(0,y,_n1##z,v)), \
(I[6] = (img)(0,_n1##y,_n1##z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[1] = (img)(_n1##x,y,z,v)), \
(I[3] = (img)(_n1##x,_n1##y,z,v)), \
(I[5] = (img)(_n1##x,y,_n1##z,v)), \
(I[7] = (img)(_n1##x,_n1##y,_n1##z,v)),1)) || \
x==--_n1##x; \
I[0] = I[1], I[2] = I[3], I[4] = I[5], I[6] = I[7], \
++x, ++_n1##x)
cimg_for2
#define cimg_for2(bound, i)
Definition: CImg.h:691
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1774 of file CImg.h.

Referenced by CImg< uintT >::get_correlate(), and CImg< uintT >::get_gradient().

#define cimg_for2XV (   img,
  x,
  v 
)    cimg_for2V(img,v) cimg_for2X(img,x)

Definition at line 701 of file CImg.h.

#define cimg_for2XY (   img,
  x,
  y 
)    cimg_for2Y(img,y) cimg_for2X(img,x)

Definition at line 699 of file CImg.h.

#define cimg_for2XYZ (   img,
  x,
  y,
  z 
)    cimg_for2Z(img,z) cimg_for2XY(img,x,y)

Definition at line 705 of file CImg.h.

#define cimg_for2XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for2V(img,v) cimg_for2XYZ(img,x,y,z)

Definition at line 708 of file CImg.h.

#define cimg_for2XZ (   img,
  x,
  z 
)    cimg_for2Z(img,z) cimg_for2X(img,x)

Definition at line 700 of file CImg.h.

#define cimg_for2XZV (   img,
  x,
  z,
  v 
)    cimg_for2V(img,v) cimg_for2XZ(img,x,z)

Definition at line 706 of file CImg.h.

#define cimg_for2Y (   img,
  y 
)    cimg_for2((img).height,y)

Definition at line 696 of file CImg.h.

#define cimg_for2YV (   img,
  y,
  v 
)    cimg_for2V(img,v) cimg_for2Y(img,y)

Definition at line 703 of file CImg.h.

#define cimg_for2YZ (   img,
  y,
  z 
)    cimg_for2Z(img,z) cimg_for2Y(img,y)

Definition at line 702 of file CImg.h.

#define cimg_for2YZV (   img,
  y,
  z,
  v 
)    cimg_for2V(img,v) cimg_for2YZ(img,y,z)

Definition at line 707 of file CImg.h.

#define cimg_for2Z (   img,
  z 
)    cimg_for2((img).depth,z)

Definition at line 697 of file CImg.h.

#define cimg_for2ZV (   img,
  z,
  v 
)    cimg_for2V(img,v) cimg_for2Z(img,z)

Definition at line 704 of file CImg.h.

#define cimg_for3 (   bound,
  i 
)
Value:
for (int i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1; \
_n1##i<(int)(bound) || i==--_n1##i; \
_p1##i = i++, ++_n1##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 730 of file CImg.h.

#define cimg_for3V (   img,
  v 
)    cimg_for3((img).dim,v)

Definition at line 738 of file CImg.h.

#define cimg_for3X (   img,
  x 
)    cimg_for3((img).width,x)

Definition at line 735 of file CImg.h.

#define cimg_for3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for3((img).height,y) for (int x = 0, \
_p1##x = 0, \
_n1##x = (int)( \
(I[0] = I[1] = (img)(0,_p1##y,z,v)), \
(I[3] = I[4] = (img)(0,y,z,v)), \
(I[6] = I[7] = (img)(0,_n1##y,z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[5] = (img)(_n1##x,y,z,v)), \
(I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x; \
I[0] = I[1], I[1] = I[2], \
I[3] = I[4], I[4] = I[5], \
I[6] = I[7], I[7] = I[8], \
_p1##x = x++, ++_n1##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
cimg_for3
#define cimg_for3(bound, i)
Definition: CImg.h:730
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1081 of file CImg.h.

Referenced by CImg< uintT >::blur_anisotropic(), CImg< uintT >::distance_hamilton(), CImg< uintT >::get_blur_median(), CImg< uintT >::get_correlate(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_resize_halfXY(), CImg< uintT >::get_select_graph(), CImg< uintT >::get_structure_tensor(), and CImg< uintT >::sharpen().

#define cimg_for3x3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for3((img).depth,z) cimg_for3((img).height,y) for (int x = 0, \
_p1##x = 0, \
_n1##x = (int)( \
(I[0] = I[1] = (img)(0,_p1##y,_p1##z,v)), \
(I[3] = I[4] = (img)(0,y,_p1##z,v)), \
(I[6] = I[7] = (img)(0,_n1##y,_p1##z,v)), \
(I[9] = I[10] = (img)(0,_p1##y,z,v)), \
(I[12] = I[13] = (img)(0,y,z,v)), \
(I[15] = I[16] = (img)(0,_n1##y,z,v)), \
(I[18] = I[19] = (img)(0,_p1##y,_n1##z,v)), \
(I[21] = I[22] = (img)(0,y,_n1##z,v)), \
(I[24] = I[25] = (img)(0,_n1##y,_n1##z,v)), \
1>=(img).width?(int)((img).width)-1:1); \
(_n1##x<(int)((img).width) && ( \
(I[2] = (img)(_n1##x,_p1##y,_p1##z,v)), \
(I[5] = (img)(_n1##x,y,_p1##z,v)), \
(I[8] = (img)(_n1##x,_n1##y,_p1##z,v)), \
(I[11] = (img)(_n1##x,_p1##y,z,v)), \
(I[14] = (img)(_n1##x,y,z,v)), \
(I[17] = (img)(_n1##x,_n1##y,z,v)), \
(I[20] = (img)(_n1##x,_p1##y,_n1##z,v)), \
(I[23] = (img)(_n1##x,y,_n1##z,v)), \
(I[26] = (img)(_n1##x,_n1##y,_n1##z,v)),1)) || \
x==--_n1##x; \
I[0] = I[1], I[1] = I[2], I[3] = I[4], I[4] = I[5], I[6] = I[7], I[7] = I[8], \
I[9] = I[10], I[10] = I[11], I[12] = I[13], I[13] = I[14], I[15] = I[16], I[16] = I[17], \
I[18] = I[19], I[19] = I[20], I[21] = I[22], I[22] = I[23], I[24] = I[25], I[25] = I[26], \
_p1##x = x++, ++_n1##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
cimg_for3
#define cimg_for3(bound, i)
Definition: CImg.h:730
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1808 of file CImg.h.

Referenced by CImg< uintT >::blur_anisotropic(), CImg< uintT >::distance_hamilton(), CImg< uintT >::get_correlate(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_structure_tensor(), and CImg< uintT >::sharpen().

#define cimg_for3XV (   img,
  x,
  v 
)    cimg_for3V(img,v) cimg_for3X(img,x)

Definition at line 741 of file CImg.h.

#define cimg_for3XY (   img,
  x,
  y 
)    cimg_for3Y(img,y) cimg_for3X(img,x)

Definition at line 739 of file CImg.h.

Referenced by CImg< uintT >::get_displacement_field().

#define cimg_for3XYZ (   img,
  x,
  y,
  z 
)    cimg_for3Z(img,z) cimg_for3XY(img,x,y)

Definition at line 745 of file CImg.h.

Referenced by CImg< uintT >::get_displacement_field().

#define cimg_for3XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for3V(img,v) cimg_for3XYZ(img,x,y,z)

Definition at line 748 of file CImg.h.

#define cimg_for3XZ (   img,
  x,
  z 
)    cimg_for3Z(img,z) cimg_for3X(img,x)

Definition at line 740 of file CImg.h.

#define cimg_for3XZV (   img,
  x,
  z,
  v 
)    cimg_for3V(img,v) cimg_for3XZ(img,x,z)

Definition at line 746 of file CImg.h.

#define cimg_for3Y (   img,
  y 
)    cimg_for3((img).height,y)

Definition at line 736 of file CImg.h.

#define cimg_for3YV (   img,
  y,
  v 
)    cimg_for3V(img,v) cimg_for3Y(img,y)

Definition at line 743 of file CImg.h.

#define cimg_for3YZ (   img,
  y,
  z 
)    cimg_for3Z(img,z) cimg_for3Y(img,y)

Definition at line 742 of file CImg.h.

#define cimg_for3YZV (   img,
  y,
  z,
  v 
)    cimg_for3V(img,v) cimg_for3YZ(img,y,z)

Definition at line 747 of file CImg.h.

#define cimg_for3Z (   img,
  z 
)    cimg_for3((img).depth,z)

Definition at line 737 of file CImg.h.

#define cimg_for3ZV (   img,
  z,
  v 
)    cimg_for3V(img,v) cimg_for3Z(img,z)

Definition at line 744 of file CImg.h.

#define cimg_for4 (   bound,
  i 
)
Value:
for (int i = 0, _p1##i = 0, _n1##i = 1>=(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(bound)?(int)(bound)-1:2; \
_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i); \
_p1##i = i++, ++_n1##i, ++_n2##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 771 of file CImg.h.

#define cimg_for4V (   img,
  v 
)    cimg_for4((img).dim,v)

Definition at line 779 of file CImg.h.

#define cimg_for4X (   img,
  x 
)    cimg_for4((img).width,x)

Definition at line 776 of file CImg.h.

#define cimg_for4x4 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for4((img).height,y) for (int x = 0, \
_p1##x = 0, \
_n1##x = 1>=(img).width?(int)((img).width)-1:1, \
_n2##x = (int)( \
(I[0] = I[1] = (img)(0,_p1##y,z,v)), \
(I[4] = I[5] = (img)(0,y,z,v)), \
(I[8] = I[9] = (img)(0,_n1##y,z,v)), \
(I[12] = I[13] = (img)(0,_n2##y,z,v)), \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[6] = (img)(_n1##x,y,z,v)), \
(I[10] = (img)(_n1##x,_n1##y,z,v)), \
(I[14] = (img)(_n1##x,_n2##y,z,v)), \
2>=(img).width?(int)((img).width)-1:2); \
(_n2##x<(int)((img).width) && ( \
(I[3] = (img)(_n2##x,_p1##y,z,v)), \
(I[7] = (img)(_n2##x,y,z,v)), \
(I[11] = (img)(_n2##x,_n1##y,z,v)), \
(I[15] = (img)(_n2##x,_n2##y,z,v)),1)) || \
_n1##x==--_n2##x || x==(_n2##x = --_n1##x); \
I[0] = I[1], I[1] = I[2], I[2] = I[3], \
I[4] = I[5], I[5] = I[6], I[6] = I[7], \
I[8] = I[9], I[9] = I[10], I[10] = I[11], \
I[12] = I[13], I[13] = I[14], I[14] = I[15], \
_p1##x = x++, ++_n1##x, ++_n2##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111
cimg_for4
#define cimg_for4(bound, i)
Definition: CImg.h:771

Definition at line 1120 of file CImg.h.

Referenced by CImg< uintT >::get_correlate().

#define cimg_for4XV (   img,
  x,
  v 
)    cimg_for4V(img,v) cimg_for4X(img,x)

Definition at line 782 of file CImg.h.

#define cimg_for4XY (   img,
  x,
  y 
)    cimg_for4Y(img,y) cimg_for4X(img,x)

Definition at line 780 of file CImg.h.

#define cimg_for4XYZ (   img,
  x,
  y,
  z 
)    cimg_for4Z(img,z) cimg_for4XY(img,x,y)

Definition at line 786 of file CImg.h.

#define cimg_for4XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for4V(img,v) cimg_for4XYZ(img,x,y,z)

Definition at line 789 of file CImg.h.

#define cimg_for4XZ (   img,
  x,
  z 
)    cimg_for4Z(img,z) cimg_for4X(img,x)

Definition at line 781 of file CImg.h.

#define cimg_for4XZV (   img,
  x,
  z,
  v 
)    cimg_for4V(img,v) cimg_for4XZ(img,x,z)

Definition at line 787 of file CImg.h.

#define cimg_for4Y (   img,
  y 
)    cimg_for4((img).height,y)

Definition at line 777 of file CImg.h.

#define cimg_for4YV (   img,
  y,
  v 
)    cimg_for4V(img,v) cimg_for4Y(img,y)

Definition at line 784 of file CImg.h.

#define cimg_for4YZ (   img,
  y,
  z 
)    cimg_for4Z(img,z) cimg_for4Y(img,y)

Definition at line 783 of file CImg.h.

#define cimg_for4YZV (   img,
  y,
  z,
  v 
)    cimg_for4V(img,v) cimg_for4YZ(img,y,z)

Definition at line 788 of file CImg.h.

#define cimg_for4Z (   img,
  z 
)    cimg_for4((img).depth,z)

Definition at line 778 of file CImg.h.

#define cimg_for4ZV (   img,
  z,
  v 
)    cimg_for4V(img,v) cimg_for4Z(img,z)

Definition at line 785 of file CImg.h.

#define cimg_for5 (   bound,
  i 
)
Value:
for (int i = 0, _p2##i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(bound)?(int)(bound)-1:2; \
_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i); \
_p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 813 of file CImg.h.

#define cimg_for5V (   img,
  v 
)    cimg_for5((img).dim,v)

Definition at line 822 of file CImg.h.

#define cimg_for5X (   img,
  x 
)    cimg_for5((img).width,x)

Definition at line 819 of file CImg.h.

#define cimg_for5x5 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for5((img).height,y) for (int x = 0, \
_p2##x = 0, _p1##x = 0, \
_n1##x = 1>=(img).width?(int)((img).width)-1:1, \
_n2##x = (int)( \
(I[0] = I[1] = I[2] = (img)(0,_p2##y,z,v)), \
(I[5] = I[6] = I[7] = (img)(0,_p1##y,z,v)), \
(I[10] = I[11] = I[12] = (img)(0,y,z,v)), \
(I[15] = I[16] = I[17] = (img)(0,_n1##y,z,v)), \
(I[20] = I[21] = I[22] = (img)(0,_n2##y,z,v)), \
(I[3] = (img)(_n1##x,_p2##y,z,v)), \
(I[8] = (img)(_n1##x,_p1##y,z,v)), \
(I[13] = (img)(_n1##x,y,z,v)), \
(I[18] = (img)(_n1##x,_n1##y,z,v)), \
(I[23] = (img)(_n1##x,_n2##y,z,v)), \
2>=(img).width?(int)((img).width)-1:2); \
(_n2##x<(int)((img).width) && ( \
(I[4] = (img)(_n2##x,_p2##y,z,v)), \
(I[9] = (img)(_n2##x,_p1##y,z,v)), \
(I[14] = (img)(_n2##x,y,z,v)), \
(I[19] = (img)(_n2##x,_n1##y,z,v)), \
(I[24] = (img)(_n2##x,_n2##y,z,v)),1)) || \
_n1##x==--_n2##x || x==(_n2##x = --_n1##x); \
I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], \
I[5] = I[6], I[6] = I[7], I[7] = I[8], I[8] = I[9], \
I[10] = I[11], I[11] = I[12], I[12] = I[13], I[13] = I[14], \
I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], \
I[20] = I[21], I[21] = I[22], I[22] = I[23], I[23] = I[24], \
_p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111
cimg_for5
#define cimg_for5(bound, i)
Definition: CImg.h:813

Definition at line 1176 of file CImg.h.

Referenced by CImg< uintT >::get_blur_median(), and CImg< uintT >::get_correlate().

#define cimg_for5XV (   img,
  x,
  v 
)    cimg_for5V(img,v) cimg_for5X(img,x)

Definition at line 825 of file CImg.h.

#define cimg_for5XY (   img,
  x,
  y 
)    cimg_for5Y(img,y) cimg_for5X(img,x)

Definition at line 823 of file CImg.h.

#define cimg_for5XYZ (   img,
  x,
  y,
  z 
)    cimg_for5Z(img,z) cimg_for5XY(img,x,y)

Definition at line 829 of file CImg.h.

#define cimg_for5XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for5V(img,v) cimg_for5XYZ(img,x,y,z)

Definition at line 832 of file CImg.h.

#define cimg_for5XZ (   img,
  x,
  z 
)    cimg_for5Z(img,z) cimg_for5X(img,x)

Definition at line 824 of file CImg.h.

#define cimg_for5XZV (   img,
  x,
  z,
  v 
)    cimg_for5V(img,v) cimg_for5XZ(img,x,z)

Definition at line 830 of file CImg.h.

#define cimg_for5Y (   img,
  y 
)    cimg_for5((img).height,y)

Definition at line 820 of file CImg.h.

#define cimg_for5YV (   img,
  y,
  v 
)    cimg_for5V(img,v) cimg_for5Y(img,y)

Definition at line 827 of file CImg.h.

#define cimg_for5YZ (   img,
  y,
  z 
)    cimg_for5Z(img,z) cimg_for5Y(img,y)

Definition at line 826 of file CImg.h.

#define cimg_for5YZV (   img,
  y,
  z,
  v 
)    cimg_for5V(img,v) cimg_for5YZ(img,y,z)

Definition at line 831 of file CImg.h.

#define cimg_for5Z (   img,
  z 
)    cimg_for5((img).depth,z)

Definition at line 821 of file CImg.h.

#define cimg_for5ZV (   img,
  z,
  v 
)    cimg_for5V(img,v) cimg_for5Z(img,z)

Definition at line 828 of file CImg.h.

#define cimg_for6 (   bound,
  i 
)
Value:
for (int i = 0, _p2##i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(bound)?(int)(bound)-1:2, \
_n3##i = 3>=(bound)?(int)(bound)-1:3; \
_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i); \
_p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 857 of file CImg.h.

#define cimg_for6V (   img,
  v 
)    cimg_for6((img).dim,v)

Definition at line 867 of file CImg.h.

#define cimg_for6X (   img,
  x 
)    cimg_for6((img).width,x)

Definition at line 864 of file CImg.h.

#define cimg_for6x6 (   img,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1247 of file CImg.h.

Referenced by CImg< uintT >::get_correlate().

#define cimg_for6XV (   img,
  x,
  v 
)    cimg_for6V(img,v) cimg_for6X(img,x)

Definition at line 870 of file CImg.h.

#define cimg_for6XY (   img,
  x,
  y 
)    cimg_for6Y(img,y) cimg_for6X(img,x)

Definition at line 868 of file CImg.h.

#define cimg_for6XYZ (   img,
  x,
  y,
  z 
)    cimg_for6Z(img,z) cimg_for6XY(img,x,y)

Definition at line 874 of file CImg.h.

#define cimg_for6XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for6V(img,v) cimg_for6XYZ(img,x,y,z)

Definition at line 877 of file CImg.h.

#define cimg_for6XZ (   img,
  x,
  z 
)    cimg_for6Z(img,z) cimg_for6X(img,x)

Definition at line 869 of file CImg.h.

#define cimg_for6XZV (   img,
  x,
  z,
  v 
)    cimg_for6V(img,v) cimg_for6XZ(img,x,z)

Definition at line 875 of file CImg.h.

#define cimg_for6Y (   img,
  y 
)    cimg_for6((img).height,y)

Definition at line 865 of file CImg.h.

#define cimg_for6YV (   img,
  y,
  v 
)    cimg_for6V(img,v) cimg_for6Y(img,y)

Definition at line 872 of file CImg.h.

#define cimg_for6YZ (   img,
  y,
  z 
)    cimg_for6Z(img,z) cimg_for6Y(img,y)

Definition at line 871 of file CImg.h.

#define cimg_for6YZV (   img,
  y,
  z,
  v 
)    cimg_for6V(img,v) cimg_for6YZ(img,y,z)

Definition at line 876 of file CImg.h.

#define cimg_for6Z (   img,
  z 
)    cimg_for6((img).depth,z)

Definition at line 866 of file CImg.h.

#define cimg_for6ZV (   img,
  z,
  v 
)    cimg_for6V(img,v) cimg_for6Z(img,z)

Definition at line 873 of file CImg.h.

#define cimg_for7 (   bound,
  i 
)
Value:
for (int i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(bound)?(int)(bound)-1:2, \
_n3##i = 3>=(bound)?(int)(bound)-1:3; \
_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i); \
_p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 903 of file CImg.h.

#define cimg_for7V (   img,
  v 
)    cimg_for7((img).dim,v)

Definition at line 913 of file CImg.h.

#define cimg_for7X (   img,
  x 
)    cimg_for7((img).width,x)

Definition at line 910 of file CImg.h.

#define cimg_for7x7 (   img,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1342 of file CImg.h.

#define cimg_for7XV (   img,
  x,
  v 
)    cimg_for7V(img,v) cimg_for7X(img,x)

Definition at line 916 of file CImg.h.

#define cimg_for7XY (   img,
  x,
  y 
)    cimg_for7Y(img,y) cimg_for7X(img,x)

Definition at line 914 of file CImg.h.

#define cimg_for7XYZ (   img,
  x,
  y,
  z 
)    cimg_for7Z(img,z) cimg_for7XY(img,x,y)

Definition at line 920 of file CImg.h.

#define cimg_for7XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for7V(img,v) cimg_for7XYZ(img,x,y,z)

Definition at line 923 of file CImg.h.

#define cimg_for7XZ (   img,
  x,
  z 
)    cimg_for7Z(img,z) cimg_for7X(img,x)

Definition at line 915 of file CImg.h.

#define cimg_for7XZV (   img,
  x,
  z,
  v 
)    cimg_for7V(img,v) cimg_for7XZ(img,x,z)

Definition at line 921 of file CImg.h.

#define cimg_for7Y (   img,
  y 
)    cimg_for7((img).height,y)

Definition at line 911 of file CImg.h.

#define cimg_for7YV (   img,
  y,
  v 
)    cimg_for7V(img,v) cimg_for7Y(img,y)

Definition at line 918 of file CImg.h.

#define cimg_for7YZ (   img,
  y,
  z 
)    cimg_for7Z(img,z) cimg_for7Y(img,y)

Definition at line 917 of file CImg.h.

#define cimg_for7YZV (   img,
  y,
  z,
  v 
)    cimg_for7V(img,v) cimg_for7YZ(img,y,z)

Definition at line 922 of file CImg.h.

#define cimg_for7Z (   img,
  z 
)    cimg_for7((img).depth,z)

Definition at line 912 of file CImg.h.

#define cimg_for7ZV (   img,
  z,
  v 
)    cimg_for7V(img,v) cimg_for7Z(img,z)

Definition at line 919 of file CImg.h.

#define cimg_for8 (   bound,
  i 
)
Value:
for (int i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
_n1##i = 1>=(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(bound)?(int)(bound)-1:2, \
_n3##i = 3>=(bound)?(int)(bound)-1:3, \
_n4##i = 4>=(bound)?(int)(bound)-1:4; \
_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
i==(_n4##i = _n3##i = _n2##i = --_n1##i); \
_p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 950 of file CImg.h.

#define cimg_for8V (   img,
  v 
)    cimg_for8((img).dim,v)

Definition at line 962 of file CImg.h.

#define cimg_for8X (   img,
  x 
)    cimg_for8((img).width,x)

Definition at line 959 of file CImg.h.

#define cimg_for8x8 (   img,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1457 of file CImg.h.

#define cimg_for8XV (   img,
  x,
  v 
)    cimg_for8V(img,v) cimg_for8X(img,x)

Definition at line 965 of file CImg.h.

#define cimg_for8XY (   img,
  x,
  y 
)    cimg_for8Y(img,y) cimg_for8X(img,x)

Definition at line 963 of file CImg.h.

#define cimg_for8XYZ (   img,
  x,
  y,
  z 
)    cimg_for8Z(img,z) cimg_for8XY(img,x,y)

Definition at line 969 of file CImg.h.

#define cimg_for8XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for8V(img,v) cimg_for8XYZ(img,x,y,z)

Definition at line 972 of file CImg.h.

#define cimg_for8XZ (   img,
  x,
  z 
)    cimg_for8Z(img,z) cimg_for8X(img,x)

Definition at line 964 of file CImg.h.

#define cimg_for8XZV (   img,
  x,
  z,
  v 
)    cimg_for8V(img,v) cimg_for8XZ(img,x,z)

Definition at line 970 of file CImg.h.

#define cimg_for8Y (   img,
  y 
)    cimg_for8((img).height,y)

Definition at line 960 of file CImg.h.

#define cimg_for8YV (   img,
  y,
  v 
)    cimg_for8V(img,v) cimg_for8Y(img,y)

Definition at line 967 of file CImg.h.

#define cimg_for8YZ (   img,
  y,
  z 
)    cimg_for8Z(img,z) cimg_for8Y(img,y)

Definition at line 966 of file CImg.h.

#define cimg_for8YZV (   img,
  y,
  z,
  v 
)    cimg_for8V(img,v) cimg_for8YZ(img,y,z)

Definition at line 971 of file CImg.h.

#define cimg_for8Z (   img,
  z 
)    cimg_for8((img).depth,z)

Definition at line 961 of file CImg.h.

#define cimg_for8ZV (   img,
  z,
  v 
)    cimg_for8V(img,v) cimg_for8Z(img,z)

Definition at line 968 of file CImg.h.

#define cimg_for9 (   bound,
  i 
)
Value:
for (int i = 0, _p4##i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
_n1##i = 1>=(int)(bound)?(int)(bound)-1:1, \
_n2##i = 2>=(int)(bound)?(int)(bound)-1:2, \
_n3##i = 3>=(int)(bound)?(int)(bound)-1:3, \
_n4##i = 4>=(int)(bound)?(int)(bound)-1:4; \
_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
i==(_n4##i = _n3##i = _n2##i = --_n1##i); \
_p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 1001 of file CImg.h.

#define cimg_for9V (   img,
  v 
)    cimg_for9((img).dim,v)

Definition at line 1013 of file CImg.h.

#define cimg_for9X (   img,
  x 
)    cimg_for9((img).width,x)

Definition at line 1010 of file CImg.h.

#define cimg_for9x9 (   img,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1603 of file CImg.h.

#define cimg_for9XV (   img,
  x,
  v 
)    cimg_for9V(img,v) cimg_for9X(img,x)

Definition at line 1016 of file CImg.h.

#define cimg_for9XY (   img,
  x,
  y 
)    cimg_for9Y(img,y) cimg_for9X(img,x)

Definition at line 1014 of file CImg.h.

#define cimg_for9XYZ (   img,
  x,
  y,
  z 
)    cimg_for9Z(img,z) cimg_for9XY(img,x,y)

Definition at line 1020 of file CImg.h.

#define cimg_for9XYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_for9V(img,v) cimg_for9XYZ(img,x,y,z)

Definition at line 1023 of file CImg.h.

#define cimg_for9XZ (   img,
  x,
  z 
)    cimg_for9Z(img,z) cimg_for9X(img,x)

Definition at line 1015 of file CImg.h.

#define cimg_for9XZV (   img,
  x,
  z,
  v 
)    cimg_for9V(img,v) cimg_for9XZ(img,x,z)

Definition at line 1021 of file CImg.h.

#define cimg_for9Y (   img,
  y 
)    cimg_for9((img).height,y)

Definition at line 1011 of file CImg.h.

#define cimg_for9YV (   img,
  y,
  v 
)    cimg_for9V(img,v) cimg_for9Y(img,y)

Definition at line 1018 of file CImg.h.

#define cimg_for9YZ (   img,
  y,
  z 
)    cimg_for9Z(img,z) cimg_for9Y(img,y)

Definition at line 1017 of file CImg.h.

#define cimg_for9YZV (   img,
  y,
  z,
  v 
)    cimg_for9V(img,v) cimg_for9YZ(img,y,z)

Definition at line 1022 of file CImg.h.

#define cimg_for9Z (   img,
  z 
)    cimg_for9((img).depth,z)

Definition at line 1012 of file CImg.h.

#define cimg_for9ZV (   img,
  z,
  v 
)    cimg_for9V(img,v) cimg_for9Z(img,z)

Definition at line 1019 of file CImg.h.

#define cimg_for_borderV (   img,
  v,
  n 
)    cimg_for_outV(img,n,(img).dim-1-(n),v)

Definition at line 670 of file CImg.h.

#define cimg_for_borderX (   img,
  x,
  n 
)    cimg_for_outX(img,n,(img).width-1-(n),x)

Definition at line 667 of file CImg.h.

#define cimg_for_borderXY (   img,
  x,
  y,
  n 
)    cimg_for_outXY(img,n,n,(img).width-1-(n),(img).height-1-(n),x,y)

Definition at line 671 of file CImg.h.

#define cimg_for_borderXYZ (   img,
  x,
  y,
  z,
  n 
)    cimg_for_outXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)

Definition at line 672 of file CImg.h.

#define cimg_for_borderXYZV (   img,
  x,
  y,
  z,
  v,
  n 
)    cimg_for_outXYZV(img,n,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),(img).dim-1-(n),x,y,z,v)

Definition at line 673 of file CImg.h.

#define cimg_for_borderY (   img,
  y,
  n 
)    cimg_for_outY(img,n,(img).height-1-(n),y)

Definition at line 668 of file CImg.h.

#define cimg_for_borderZ (   img,
  z,
  n 
)    cimg_for_outZ(img,n,(img).depth-1-(n),z)

Definition at line 669 of file CImg.h.

#define cimg_for_in1 (   bound,
  i0,
  i1,
  i 
)    for (int i = (int)(i0)<0?0:(int)(i0), _max##i = (int)(i1)<(int)(bound)?(int)(i1):(int)(bound)-1; i<=_max##i; ++i)

Definition at line 609 of file CImg.h.

#define cimg_for_in2 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1; \
i<=(int)(i1) && (_n1##i<(int)(bound) || i==--_n1##i); \
++i, ++_n1##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 710 of file CImg.h.

#define cimg_for_in2V (   img,
  v0,
  v1,
  v 
)    cimg_for_in2((img).dim,v0,v1,v)

Definition at line 718 of file CImg.h.

#define cimg_for_in2X (   img,
  x0,
  x1,
  x 
)    cimg_for_in2((img).width,x0,x1,x)

Definition at line 715 of file CImg.h.

#define cimg_for_in2x2 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for_in2((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
_n1##x = (int)( \
(I[0] = (img)(x,y,z,v)), \
(I[2] = (img)(x,_n1##y,z,v)), \
x+1>=(int)(img).width?(int)((img).width)-1:x+1); \
x<=(int)(x1) && ((_n1##x<(int)((img).width) && ( \
(I[1] = (img)(_n1##x,y,z,v)), \
(I[3] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x); \
I[0] = I[1], \
I[2] = I[3], \
++x, ++_n1##x)
cimg_for_in2
#define cimg_for_in2(bound, i0, i1, i)
Definition: CImg.h:710
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1067 of file CImg.h.

#define cimg_for_in2x2x2 (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for_in2((img).depth,z0,z1,z) cimg_for_in2((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
_n1##x = (int)( \
(I[0] = (img)(x,y,z,v)), \
(I[2] = (img)(x,_n1##y,z,v)), \
(I[4] = (img)(x,y,_n1##z,v)), \
(I[6] = (img)(x,_n1##y,_n1##z,v)), \
x+1>=(int)(img).width?(int)((img).width)-1:x+1); \
x<=(int)(x1) && ((_n1##x<(int)((img).width) && ( \
(I[1] = (img)(_n1##x,y,z,v)), \
(I[3] = (img)(_n1##x,_n1##y,z,v)), \
(I[5] = (img)(_n1##x,y,_n1##z,v)), \
(I[7] = (img)(_n1##x,_n1##y,_n1##z,v)),1)) || \
x==--_n1##x); \
I[0] = I[1], I[2] = I[3], I[4] = I[5], I[6] = I[7], \
++x, ++_n1##x)
cimg_for_in2
#define cimg_for_in2(bound, i0, i1, i)
Definition: CImg.h:710
y
void int int REAL REAL * y
Definition: read.cpp:74
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1791 of file CImg.h.

#define cimg_for_in2XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2X(img,x0,x1,x)

Definition at line 721 of file CImg.h.

#define cimg_for_in2XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in2Y(img,y0,y1,y) cimg_for_in2X(img,x0,x1,x)

Definition at line 719 of file CImg.h.

#define cimg_for_in2XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in2Z(img,z0,z1,z) cimg_for_in2XY(img,x0,y0,x1,y1,x,y)

Definition at line 725 of file CImg.h.

#define cimg_for_in2XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 728 of file CImg.h.

#define cimg_for_in2XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in2Z(img,z0,z1,z) cimg_for_in2X(img,x0,x1,x)

Definition at line 720 of file CImg.h.

#define cimg_for_in2XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2XZ(img,x0,y0,x1,y1,x,z)

Definition at line 726 of file CImg.h.

#define cimg_for_in2Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in2((img).height,y0,y1,y)

Definition at line 716 of file CImg.h.

#define cimg_for_in2YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2Y(img,y0,y1,y)

Definition at line 723 of file CImg.h.

#define cimg_for_in2YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in2Z(img,z0,z1,z) cimg_for_in2Y(img,y0,y1,y)

Definition at line 722 of file CImg.h.

#define cimg_for_in2YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2YZ(img,y0,z0,y1,z1,y,z)

Definition at line 727 of file CImg.h.

#define cimg_for_in2Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in2((img).depth,z0,z1,z)

Definition at line 717 of file CImg.h.

#define cimg_for_in2ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in2V(img,v0,v1,v) cimg_for_in2Z(img,z0,z1,z)

Definition at line 724 of file CImg.h.

#define cimg_for_in3 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1; \
i<=(int)(i1) && (_n1##i<(int)(bound) || i==--_n1##i); \
_p1##i = i++, ++_n1##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 750 of file CImg.h.

#define cimg_for_in3V (   img,
  v0,
  v1,
  v 
)    cimg_for_in3((img).dim,v0,v1,v)

Definition at line 759 of file CImg.h.

#define cimg_for_in3X (   img,
  x0,
  x1,
  x 
)    cimg_for_in3((img).width,x0,x1,x)

Definition at line 756 of file CImg.h.

#define cimg_for_in3x3 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for_in3((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
_p1##x = x-1<0?0:x-1, \
_n1##x = (int)( \
(I[0] = (img)(_p1##x,_p1##y,z,v)), \
(I[3] = (img)(_p1##x,y,z,v)), \
(I[6] = (img)(_p1##x,_n1##y,z,v)), \
(I[1] = (img)(x,_p1##y,z,v)), \
(I[4] = (img)(x,y,z,v)), \
(I[7] = (img)(x,_n1##y,z,v)), \
x+1>=(int)(img).width?(int)((img).width)-1:x+1); \
x<=(int)(x1) && ((_n1##x<(int)((img).width) && ( \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[5] = (img)(_n1##x,y,z,v)), \
(I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \
x==--_n1##x); \
I[0] = I[1], I[1] = I[2], \
I[3] = I[4], I[4] = I[5], \
I[6] = I[7], I[7] = I[8], \
_p1##x = x++, ++_n1##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
cimg_for_in3
#define cimg_for_in3(bound, i0, i1, i)
Definition: CImg.h:750
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1099 of file CImg.h.

#define cimg_for_in3x3x3 (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1838 of file CImg.h.

#define cimg_for_in3XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3X(img,x0,x1,x)

Definition at line 762 of file CImg.h.

#define cimg_for_in3XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in3Y(img,y0,y1,y) cimg_for_in3X(img,x0,x1,x)

Definition at line 760 of file CImg.h.

#define cimg_for_in3XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in3Z(img,z0,z1,z) cimg_for_in3XY(img,x0,y0,x1,y1,x,y)

Definition at line 766 of file CImg.h.

#define cimg_for_in3XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 769 of file CImg.h.

#define cimg_for_in3XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in3Z(img,z0,z1,z) cimg_for_in3X(img,x0,x1,x)

Definition at line 761 of file CImg.h.

#define cimg_for_in3XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3XZ(img,x0,y0,x1,y1,x,z)

Definition at line 767 of file CImg.h.

#define cimg_for_in3Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in3((img).height,y0,y1,y)

Definition at line 757 of file CImg.h.

#define cimg_for_in3YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3Y(img,y0,y1,y)

Definition at line 764 of file CImg.h.

#define cimg_for_in3YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in3Z(img,z0,z1,z) cimg_for_in3Y(img,y0,y1,y)

Definition at line 763 of file CImg.h.

#define cimg_for_in3YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3YZ(img,y0,z0,y1,z1,y,z)

Definition at line 768 of file CImg.h.

#define cimg_for_in3Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in3((img).depth,z0,z1,z)

Definition at line 758 of file CImg.h.

#define cimg_for_in3ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in3V(img,v0,v1,v) cimg_for_in3Z(img,z0,z1,z)

Definition at line 765 of file CImg.h.

#define cimg_for_in4 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2; \
i<=(int)(i1) && (_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i)); \
_p1##i = i++, ++_n1##i, ++_n2##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 791 of file CImg.h.

#define cimg_for_in4V (   img,
  v0,
  v1,
  v 
)    cimg_for_in4((img).dim,v0,v1,v)

Definition at line 801 of file CImg.h.

#define cimg_for_in4X (   img,
  x0,
  x1,
  x 
)    cimg_for_in4((img).width,x0,x1,x)

Definition at line 798 of file CImg.h.

#define cimg_for_in4x4 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)
Value:
cimg_for_in4((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
_p1##x = x-1<0?0:x-1, \
_n1##x = x+1>=(int)(img).width?(int)((img).width)-1:x+1, \
_n2##x = (int)( \
(I[0] = (img)(_p1##x,_p1##y,z,v)), \
(I[4] = (img)(_p1##x,y,z,v)), \
(I[8] = (img)(_p1##x,_n1##y,z,v)), \
(I[12] = (img)(_p1##x,_n2##y,z,v)), \
(I[1] = (img)(x,_p1##y,z,v)), \
(I[5] = (img)(x,y,z,v)), \
(I[9] = (img)(x,_n1##y,z,v)), \
(I[13] = (img)(x,_n2##y,z,v)), \
(I[2] = (img)(_n1##x,_p1##y,z,v)), \
(I[6] = (img)(_n1##x,y,z,v)), \
(I[10] = (img)(_n1##x,_n1##y,z,v)), \
(I[14] = (img)(_n1##x,_n2##y,z,v)), \
x+2>=(int)(img).width?(int)((img).width)-1:x+2); \
x<=(int)(x1) && ((_n2##x<(int)((img).width) && ( \
(I[3] = (img)(_n2##x,_p1##y,z,v)), \
(I[7] = (img)(_n2##x,y,z,v)), \
(I[11] = (img)(_n2##x,_n1##y,z,v)), \
(I[15] = (img)(_n2##x,_n2##y,z,v)),1)) || \
_n1##x==--_n2##x || x==(_n2##x = --_n1##x)); \
I[0] = I[1], I[1] = I[2], I[2] = I[3], \
I[4] = I[5], I[5] = I[6], I[6] = I[7], \
I[8] = I[9], I[9] = I[10], I[10] = I[11], \
I[12] = I[13], I[13] = I[14], I[14] = I[15], \
_p1##x = x++, ++_n1##x, ++_n2##x)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74
cimg_for_in4
#define cimg_for_in4(bound, i0, i1, i)
Definition: CImg.h:791
for
for(;;)
Definition: rational_rotation.h:111

Definition at line 1146 of file CImg.h.

#define cimg_for_in4XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4X(img,x0,x1,x)

Definition at line 804 of file CImg.h.

#define cimg_for_in4XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in4Y(img,y0,y1,y) cimg_for_in4X(img,x0,x1,x)

Definition at line 802 of file CImg.h.

#define cimg_for_in4XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in4Z(img,z0,z1,z) cimg_for_in4XY(img,x0,y0,x1,y1,x,y)

Definition at line 808 of file CImg.h.

#define cimg_for_in4XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 811 of file CImg.h.

#define cimg_for_in4XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in4Z(img,z0,z1,z) cimg_for_in4X(img,x0,x1,x)

Definition at line 803 of file CImg.h.

#define cimg_for_in4XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4XZ(img,x0,y0,x1,y1,x,z)

Definition at line 809 of file CImg.h.

#define cimg_for_in4Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in4((img).height,y0,y1,y)

Definition at line 799 of file CImg.h.

#define cimg_for_in4YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4Y(img,y0,y1,y)

Definition at line 806 of file CImg.h.

#define cimg_for_in4YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in4Z(img,z0,z1,z) cimg_for_in4Y(img,y0,y1,y)

Definition at line 805 of file CImg.h.

#define cimg_for_in4YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4YZ(img,y0,z0,y1,z1,y,z)

Definition at line 810 of file CImg.h.

#define cimg_for_in4Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in4((img).depth,z0,z1,z)

Definition at line 800 of file CImg.h.

#define cimg_for_in4ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in4V(img,v0,v1,v) cimg_for_in4Z(img,z0,z1,z)

Definition at line 807 of file CImg.h.

#define cimg_for_in5 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p2##i = i-2<0?0:i-2, \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2; \
i<=(int)(i1) && (_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i)); \
_p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 834 of file CImg.h.

#define cimg_for_in5V (   img,
  v0,
  v1,
  v 
)    cimg_for_in5((img).dim,v0,v1,v)

Definition at line 845 of file CImg.h.

#define cimg_for_in5X (   img,
  x0,
  x1,
  x 
)    cimg_for_in5((img).width,x0,x1,x)

Definition at line 842 of file CImg.h.

#define cimg_for_in5x5 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1206 of file CImg.h.

#define cimg_for_in5XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5X(img,x0,x1,x)

Definition at line 848 of file CImg.h.

#define cimg_for_in5XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in5Y(img,y0,y1,y) cimg_for_in5X(img,x0,x1,x)

Definition at line 846 of file CImg.h.

#define cimg_for_in5XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in5Z(img,z0,z1,z) cimg_for_in5XY(img,x0,y0,x1,y1,x,y)

Definition at line 852 of file CImg.h.

#define cimg_for_in5XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 855 of file CImg.h.

#define cimg_for_in5XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in5Z(img,z0,z1,z) cimg_for_in5X(img,x0,x1,x)

Definition at line 847 of file CImg.h.

#define cimg_for_in5XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5XZ(img,x0,y0,x1,y1,x,z)

Definition at line 853 of file CImg.h.

#define cimg_for_in5Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in5((img).height,y0,y1,y)

Definition at line 843 of file CImg.h.

#define cimg_for_in5YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5Y(img,y0,y1,y)

Definition at line 850 of file CImg.h.

#define cimg_for_in5YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in5Z(img,z0,z1,z) cimg_for_in5Y(img,y0,y1,y)

Definition at line 849 of file CImg.h.

#define cimg_for_in5YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5YZ(img,y0,z0,y1,z1,y,z)

Definition at line 854 of file CImg.h.

#define cimg_for_in5Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in5((img).depth,z0,z1,z)

Definition at line 844 of file CImg.h.

#define cimg_for_in5ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in5V(img,v0,v1,v) cimg_for_in5Z(img,z0,z1,z)

Definition at line 851 of file CImg.h.

#define cimg_for_in6 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p2##i = i-2<0?0:i-2, \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \
_n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3; \
i<=(int)(i1) && (_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i)); \
_p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 879 of file CImg.h.

#define cimg_for_in6V (   img,
  v0,
  v1,
  v 
)    cimg_for_in6((img).dim,v0,v1,v)

Definition at line 891 of file CImg.h.

#define cimg_for_in6X (   img,
  x0,
  x1,
  x 
)    cimg_for_in6((img).width,x0,x1,x)

Definition at line 888 of file CImg.h.

#define cimg_for_in6x6 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1288 of file CImg.h.

#define cimg_for_in6XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6X(img,x0,x1,x)

Definition at line 894 of file CImg.h.

#define cimg_for_in6XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in6Y(img,y0,y1,y) cimg_for_in6X(img,x0,x1,x)

Definition at line 892 of file CImg.h.

#define cimg_for_in6XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in6Z(img,z0,z1,z) cimg_for_in6XY(img,x0,y0,x1,y1,x,y)

Definition at line 898 of file CImg.h.

#define cimg_for_in6XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 901 of file CImg.h.

#define cimg_for_in6XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in6Z(img,z0,z1,z) cimg_for_in6X(img,x0,x1,x)

Definition at line 893 of file CImg.h.

#define cimg_for_in6XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6XZ(img,x0,y0,x1,y1,x,z)

Definition at line 899 of file CImg.h.

#define cimg_for_in6Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in6((img).height,y0,y1,y)

Definition at line 889 of file CImg.h.

#define cimg_for_in6YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6Y(img,y0,y1,y)

Definition at line 896 of file CImg.h.

#define cimg_for_in6YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in6Z(img,z0,z1,z) cimg_for_in6Y(img,y0,y1,y)

Definition at line 895 of file CImg.h.

#define cimg_for_in6YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6YZ(img,y0,z0,y1,z1,y,z)

Definition at line 900 of file CImg.h.

#define cimg_for_in6Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in6((img).depth,z0,z1,z)

Definition at line 890 of file CImg.h.

#define cimg_for_in6ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in6V(img,v0,v1,v) cimg_for_in6Z(img,z0,z1,z)

Definition at line 897 of file CImg.h.

#define cimg_for_in7 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p3##i = i-3<0?0:i-3, \
_p2##i = i-2<0?0:i-2, \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \
_n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3; \
i<=(int)(i1) && (_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i)); \
_p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 925 of file CImg.h.

#define cimg_for_in7V (   img,
  v0,
  v1,
  v 
)    cimg_for_in7((img).dim,v0,v1,v)

Definition at line 938 of file CImg.h.

#define cimg_for_in7X (   img,
  x0,
  x1,
  x 
)    cimg_for_in7((img).width,x0,x1,x)

Definition at line 935 of file CImg.h.

#define cimg_for_in7x7 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1388 of file CImg.h.

#define cimg_for_in7XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7X(img,x0,x1,x)

Definition at line 941 of file CImg.h.

#define cimg_for_in7XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in7Y(img,y0,y1,y) cimg_for_in7X(img,x0,x1,x)

Definition at line 939 of file CImg.h.

#define cimg_for_in7XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in7Z(img,z0,z1,z) cimg_for_in7XY(img,x0,y0,x1,y1,x,y)

Definition at line 945 of file CImg.h.

#define cimg_for_in7XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 948 of file CImg.h.

#define cimg_for_in7XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in7Z(img,z0,z1,z) cimg_for_in7X(img,x0,x1,x)

Definition at line 940 of file CImg.h.

#define cimg_for_in7XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7XZ(img,x0,y0,x1,y1,x,z)

Definition at line 946 of file CImg.h.

#define cimg_for_in7Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in7((img).height,y0,y1,y)

Definition at line 936 of file CImg.h.

#define cimg_for_in7YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7Y(img,y0,y1,y)

Definition at line 943 of file CImg.h.

#define cimg_for_in7YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in7Z(img,z0,z1,z) cimg_for_in7Y(img,y0,y1,y)

Definition at line 942 of file CImg.h.

#define cimg_for_in7YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7YZ(img,y0,z0,y1,z1,y,z)

Definition at line 947 of file CImg.h.

#define cimg_for_in7Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in7((img).depth,z0,z1,z)

Definition at line 937 of file CImg.h.

#define cimg_for_in7ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in7V(img,v0,v1,v) cimg_for_in7Z(img,z0,z1,z)

Definition at line 944 of file CImg.h.

#define cimg_for_in8 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p3##i = i-3<0?0:i-3, \
_p2##i = i-2<0?0:i-2, \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \
_n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3, \
_n4##i = i+4>=(int)(bound)?(int)(bound)-1:i+4; \
i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \
_p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 974 of file CImg.h.

#define cimg_for_in8V (   img,
  v0,
  v1,
  v 
)    cimg_for_in8((img).dim,v0,v1,v)

Definition at line 989 of file CImg.h.

#define cimg_for_in8X (   img,
  x0,
  x1,
  x 
)    cimg_for_in8((img).width,x0,x1,x)

Definition at line 986 of file CImg.h.

#define cimg_for_in8x8 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1517 of file CImg.h.

#define cimg_for_in8XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8X(img,x0,x1,x)

Definition at line 992 of file CImg.h.

#define cimg_for_in8XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in8Y(img,y0,y1,y) cimg_for_in8X(img,x0,x1,x)

Definition at line 990 of file CImg.h.

#define cimg_for_in8XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in8Z(img,z0,z1,z) cimg_for_in8XY(img,x0,y0,x1,y1,x,y)

Definition at line 996 of file CImg.h.

#define cimg_for_in8XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 999 of file CImg.h.

#define cimg_for_in8XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in8Z(img,z0,z1,z) cimg_for_in8X(img,x0,x1,x)

Definition at line 991 of file CImg.h.

#define cimg_for_in8XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8XZ(img,x0,y0,x1,y1,x,z)

Definition at line 997 of file CImg.h.

#define cimg_for_in8Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in8((img).height,y0,y1,y)

Definition at line 987 of file CImg.h.

#define cimg_for_in8YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8Y(img,y0,y1,y)

Definition at line 994 of file CImg.h.

#define cimg_for_in8YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in8Z(img,z0,z1,z) cimg_for_in8Y(img,y0,y1,y)

Definition at line 993 of file CImg.h.

#define cimg_for_in8YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8YZ(img,y0,z0,y1,z1,y,z)

Definition at line 998 of file CImg.h.

#define cimg_for_in8Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in8((img).depth,z0,z1,z)

Definition at line 988 of file CImg.h.

#define cimg_for_in8ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in8V(img,v0,v1,v) cimg_for_in8Z(img,z0,z1,z)

Definition at line 995 of file CImg.h.

#define cimg_for_in9 (   bound,
  i0,
  i1,
  i 
)
Value:
for (int i = (int)(i0)<0?0:(int)(i0), \
_p4##i = i-4<0?0:i-4, \
_p3##i = i-3<0?0:i-3, \
_p2##i = i-2<0?0:i-2, \
_p1##i = i-1<0?0:i-1, \
_n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \
_n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \
_n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3, \
_n4##i = i+4>=(int)(bound)?(int)(bound)-1:i+4; \
i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \
_p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
i
blockLoc i
Definition: read.cpp:79

Definition at line 1025 of file CImg.h.

#define cimg_for_in9V (   img,
  v0,
  v1,
  v 
)    cimg_for_in9((img).dim,v0,v1,v)

Definition at line 1041 of file CImg.h.

#define cimg_for_in9X (   img,
  x0,
  x1,
  x 
)    cimg_for_in9((img).width,x0,x1,x)

Definition at line 1038 of file CImg.h.

#define cimg_for_in9x9 (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y,
  z,
  v,
  I 
)

Definition at line 1669 of file CImg.h.

#define cimg_for_in9XV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9X(img,x0,x1,x)

Definition at line 1044 of file CImg.h.

#define cimg_for_in9XY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_in9Y(img,y0,y1,y) cimg_for_in9X(img,x0,x1,x)

Definition at line 1042 of file CImg.h.

#define cimg_for_in9XYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_in9Z(img,z0,z1,z) cimg_for_in9XY(img,x0,y0,x1,y1,x,y)

Definition at line 1048 of file CImg.h.

#define cimg_for_in9XYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 1051 of file CImg.h.

#define cimg_for_in9XZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_in9Z(img,z0,z1,z) cimg_for_in9X(img,x0,x1,x)

Definition at line 1043 of file CImg.h.

#define cimg_for_in9XZV (   img,
  x0,
  z0,
  v0,
  x1,
  y1,
  v1,
  x,
  z,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9XZ(img,x0,y0,x1,y1,x,z)

Definition at line 1049 of file CImg.h.

#define cimg_for_in9Y (   img,
  y0,
  y1,
  y 
)    cimg_for_in9((img).height,y0,y1,y)

Definition at line 1039 of file CImg.h.

#define cimg_for_in9YV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9Y(img,y0,y1,y)

Definition at line 1046 of file CImg.h.

#define cimg_for_in9YZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_in9Z(img,z0,z1,z) cimg_for_in9Y(img,y0,y1,y)

Definition at line 1045 of file CImg.h.

#define cimg_for_in9YZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9YZ(img,y0,z0,y1,z1,y,z)

Definition at line 1050 of file CImg.h.

#define cimg_for_in9Z (   img,
  z0,
  z1,
  z 
)    cimg_for_in9((img).depth,z0,z1,z)

Definition at line 1040 of file CImg.h.

#define cimg_for_in9ZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_in9V(img,v0,v1,v) cimg_for_in9Z(img,z0,z1,z)

Definition at line 1047 of file CImg.h.

#define cimg_for_insideV (   img,
  v,
  n 
)    cimg_for_inV(img,n,(img).dim-1-(n),v)

Definition at line 629 of file CImg.h.

#define cimg_for_insideX (   img,
  x,
  n 
)    cimg_for_inX(img,n,(img).width-1-(n),x)

Definition at line 626 of file CImg.h.

#define cimg_for_insideXY (   img,
  x,
  y,
  n 
)    cimg_for_inXY(img,n,n,(img).width-1-(n),(img).height-1-(n),x,y)

Definition at line 630 of file CImg.h.

#define cimg_for_insideXYZ (   img,
  x,
  y,
  z,
  n 
)    cimg_for_inXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)

Definition at line 631 of file CImg.h.

#define cimg_for_insideXYZV (   img,
  x,
  y,
  z,
  v,
  n 
)    cimg_for_inXYZ(img,n,n,n,(img).width-1-(n),(img).height-1-(n),(img).depth-1-(n),x,y,z)

Definition at line 632 of file CImg.h.

#define cimg_for_insideY (   img,
  y,
  n 
)    cimg_for_inY(img,n,(img).height-1-(n),y)

Definition at line 627 of file CImg.h.

#define cimg_for_insideZ (   img,
  z,
  n 
)    cimg_for_inZ(img,n,(img).depth-1-(n),z)

Definition at line 628 of file CImg.h.

#define cimg_for_inV (   img,
  v0,
  v1,
  v 
)    cimg_for_in1((img).dim,v0,v1,v)

Definition at line 614 of file CImg.h.

#define cimg_for_inX (   img,
  x0,
  x1,
  x 
)    cimg_for_in1((img).width,x0,x1,x)

Definition at line 611 of file CImg.h.

#define cimg_for_inXV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inX(img,x0,x1,x)

Definition at line 617 of file CImg.h.

#define cimg_for_inXY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_inY(img,y0,y1,y) cimg_for_inX(img,x0,x1,x)

Definition at line 615 of file CImg.h.

Referenced by CImg< uintT >::draw_mandelbrot(), and CImg< uintT >::get_blur_patch().

#define cimg_for_inXYV (   img,
  x0,
  y0,
  v0,
  x1,
  y1,
  v1,
  x,
  y,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inXY(img,x0,y0,x1,y1,x,y)

Definition at line 622 of file CImg.h.

#define cimg_for_inXYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_inZ(img,z0,z1,z) cimg_for_inXY(img,x0,y0,x1,y1,x,y)

Definition at line 621 of file CImg.h.

Referenced by CImg< uintT >::get_blur_patch().

#define cimg_for_inXYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 625 of file CImg.h.

#define cimg_for_inXZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_inZ(img,z0,z1,z) cimg_for_inX(img,x0,x1,x)

Definition at line 616 of file CImg.h.

#define cimg_for_inXZV (   img,
  x0,
  z0,
  v0,
  x1,
  z1,
  v1,
  x,
  z,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inXZ(img,x0,z0,x1,z1,x,z)

Definition at line 623 of file CImg.h.

#define cimg_for_inY (   img,
  y0,
  y1,
  y 
)    cimg_for_in1((img).height,y0,y1,y)

Definition at line 612 of file CImg.h.

#define cimg_for_inYV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inY(img,y0,y1,y)

Definition at line 619 of file CImg.h.

#define cimg_for_inYZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_inZ(img,x0,z1,z) cimg_for_inY(img,y0,y1,y)

Definition at line 618 of file CImg.h.

#define cimg_for_inYZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inYZ(img,y0,z0,y1,z1,y,z)

Definition at line 624 of file CImg.h.

#define cimg_for_inZ (   img,
  z0,
  z1,
  z 
)    cimg_for_in1((img).depth,z0,z1,z)

Definition at line 613 of file CImg.h.

#define cimg_for_inZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_inV(img,v0,v1,v) cimg_for_inZ(img,z0,z1,z)

Definition at line 620 of file CImg.h.

#define cimg_for_lineXY (   x,
  y,
  x0,
  y0,
  x1,
  y1 
)
Value:
for (int x = (int)(x0), y = (int)(y0), _sx = 1, _sy = 1, _steep = 0, \
_dx=(x1)>(x0)?(int)(x1)-(int)(x0):(_sx=-1,(int)(x0)-(int)(x1)), \
_dy=(y1)>(y0)?(int)(y1)-(int)(y0):(_sy=-1,(int)(y0)-(int)(y1)), \
_counter = _dx, \
_err = _dx>_dy?(_dy>>1):((_steep=1),(_counter=_dy),(_dx>>1)); \
_counter>=0; \
--_counter, x+=_steep? \
(y+=_sy,(_err-=_dx)<0?_err+=_dy,_sx:0): \
(y+=(_err-=_dy)<0?_err+=_dx,_sy:0,_sx))
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 680 of file CImg.h.

#define cimg_for_out1 (   boundi,
  i0,
  i1,
  i 
)    for (int i = (int)(i0)>0?0:(int)(i1)+1; i<(int)(boundi); ++i, i = i==(int)(i0)?(int)(i1)+1:i)

Definition at line 634 of file CImg.h.

#define cimg_for_out2 (   boundi,
  boundj,
  i0,
  j0,
  i1,
  j1,
  i,
  j 
)
Value:
for (int j = 0; j<(int)(boundj); ++j) \
for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j?0:(int)(i0)>0?0:(int)(i1)+1; i<(int)(boundi); \
++i, i = _n1j?i:(i==(int)(i0)?(int)(i1)+1:i))
i
blockLoc i
Definition: read.cpp:79
j
j indices j
Definition: Indexing.h:6

Definition at line 636 of file CImg.h.

#define cimg_for_out3 (   boundi,
  boundj,
  boundk,
  i0,
  j0,
  k0,
  i1,
  j1,
  k1,
  i,
  j,
  k 
)
Value:
for (int k = 0; k<(int)(boundk); ++k) \
for (int _n1k = (int)(k<(int)(k0) || k>(int)(k1)), j = 0; j<(int)(boundj); ++j) \
for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j || _n1k?0:(int)(i0)>0?0:(int)(i1)+1; i<(int)(boundi); \
++i, i = _n1j || _n1k?i:(i==(int)(i0)?(int)(i1)+1:i))
k
j indices k indices k
Definition: Indexing.h:6
i
blockLoc i
Definition: read.cpp:79
j
j indices j
Definition: Indexing.h:6

Definition at line 640 of file CImg.h.

#define cimg_for_out4 (   boundi,
  boundj,
  boundk,
  boundl,
  i0,
  j0,
  k0,
  l0,
  i1,
  j1,
  k1,
  l1,
  i,
  j,
  k,
  l 
)
Value:
for (int l = 0; l<(int)(boundl); ++l) \
for (int _n1l = (int)(l<(int)(l0) || l>(int)(l1)), k = 0; k<(int)(boundk); ++k) \
for (int _n1k = (int)(k<(int)(k0) || k>(int)(k1)), j = 0; j<(int)(boundj); ++j) \
for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j || _n1k || _n1l?0:(int)(i0)>0?0:(int)(i1)+1; i<(int)(boundi); \
++i, i = _n1j || _n1k || _n1l?i:(i==(int)(i0)?(int)(i1)+1:i))
k
j indices k indices k
Definition: Indexing.h:6
i
blockLoc i
Definition: read.cpp:79
j
j indices j
Definition: Indexing.h:6

Definition at line 645 of file CImg.h.

#define cimg_for_outV (   img,
  v0,
  v1,
  v 
)    cimg_for_out1((img).dim,v0,v1,v)

Definition at line 654 of file CImg.h.

#define cimg_for_outX (   img,
  x0,
  x1,
  x 
)    cimg_for_out1((img).width,x0,x1,x)

Definition at line 651 of file CImg.h.

#define cimg_for_outXV (   img,
  x0,
  v0,
  x1,
  v1,
  x,
  v 
)    cimg_for_out2((img).width,(img).dim,x0,v0,x1,v1,x,v)

Definition at line 657 of file CImg.h.

#define cimg_for_outXY (   img,
  x0,
  y0,
  x1,
  y1,
  x,
  y 
)    cimg_for_out2((img).width,(img).height,x0,y0,x1,y1,x,y)

Definition at line 655 of file CImg.h.

#define cimg_for_outXYV (   img,
  x0,
  y0,
  v0,
  x1,
  y1,
  v1,
  x,
  y,
  v 
)    cimg_for_out3((img).width,(img).height,(img).dim,x0,y0,v0,x1,y1,v1,x,y,v)

Definition at line 662 of file CImg.h.

#define cimg_for_outXYZ (   img,
  x0,
  y0,
  z0,
  x1,
  y1,
  z1,
  x,
  y,
  z 
)    cimg_for_out3((img).width,(img).height,(img).depth,x0,y0,z0,x1,y1,z1,x,y,z)

Definition at line 661 of file CImg.h.

#define cimg_for_outXYZV (   img,
  x0,
  y0,
  z0,
  v0,
  x1,
  y1,
  z1,
  v1,
  x,
  y,
  z,
  v 
)    cimg_for_out4((img).width,(img).height,(img).depth,(img).dim,x0,y0,z0,v0,x1,y1,z1,v1,x,y,z,v)

Definition at line 665 of file CImg.h.

Referenced by CImg< uintT >::get_resize().

#define cimg_for_outXZ (   img,
  x0,
  z0,
  x1,
  z1,
  x,
  z 
)    cimg_for_out2((img).width,(img).depth,x0,z0,x1,z1,x,z)

Definition at line 656 of file CImg.h.

#define cimg_for_outXZV (   img,
  x0,
  z0,
  v0,
  x1,
  z1,
  v1,
  x,
  z,
  v 
)    cimg_for_out3((img).width,(img).depth,(img).dim,x0,z0,v0,x1,z1,v1,x,z,v)

Definition at line 663 of file CImg.h.

#define cimg_for_outY (   img,
  y0,
  y1,
  y 
)    cimg_for_out1((img).height,y0,y1,y)

Definition at line 652 of file CImg.h.

#define cimg_for_outYV (   img,
  y0,
  v0,
  y1,
  v1,
  y,
  v 
)    cimg_for_out2((img).height,(img).dim,y0,v0,y1,v1,y,v)

Definition at line 659 of file CImg.h.

#define cimg_for_outYZ (   img,
  y0,
  z0,
  y1,
  z1,
  y,
  z 
)    cimg_for_out2((img).height,(img).depth,y0,z0,y1,z1,y,z)

Definition at line 658 of file CImg.h.

#define cimg_for_outYZV (   img,
  y0,
  z0,
  v0,
  y1,
  z1,
  v1,
  y,
  z,
  v 
)    cimg_for_out3((img).height,(img).depth,(img).dim,y0,z0,v0,y1,z1,v1,y,z,v)

Definition at line 664 of file CImg.h.

#define cimg_for_outZ (   img,
  z0,
  z1,
  z 
)    cimg_for_out1((img).depth,z0,z1,z)

Definition at line 653 of file CImg.h.

#define cimg_for_outZV (   img,
  z0,
  v0,
  z1,
  v1,
  z,
  v 
)    cimg_for_out2((img).depth,(img).dim,z0,v0,z1,v1,z,v)

Definition at line 660 of file CImg.h.

#define cimg_for_spiralXY (   img,
  x,
  y 
)
Value:
for (int x = 0, y = 0, _n1##x = 1, _n1##y = (int)((img).width*(img).height); _n1##y; \
--_n1##y, _n1##x += (_n1##x>>2)-((!(_n1##x&3)?--y:((_n1##x&3)==1?(img).width-1-++x:((_n1##x&3)==2?(img).height-1-++y:--x))))?0:1)
y
void int int REAL REAL * y
Definition: read.cpp:74
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 676 of file CImg.h.

#define cimg_foroff (   img,
  off 
)    for (unsigned int off = 0, _max##off = (unsigned int)(img).size(); off<_max##off; ++off)

Definition at line 590 of file CImg.h.

Referenced by CImg< uintT >::_load_analyze(), CImg< uintT >::_load_pandore(), CImg< uintT >::_load_pnm(), CImg< uintT >::draw_axis(), CImg< uintT >::draw_graph(), CImg< uintT >::draw_grid(), CImg< uintT >::get_diagonal(), CImg< uintT >::get_label_regions(), CImg< uintT >::magnitude(), CImg< uintT >::print(), CImg< uintT >::sequence(), and CImg< uintT >::sort().

#define cimg_forV (   img,
  v 
)    cimg_for1((img).dim,v)

Definition at line 596 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::_draw_scanline(), CImg< uintT >::_draw_text(), CImg< uintT >::_save_inr(), CImg< uintT >::_save_raw(), CImg< uintT >::autocrop(), CImg< uintT >::blur_anisotropic(), CImg< uintT >::blur_bilateral(), CImg< uintT >::display_graph(), CImg< uintT >::distance_hamilton(), CImg< uintT >::draw_gaussian(), CImg< uintT >::draw_graph(), CImg< uintT >::draw_line(), CImg< uintT >::draw_mandelbrot(), CImg< uintT >::draw_plasma(), CImg< uintT >::draw_point(), CImg< uintT >::draw_rectangle(), CImg< uintT >::draw_triangle(), CImg< uintT >::FFT(), CImg< uintT >::get_blur_median(), CImg< uintT >::get_blur_patch(), CImg< uintT >::get_correlate(), CImg< uintT >::get_dilate(), CImg< uintT >::get_displacement_field(), CImg< uintT >::get_distance(), CImg< uintT >::get_erode(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_index(), CImg< uintT >::get_map(), CImg< uintT >::get_matrix_at(), CImg< uintT >::get_norm(), CImg< uintT >::get_resize(), CImg< uintT >::get_select_graph(), CImg< uintT >::get_structure_tensor(), CImg< uintT >::get_vector_at(), CImg< uintT >::mirror(), CImg< uintT >::normalize(), CImg< uintT >::sharpen(), and CImg< uintT >::translate().

#define cimg_forX (   img,
  x 
)    cimg_for1((img).width,x)

Definition at line 593 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::_display_object3d(), CImg< uintT >::_draw_object3d(), CImg< uintT >::_load_bmp(), CImg< uintT >::_load_off(), CImg< uintT >::_load_png(), CImg< uintT >::_LU(), CImg< uintT >::_save_ascii(), CImg< uintT >::_save_bmp(), CImg< uintT >::_save_dlm(), CImg< uintT >::_save_off(), CImg< uintT >::_save_png(), CImg< uintT >::det(), CImg< uintT >::dijkstra(), CImg< uintT >::draw_gaussian(), CImg< uintT >::draw_graph(), CImg< uintT >::equalize(), CImg< uintT >::FFT(), CImg< uintT >::get_distance(), CImg< uintT >::get_index(), CImg< uintT >::get_pseudoinvert(), CImg< uintT >::get_resize(), CImg< uintT >::identity_matrix(), CImg< uintT >::invert(), CImg< uintT >::isocurve3d(), CImg< uintT >::isosurface3d(), CImg< uintT >::operator*(), CImg< uintT >::SVD(), CImg< uintT >::symmetric_eigen(), and CImg< uintT >::trace().

#define cimg_forXV (   img,
  x,
  v 
)    cimg_forV(img,v) cimg_forX(img,x)

Definition at line 600 of file CImg.h.

Referenced by CImg< uintT >::get_blur_median().

#define cimg_forXY (   img,
  x,
  y 
)    cimg_forY(img,y) cimg_forX(img,x)

Definition at line 597 of file CImg.h.

Referenced by CImg< uintT >::_draw_object3d(), CImg< uintT >::_load_jpeg(), CImg< uintT >::_load_pnm(), CImgList< uintT >::_load_yuv(), CImg< uintT >::_save_jpeg(), CImg< uintT >::_save_pnm(), CImg< uintT >::blur_anisotropic(), CImg< uintT >::blur_bilateral(), CImg< uintT >::edge_tensors(), CImg< uintT >::get_blur_patch(), CImgList< uintT >::get_crop_font(), CImg< uintT >::get_distance(), CImg< uintT >::get_label_regions(), CImg< uintT >::get_rotate(), CImg< uintT >::invert(), CImgList< uintT >::load_parrec(), CImg< uintT >::operator*(), CImgList< uintT >::save_ffmpeg(), CImg< uintT >::sharpen(), CImg< uintT >::solve(), and CImg< uintT >::symmetric_eigen().

#define cimg_forXYV (   img,
  x,
  y,
  v 
)    cimg_forV(img,v) cimg_forXY(img,x,y)

Definition at line 604 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::deriche(), CImg< uintT >::FFT(), CImg< uintT >::get_blur_median(), CImg< uintT >::get_haar(), CImg< uintT >::get_projections2d(), and CImg< uintT >::get_resize().

#define cimg_forXYZ (   img,
  x,
  y,
  z 
)    cimg_forZ(img,z) cimg_forXY(img,x,y)

Definition at line 603 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::_load_raw(), CImg< uintT >::_save_inr(), CImg< uintT >::_save_raw(), CImg< uintT >::blur_anisotropic(), CImg< uintT >::blur_bilateral(), CImg< uintT >::deriche(), CImg< uintT >::draw_gaussian(), CImg< uintT >::edge_tensors(), CImg< uintT >::FFT(), CImg< uintT >::get_BayertoRGB(), CImg< uintT >::get_blur_patch(), CImg< uintT >::get_norm(), CImg< uintT >::get_resize(), CImg< uintT >::get_RGBtoBayer(), CImg< uintT >::normalize(), and CImg< uintT >::sharpen().

#define cimg_forXYZV (   img,
  x,
  y,
  z,
  v 
)    cimg_forV(img,v) cimg_forXYZ(img,x,y,z)

Definition at line 607 of file CImg.h.

Referenced by CImg< uintT >::_get_permute_axes(), CImg< uintT >::fill(), CImg< uintT >::get_blur_median(), CImg< uintT >::get_crop(), CImg< uintT >::get_resize(), CImg< uintT >::get_rotate(), CImg< uintT >::get_warp(), CImg< uintT >::max(), CImg< uintT >::min(), CImg< uintT >::operator%=(), CImg< uintT >::operator&=(), CImg< uintT >::operator*=(), CImg< uintT >::operator+=(), CImg< uintT >::operator-=(), CImg< uintT >::operator/=(), CImg< uintT >::operator^=(), CImg< uintT >::operator|=(), and CImg< uintT >::pow().

#define cimg_forXZ (   img,
  x,
  z 
)    cimg_forZ(img,z) cimg_forX(img,x)

Definition at line 598 of file CImg.h.

Referenced by CImg< uintT >::get_distance().

#define cimg_forXZV (   img,
  x,
  z,
  v 
)    cimg_forV(img,v) cimg_forXZ(img,x,z)

Definition at line 605 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::deriche(), CImg< uintT >::FFT(), CImg< uintT >::get_haar(), CImg< uintT >::get_projections2d(), and CImg< uintT >::get_resize().

#define cimg_forY (   img,
  y 
)    cimg_for1((img).height,y)

Definition at line 594 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::_load_png(), CImg< uintT >::_save_bmp(), CImg< uintT >::_save_png(), CImg< uintT >::draw_gaussian(), CImg< uintT >::FFT(), CImg< uintT >::get_distance(), CImg< uintT >::get_pseudoinvert(), CImg< uintT >::get_resize(), CImg< uintT >::invert(), CImg< uintT >::isosurface3d(), CImg< uintT >::solve(), CImg< uintT >::SVD(), and CImg< uintT >::symmetric_eigen().

#define cimg_forYV (   img,
  y,
  v 
)    cimg_forV(img,v) cimg_forY(img,y)

Definition at line 601 of file CImg.h.

#define cimg_forYZ (   img,
  y,
  z 
)    cimg_forZ(img,z) cimg_forY(img,y)

Definition at line 599 of file CImg.h.

Referenced by CImg< uintT >::get_distance(), and CImg< uintT >::get_index().

#define cimg_forYZV (   img,
  y,
  z,
  v 
)    cimg_forV(img,v) cimg_forYZ(img,y,z)

Definition at line 606 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::_save_ascii(), CImg< uintT >::_save_dlm(), CImg< uintT >::deriche(), CImg< uintT >::FFT(), CImg< uintT >::get_correlate(), CImg< uintT >::get_dilate(), CImg< uintT >::get_erode(), CImg< uintT >::get_haar(), CImg< uintT >::get_projections2d(), CImg< uintT >::get_resize(), CImg< uintT >::translate(), and CImg< uintT >::transpose().

#define cimg_forZ (   img,
  z 
)    cimg_for1((img).depth,z)

Definition at line 595 of file CImg.h.

Referenced by CImg< uintT >::_autocrop(), CImg< uintT >::FFT(), CImg< uintT >::get_distance(), CImg< uintT >::get_resize(), and CImg< uintT >::save_tiff().

#define cimg_forZV (   img,
  z,
  v 
)    cimg_forV(img,v) cimg_forZ(img,z)

Definition at line 602 of file CImg.h.

Referenced by CImg< uintT >::blur_anisotropic(), CImg< uintT >::get_correlate(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_resize_doubleXY(), CImg< uintT >::get_resize_halfXY(), CImg< uintT >::get_resize_tripleXY(), CImg< uintT >::get_rotate(), and CImg< uintT >::translate().

#define cimg_get2x2 (   img,
  x,
  y,
  z,
  v,
  I 
)    I[0] = (img)(x,y,z,v), I[1] = (img)(_n1##x,y,z,v), I[2] = (img)(x,_n1##y,z,v), I[3] = (img)(_n1##x,_n1##y,z,v)

Definition at line 481 of file CImg.h.

#define cimg_get2x2x2 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(x,y,z,v), I[1] = (img)(_n1##x,y,z,v), I[2] = (img)(x,_n1##y,z,v), I[3] = (img)(_n1##x,_n1##y,z,v), \
I[4] = (img)(x,y,_n1##z,v), I[5] = (img)(_n1##x,y,_n1##z,v), I[6] = (img)(x,_n1##y,_n1##z,v), I[7] = (img)(_n1##x,_n1##y,_n1##z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 571 of file CImg.h.

#define cimg_get3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p1##x,_p1##y,z,v), I[1] = (img)(x,_p1##y,z,v), I[2] = (img)(_n1##x,_p1##y,z,v), I[3] = (img)(_p1##x,y,z,v), \
I[4] = (img)(x,y,z,v), I[5] = (img)(_n1##x,y,z,v), I[6] = (img)(_p1##x,_n1##y,z,v), I[7] = (img)(x,_n1##y,z,v), \
I[8] = (img)(_n1##x,_n1##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 484 of file CImg.h.

Referenced by CImg< uintT >::get_BayertoRGB().

#define cimg_get3x3x3 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p1##x,_p1##y,_p1##z,v), I[1] = (img)(x,_p1##y,_p1##z,v), I[2] = (img)(_n1##x,_p1##y,_p1##z,v), \
I[3] = (img)(_p1##x,y,_p1##z,v), I[4] = (img)(x,y,_p1##z,v), I[5] = (img)(_n1##x,y,_p1##z,v), \
I[6] = (img)(_p1##x,_n1##y,_p1##z,v), I[7] = (img)(x,_n1##y,_p1##z,v), I[8] = (img)(_n1##x,_n1##y,_p1##z,v), \
I[9] = (img)(_p1##x,_p1##y,z,v), I[10] = (img)(x,_p1##y,z,v), I[11] = (img)(_n1##x,_p1##y,z,v), \
I[12] = (img)(_p1##x,y,z,v), I[13] = (img)(x,y,z,v), I[14] = (img)(_n1##x,y,z,v), \
I[15] = (img)(_p1##x,_n1##y,z,v), I[16] = (img)(x,_n1##y,z,v), I[17] = (img)(_n1##x,_n1##y,z,v), \
I[18] = (img)(_p1##x,_p1##y,_n1##z,v), I[19] = (img)(x,_p1##y,_n1##z,v), I[20] = (img)(_n1##x,_p1##y,_n1##z,v), \
I[21] = (img)(_p1##x,y,_n1##z,v), I[22] = (img)(x,y,_n1##z,v), I[23] = (img)(_n1##x,y,_n1##z,v), \
I[24] = (img)(_p1##x,_n1##y,_n1##z,v), I[25] = (img)(x,_n1##y,_n1##z,v), I[26] = (img)(_n1##x,_n1##y,_n1##z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 575 of file CImg.h.

#define cimg_get4x4 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p1##x,_p1##y,z,v), I[1] = (img)(x,_p1##y,z,v), I[2] = (img)(_n1##x,_p1##y,z,v), I[3] = (img)(_n2##x,_p1##y,z,v), \
I[4] = (img)(_p1##x,y,z,v), I[5] = (img)(x,y,z,v), I[6] = (img)(_n1##x,y,z,v), I[7] = (img)(_n2##x,y,z,v), \
I[8] = (img)(_p1##x,_n1##y,z,v), I[9] = (img)(x,_n1##y,z,v), I[10] = (img)(_n1##x,_n1##y,z,v), I[11] = (img)(_n2##x,_n1##y,z,v), \
I[12] = (img)(_p1##x,_n2##y,z,v), I[13] = (img)(x,_n2##y,z,v), I[14] = (img)(_n1##x,_n2##y,z,v), I[15] = (img)(_n2##x,_n2##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 489 of file CImg.h.

#define cimg_get5x5 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p2##x,_p2##y,z,v), I[1] = (img)(_p1##x,_p2##y,z,v), I[2] = (img)(x,_p2##y,z,v), I[3] = (img)(_n1##x,_p2##y,z,v), \
I[4] = (img)(_n2##x,_p2##y,z,v), I[5] = (img)(_p2##x,_p1##y,z,v), I[6] = (img)(_p1##x,_p1##y,z,v), I[7] = (img)(x,_p1##y,z,v), \
I[8] = (img)(_n1##x,_p1##y,z,v), I[9] = (img)(_n2##x,_p1##y,z,v), I[10] = (img)(_p2##x,y,z,v), I[11] = (img)(_p1##x,y,z,v), \
I[12] = (img)(x,y,z,v), I[13] = (img)(_n1##x,y,z,v), I[14] = (img)(_n2##x,y,z,v), I[15] = (img)(_p2##x,_n1##y,z,v), \
I[16] = (img)(_p1##x,_n1##y,z,v), I[17] = (img)(x,_n1##y,z,v), I[18] = (img)(_n1##x,_n1##y,z,v), I[19] = (img)(_n2##x,_n1##y,z,v), \
I[20] = (img)(_p2##x,_n2##y,z,v), I[21] = (img)(_p1##x,_n2##y,z,v), I[22] = (img)(x,_n2##y,z,v), I[23] = (img)(_n1##x,_n2##y,z,v), \
I[24] = (img)(_n2##x,_n2##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 495 of file CImg.h.

#define cimg_get6x6 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p2##x,_p2##y,z,v), I[1] = (img)(_p1##x,_p2##y,z,v), I[2] = (img)(x,_p2##y,z,v), I[3] = (img)(_n1##x,_p2##y,z,v), \
I[4] = (img)(_n2##x,_p2##y,z,v), I[5] = (img)(_n3##x,_p2##y,z,v), I[6] = (img)(_p2##x,_p1##y,z,v), I[7] = (img)(_p1##x,_p1##y,z,v), \
I[8] = (img)(x,_p1##y,z,v), I[9] = (img)(_n1##x,_p1##y,z,v), I[10] = (img)(_n2##x,_p1##y,z,v), I[11] = (img)(_n3##x,_p1##y,z,v), \
I[12] = (img)(_p2##x,y,z,v), I[13] = (img)(_p1##x,y,z,v), I[14] = (img)(x,y,z,v), I[15] = (img)(_n1##x,y,z,v), \
I[16] = (img)(_n2##x,y,z,v), I[17] = (img)(_n3##x,y,z,v), I[18] = (img)(_p2##x,_n1##y,z,v), I[19] = (img)(_p1##x,_n1##y,z,v), \
I[20] = (img)(x,_n1##y,z,v), I[21] = (img)(_n1##x,_n1##y,z,v), I[22] = (img)(_n2##x,_n1##y,z,v), I[23] = (img)(_n3##x,_n1##y,z,v), \
I[24] = (img)(_p2##x,_n2##y,z,v), I[25] = (img)(_p1##x,_n2##y,z,v), I[26] = (img)(x,_n2##y,z,v), I[27] = (img)(_n1##x,_n2##y,z,v), \
I[28] = (img)(_n2##x,_n2##y,z,v), I[29] = (img)(_n3##x,_n2##y,z,v), I[30] = (img)(_p2##x,_n3##y,z,v), I[31] = (img)(_p1##x,_n3##y,z,v), \
I[32] = (img)(x,_n3##y,z,v), I[33] = (img)(_n1##x,_n3##y,z,v), I[34] = (img)(_n2##x,_n3##y,z,v), I[35] = (img)(_n3##x,_n3##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 504 of file CImg.h.

#define cimg_get7x7 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p3##x,_p3##y,z,v), I[1] = (img)(_p2##x,_p3##y,z,v), I[2] = (img)(_p1##x,_p3##y,z,v), I[3] = (img)(x,_p3##y,z,v), \
I[4] = (img)(_n1##x,_p3##y,z,v), I[5] = (img)(_n2##x,_p3##y,z,v), I[6] = (img)(_n3##x,_p3##y,z,v), I[7] = (img)(_p3##x,_p2##y,z,v), \
I[8] = (img)(_p2##x,_p2##y,z,v), I[9] = (img)(_p1##x,_p2##y,z,v), I[10] = (img)(x,_p2##y,z,v), I[11] = (img)(_n1##x,_p2##y,z,v), \
I[12] = (img)(_n2##x,_p2##y,z,v), I[13] = (img)(_n3##x,_p2##y,z,v), I[14] = (img)(_p3##x,_p1##y,z,v), I[15] = (img)(_p2##x,_p1##y,z,v), \
I[16] = (img)(_p1##x,_p1##y,z,v), I[17] = (img)(x,_p1##y,z,v), I[18] = (img)(_n1##x,_p1##y,z,v), I[19] = (img)(_n2##x,_p1##y,z,v), \
I[20] = (img)(_n3##x,_p1##y,z,v), I[21] = (img)(_p3##x,y,z,v), I[22] = (img)(_p2##x,y,z,v), I[23] = (img)(_p1##x,y,z,v), \
I[24] = (img)(x,y,z,v), I[25] = (img)(_n1##x,y,z,v), I[26] = (img)(_n2##x,y,z,v), I[27] = (img)(_n3##x,y,z,v), \
I[28] = (img)(_p3##x,_n1##y,z,v), I[29] = (img)(_p2##x,_n1##y,z,v), I[30] = (img)(_p1##x,_n1##y,z,v), I[31] = (img)(x,_n1##y,z,v), \
I[32] = (img)(_n1##x,_n1##y,z,v), I[33] = (img)(_n2##x,_n1##y,z,v), I[34] = (img)(_n3##x,_n1##y,z,v), I[35] = (img)(_p3##x,_n2##y,z,v), \
I[36] = (img)(_p2##x,_n2##y,z,v), I[37] = (img)(_p1##x,_n2##y,z,v), I[38] = (img)(x,_n2##y,z,v), I[39] = (img)(_n1##x,_n2##y,z,v), \
I[40] = (img)(_n2##x,_n2##y,z,v), I[41] = (img)(_n3##x,_n2##y,z,v), I[42] = (img)(_p3##x,_n3##y,z,v), I[43] = (img)(_p2##x,_n3##y,z,v), \
I[44] = (img)(_p1##x,_n3##y,z,v), I[45] = (img)(x,_n3##y,z,v), I[46] = (img)(_n1##x,_n3##y,z,v), I[47] = (img)(_n2##x,_n3##y,z,v), \
I[48] = (img)(_n3##x,_n3##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 515 of file CImg.h.

#define cimg_get8x8 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p3##x,_p3##y,z,v), I[1] = (img)(_p2##x,_p3##y,z,v), I[2] = (img)(_p1##x,_p3##y,z,v), I[3] = (img)(x,_p3##y,z,v), \
I[4] = (img)(_n1##x,_p3##y,z,v), I[5] = (img)(_n2##x,_p3##y,z,v), I[6] = (img)(_n3##x,_p3##y,z,v), I[7] = (img)(_n4##x,_p3##y,z,v), \
I[8] = (img)(_p3##x,_p2##y,z,v), I[9] = (img)(_p2##x,_p2##y,z,v), I[10] = (img)(_p1##x,_p2##y,z,v), I[11] = (img)(x,_p2##y,z,v), \
I[12] = (img)(_n1##x,_p2##y,z,v), I[13] = (img)(_n2##x,_p2##y,z,v), I[14] = (img)(_n3##x,_p2##y,z,v), I[15] = (img)(_n4##x,_p2##y,z,v), \
I[16] = (img)(_p3##x,_p1##y,z,v), I[17] = (img)(_p2##x,_p1##y,z,v), I[18] = (img)(_p1##x,_p1##y,z,v), I[19] = (img)(x,_p1##y,z,v), \
I[20] = (img)(_n1##x,_p1##y,z,v), I[21] = (img)(_n2##x,_p1##y,z,v), I[22] = (img)(_n3##x,_p1##y,z,v), I[23] = (img)(_n4##x,_p1##y,z,v), \
I[24] = (img)(_p3##x,y,z,v), I[25] = (img)(_p2##x,y,z,v), I[26] = (img)(_p1##x,y,z,v), I[27] = (img)(x,y,z,v), \
I[28] = (img)(_n1##x,y,z,v), I[29] = (img)(_n2##x,y,z,v), I[30] = (img)(_n3##x,y,z,v), I[31] = (img)(_n4##x,y,z,v), \
I[32] = (img)(_p3##x,_n1##y,z,v), I[33] = (img)(_p2##x,_n1##y,z,v), I[34] = (img)(_p1##x,_n1##y,z,v), I[35] = (img)(x,_n1##y,z,v), \
I[36] = (img)(_n1##x,_n1##y,z,v), I[37] = (img)(_n2##x,_n1##y,z,v), I[38] = (img)(_n3##x,_n1##y,z,v), I[39] = (img)(_n4##x,_n1##y,z,v), \
I[40] = (img)(_p3##x,_n2##y,z,v), I[41] = (img)(_p2##x,_n2##y,z,v), I[42] = (img)(_p1##x,_n2##y,z,v), I[43] = (img)(x,_n2##y,z,v), \
I[44] = (img)(_n1##x,_n2##y,z,v), I[45] = (img)(_n2##x,_n2##y,z,v), I[46] = (img)(_n3##x,_n2##y,z,v), I[47] = (img)(_n4##x,_n2##y,z,v), \
I[48] = (img)(_p3##x,_n3##y,z,v), I[49] = (img)(_p2##x,_n3##y,z,v), I[50] = (img)(_p1##x,_n3##y,z,v), I[51] = (img)(x,_n3##y,z,v), \
I[52] = (img)(_n1##x,_n3##y,z,v), I[53] = (img)(_n2##x,_n3##y,z,v), I[54] = (img)(_n3##x,_n3##y,z,v), I[55] = (img)(_n4##x,_n3##y,z,v), \
I[56] = (img)(_p3##x,_n4##y,z,v), I[57] = (img)(_p2##x,_n4##y,z,v), I[58] = (img)(_p1##x,_n4##y,z,v), I[59] = (img)(x,_n4##y,z,v), \
I[60] = (img)(_n1##x,_n4##y,z,v), I[61] = (img)(_n2##x,_n4##y,z,v), I[62] = (img)(_n3##x,_n4##y,z,v), I[63] = (img)(_n4##x,_n4##y,z,v);
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 530 of file CImg.h.

#define cimg_get9x9 (   img,
  x,
  y,
  z,
  v,
  I 
)
Value:
I[0] = (img)(_p4##x,_p4##y,z,v), I[1] = (img)(_p3##x,_p4##y,z,v), I[2] = (img)(_p2##x,_p4##y,z,v), I[3] = (img)(_p1##x,_p4##y,z,v), \
I[4] = (img)(x,_p4##y,z,v), I[5] = (img)(_n1##x,_p4##y,z,v), I[6] = (img)(_n2##x,_p4##y,z,v), I[7] = (img)(_n3##x,_p4##y,z,v), \
I[8] = (img)(_n4##x,_p4##y,z,v), I[9] = (img)(_p4##x,_p3##y,z,v), I[10] = (img)(_p3##x,_p3##y,z,v), I[11] = (img)(_p2##x,_p3##y,z,v), \
I[12] = (img)(_p1##x,_p3##y,z,v), I[13] = (img)(x,_p3##y,z,v), I[14] = (img)(_n1##x,_p3##y,z,v), I[15] = (img)(_n2##x,_p3##y,z,v), \
I[16] = (img)(_n3##x,_p3##y,z,v), I[17] = (img)(_n4##x,_p3##y,z,v), I[18] = (img)(_p4##x,_p2##y,z,v), I[19] = (img)(_p3##x,_p2##y,z,v), \
I[20] = (img)(_p2##x,_p2##y,z,v), I[21] = (img)(_p1##x,_p2##y,z,v), I[22] = (img)(x,_p2##y,z,v), I[23] = (img)(_n1##x,_p2##y,z,v), \
I[24] = (img)(_n2##x,_p2##y,z,v), I[25] = (img)(_n3##x,_p2##y,z,v), I[26] = (img)(_n4##x,_p2##y,z,v), I[27] = (img)(_p4##x,_p1##y,z,v), \
I[28] = (img)(_p3##x,_p1##y,z,v), I[29] = (img)(_p2##x,_p1##y,z,v), I[30] = (img)(_p1##x,_p1##y,z,v), I[31] = (img)(x,_p1##y,z,v), \
I[32] = (img)(_n1##x,_p1##y,z,v), I[33] = (img)(_n2##x,_p1##y,z,v), I[34] = (img)(_n3##x,_p1##y,z,v), I[35] = (img)(_n4##x,_p1##y,z,v), \
I[36] = (img)(_p4##x,y,z,v), I[37] = (img)(_p3##x,y,z,v), I[38] = (img)(_p2##x,y,z,v), I[39] = (img)(_p1##x,y,z,v), \
I[40] = (img)(x,y,z,v), I[41] = (img)(_n1##x,y,z,v), I[42] = (img)(_n2##x,y,z,v), I[43] = (img)(_n3##x,y,z,v), \
I[44] = (img)(_n4##x,y,z,v), I[45] = (img)(_p4##x,_n1##y,z,v), I[46] = (img)(_p3##x,_n1##y,z,v), I[47] = (img)(_p2##x,_n1##y,z,v), \
I[48] = (img)(_p1##x,_n1##y,z,v), I[49] = (img)(x,_n1##y,z,v), I[50] = (img)(_n1##x,_n1##y,z,v), I[51] = (img)(_n2##x,_n1##y,z,v), \
I[52] = (img)(_n3##x,_n1##y,z,v), I[53] = (img)(_n4##x,_n1##y,z,v), I[54] = (img)(_p4##x,_n2##y,z,v), I[55] = (img)(_p3##x,_n2##y,z,v), \
I[56] = (img)(_p2##x,_n2##y,z,v), I[57] = (img)(_p1##x,_n2##y,z,v), I[58] = (img)(x,_n2##y,z,v), I[59] = (img)(_n1##x,_n2##y,z,v), \
I[60] = (img)(_n2##x,_n2##y,z,v), I[61] = (img)(_n3##x,_n2##y,z,v), I[62] = (img)(_n4##x,_n2##y,z,v), I[63] = (img)(_p4##x,_n3##y,z,v), \
I[64] = (img)(_p3##x,_n3##y,z,v), I[65] = (img)(_p2##x,_n3##y,z,v), I[66] = (img)(_p1##x,_n3##y,z,v), I[67] = (img)(x,_n3##y,z,v), \
I[68] = (img)(_n1##x,_n3##y,z,v), I[69] = (img)(_n2##x,_n3##y,z,v), I[70] = (img)(_n3##x,_n3##y,z,v), I[71] = (img)(_n4##x,_n3##y,z,v), \
I[72] = (img)(_p4##x,_n4##y,z,v), I[73] = (img)(_p3##x,_n4##y,z,v), I[74] = (img)(_p2##x,_n4##y,z,v), I[75] = (img)(_p1##x,_n4##y,z,v), \
I[76] = (img)(x,_n4##y,z,v), I[77] = (img)(_n1##x,_n4##y,z,v), I[78] = (img)(_n2##x,_n4##y,z,v), I[79] = (img)(_n3##x,_n4##y,z,v), \
I[80] = (img)(_n4##x,_n4##y,z,v)
y
void int int REAL REAL * y
Definition: read.cpp:74
v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20
z
void int int int REAL REAL REAL * z
Definition: write.cpp:76
x
void int int REAL * x
Definition: read.cpp:74

Definition at line 548 of file CImg.h.

#define cimg_help (   str)    cimg_library::cimg::option((char*)0,argc,argv,str,(char*)0)

Definition at line 401 of file CImg.h.

#define cimg_option (   name,
  defaut,
  usage 
)    cimg_library::cimg::option(name,argc,argv,defaut,usage)

Definition at line 402 of file CImg.h.

#define cimg_OS   0

Definition at line 96 of file CImg.h.

Referenced by cimg_library::cimg::info().

#define cimg_stdout   stderr

Definition at line 136 of file CImg.h.

Referenced by cimg_library::cimg::dialog(), cimg_library::cimg::info(), cimg_library::cimg::option(), CImg< uintT >::print(), CImgList< uintT >::print(), and cimg_library::cimg::warn().

#define cimg_strescape (   ci,
  co 
)    case ci: *nd = co; ++ns; break;

Referenced by cimg_library::cimg::strescape().

#define cimg_usage (   usage)    cimg_library::cimg::option((char*)0,argc,argv,(char*)0,usage)

Definition at line 400 of file CImg.h.

#define cimg_version   132

Definition at line 56 of file CImg.h.

Referenced by cimg_library::cimg::info().

#define cimglist_apply (   list,
  fn 
)    cimglist_for(list,__##fn) (list)[__##fn].fn

Definition at line 1881 of file CImg.h.

Referenced by CImgList< uintT >::assign(), CImgList< uintT >::CImgList(), and CImg< uintT >::get_split().

#define cimglist_for (   list,
  l 
)    for (int l = 0; l<(int)(list).width; ++l)

Definition at line 1877 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d(), CImg< uintT >::_draw_object3d(), CImgList< uintT >::_font(), CImgList< uintT >::_save_cimg(), CImg< uintT >::_save_off(), CImgList< uintT >::_save_yuv(), CImgList< uintT >::assign(), CImgList< uintT >::CImgList(), CImgList< uintT >::contains(), cimg_library::cimg::dialog(), CImg< uintT >::draw_line(), CImg< uintT >::draw_point(), CImg< uintT >::draw_polygon(), CImg< uintT >::draw_spline(), CImg< T >::_cimg_math_parser::eval(), CImgList< uintT >::get_append(), CImgList< uintT >::get_crop_font(), CImgList< uintT >::get_images(), CImgList< uintT >::get_shared(), CImgList< uintT >::get_shared_images(), CImg< uintT >::get_split(), CImgList< uintT >::get_split(), CImgList< uintT >::insert(), CImg< uintT >::is_object3d(), CImgList< uintT >::load_parrec(), CImgList< uintT >::load_tiff(), CImgList< uintT >::max(), CImgList< uintT >::maxmin(), CImgList< uintT >::min(), CImgList< uintT >::minmax(), CImgList< uintT >::print(), CImgList< uintT >::reverse_object3d(), CImgList< uintT >::save(), CImgList< uintT >::save_ffmpeg_external(), CImg< uintT >::sphere3d(), and CImgList< uintT >::transfer_to().

#define cimglist_for_in (   list,
  l0,
  l1,
  l 
)    for (int l = (int)(l0)<0?0:(int)(l0), _max##l = (unsigned int)l1<(list).width?(int)(l1):(int)(list).width-1; l<=_max##l; ++l)

Definition at line 1878 of file CImg.h.

Referenced by CImgList< uintT >::_font().