cimg.h File Reference

#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <cstring>
#include <cmath>
#include <ctime>
#include "png.h"
#include "jpeglib.h"
#include "tiffio.h"
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_library::CImgException
 Class which is thrown when an error occured during a CImg library function call. More...
struct  cimg_library::CImgInstanceException
struct  cimg_library::CImgArgumentException
struct  cimg_library::CImgIOException
struct  cimg_library::CImgDisplayException
struct  cimg_library::CImgWarningException
struct  cimg_library::cimg::type< T >
struct  cimg_library::cimg::type< bool >
struct  cimg_library::cimg::type< unsigned char >
struct  cimg_library::cimg::type< char >
struct  cimg_library::cimg::type< unsigned short >
struct  cimg_library::cimg::type< short >
struct  cimg_library::cimg::type< unsigned int >
struct  cimg_library::cimg::type< int >
struct  cimg_library::cimg::type< unsigned long >
struct  cimg_library::cimg::type< long >
struct  cimg_library::cimg::type< float >
struct  cimg_library::cimg::type< double >
struct  cimg_library::cimg::superset< T, t >
struct  cimg_library::cimg::superset< bool, unsigned char >
struct  cimg_library::cimg::superset< bool, char >
struct  cimg_library::cimg::superset< bool, unsigned short >
struct  cimg_library::cimg::superset< bool, short >
struct  cimg_library::cimg::superset< bool, unsigned int >
struct  cimg_library::cimg::superset< bool, int >
struct  cimg_library::cimg::superset< bool, unsigned long >
struct  cimg_library::cimg::superset< bool, long >
struct  cimg_library::cimg::superset< bool, float >
struct  cimg_library::cimg::superset< bool, double >
struct  cimg_library::cimg::superset< unsigned char, char >
struct  cimg_library::cimg::superset< unsigned char, unsigned short >
struct  cimg_library::cimg::superset< unsigned char, short >
struct  cimg_library::cimg::superset< unsigned char, unsigned int >
struct  cimg_library::cimg::superset< unsigned char, int >
struct  cimg_library::cimg::superset< unsigned char, unsigned long >
struct  cimg_library::cimg::superset< unsigned char, long >
struct  cimg_library::cimg::superset< unsigned char, float >
struct  cimg_library::cimg::superset< unsigned char, double >
struct  cimg_library::cimg::superset< char, unsigned char >
struct  cimg_library::cimg::superset< char, unsigned short >
struct  cimg_library::cimg::superset< char, short >
struct  cimg_library::cimg::superset< char, unsigned int >
struct  cimg_library::cimg::superset< char, int >
struct  cimg_library::cimg::superset< char, unsigned long >
struct  cimg_library::cimg::superset< char, long >
struct  cimg_library::cimg::superset< char, float >
struct  cimg_library::cimg::superset< char, double >
struct  cimg_library::cimg::superset< unsigned short, char >
struct  cimg_library::cimg::superset< unsigned short, short >
struct  cimg_library::cimg::superset< unsigned short, unsigned int >
struct  cimg_library::cimg::superset< unsigned short, int >
struct  cimg_library::cimg::superset< unsigned short, unsigned long >
struct  cimg_library::cimg::superset< unsigned short, long >
struct  cimg_library::cimg::superset< unsigned short, float >
struct  cimg_library::cimg::superset< unsigned short, double >
struct  cimg_library::cimg::superset< short, unsigned short >
struct  cimg_library::cimg::superset< short, unsigned int >
struct  cimg_library::cimg::superset< short, int >
struct  cimg_library::cimg::superset< short, unsigned long >
struct  cimg_library::cimg::superset< short, long >
struct  cimg_library::cimg::superset< short, float >
struct  cimg_library::cimg::superset< short, double >
struct  cimg_library::cimg::superset< unsigned int, char >
struct  cimg_library::cimg::superset< unsigned int, short >
struct  cimg_library::cimg::superset< unsigned int, int >
struct  cimg_library::cimg::superset< unsigned int, unsigned long >
struct  cimg_library::cimg::superset< unsigned int, long >
struct  cimg_library::cimg::superset< unsigned int, float >
struct  cimg_library::cimg::superset< unsigned int, double >
struct  cimg_library::cimg::superset< int, unsigned int >
struct  cimg_library::cimg::superset< int, unsigned long >
struct  cimg_library::cimg::superset< int, long >
struct  cimg_library::cimg::superset< int, float >
struct  cimg_library::cimg::superset< int, double >
struct  cimg_library::cimg::superset< unsigned long, char >
struct  cimg_library::cimg::superset< unsigned long, short >
struct  cimg_library::cimg::superset< unsigned long, int >
struct  cimg_library::cimg::superset< unsigned long, long >
struct  cimg_library::cimg::superset< unsigned long, float >
struct  cimg_library::cimg::superset< unsigned long, double >
struct  cimg_library::cimg::superset< long, float >
struct  cimg_library::cimg::superset< long, double >
struct  cimg_library::cimg::superset< float, double >
struct  cimg_library::cimg::superset2< t1, t2, t3 >
struct  cimg_library::cimg::superset3< t1, t2, t3, t4 >
struct  cimg_library::cimg::last< t1, t2 >
struct  cimg_library::CImgDisplay
 This class represents a window which can display CImg images and handles mouse and keyboard events. More...
struct  cimg_library::CImg< T >
 Class representing an image (up to 4 dimensions wide), each pixel being of type T. More...
struct  cimg_library::CImg< T >::_marching_squares_func
struct  cimg_library::CImg< T >::_marching_cubes_func
struct  cimg_library::CImg< T >::_marching_squares_func_float
struct  cimg_library::CImg< T >::_marching_cubes_func_float
struct  cimg_library::CImgList< T >
 Class representing list of images CImg<T>. More...

Namespaces

namespace  cimg_library
 

Namespace that encompasses all classes and functions of the CImg library.


namespace  cimg_library::cimg
 

Namespace that encompasses low-level functions and variables of the CImg Library.


Defines

#define cimg_OS   0
#define cimg_display_type   0
#define cimg_debug   2
#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)
#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; off<(img).size(); ++off)
#define cimglist_for(list, l)   for (unsigned int l=0; l<(list).size; ++l)
#define cimglist_apply(list, fn)   cimglist_for(list,__##fn) (list)[__##fn].fn
#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 _CImg_stdarg(img, a0, a1, N, t)
#define _CImgList_stdarg(t)
#define cimg_exception_err(etype, disp_flag)
#define cimg_test_temporary_path(p)
#define _cimg_fillv(x, y, z, a0, t)
#define _cimg_fillzv(x, y, a0, t)
#define _cimg_fillyzv(x, a0, t)
#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_get_label_test(p, q)
#define cimg_Labf(x)   ((x)>=0.008856?(std::pow(x,1/3.0)):(7.787*(x)+16.0/116.0))
#define cimg_Labfi(x)   ((x)>=0.206893?((x)*(x)*(x)):(((x)-16.0/116.0)/7.787))
#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_deriche2_apply
#define cimg_valign2d(i, j)
#define cimg_valign3d(i, j, k)
#define _cimg_blur_patch_fastfunc(x)   ((x)>3?0:1)
#define _cimg_blur_patch_slowfunc(x)   std::exp(-(x))
#define _cimg_blur_patch3d(N, func)
#define _cimg_blur_patch2d(N, func)
#define _median_sort(a, b)   if ((a)>(b)) cimg::swap(a,b)
#define cimg_load_inr_case(Tf, sign, pixsize, Ts)
#define cimg_load_pandore_case(nid, nbdim, nwidth, nheight, ndepth, ndim, stype)
#define cimg_load_cimg_case(Ts, Tss)
#define cimg_load_cimg_case2(Ts, Tss)
#define cimg_save_cimg_case(Ts, Tss)
Plugins

#define cimg_plugin_greycstoration_count
#define cimg_plugin_greycstoration_lock
#define cimg_plugin_greycstoration_unlock
Drawing

#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)
Input-Output

#define cimg_save_pandore_case(sy, sz, sv, stype, id)

Functions

void cimg_library::cimg::info ()
 Print informations about CImg environement variables.
unsigned intcimg_library::cimg::exception_mode ()
int cimg_library::cimg::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)
template<typename tfunc , typename tp , typename tf >
void cimg_library::cimg::marching_cubes (const tfunc &func, const float isovalue, const float x0, const float y0, const float z0, const float x1, const float y1, const float z1, const float resx, const float resy, const float resz, CImgList< tp > &points, CImgList< tf > &primitives, const bool invert_faces)
 Polygonize an implicit function.
template<typename tfunc , typename tp , typename tf >
void cimg_library::cimg::marching_squares (const tfunc &func, const float isovalue, const float x0, const float y0, const float x1, const float y1, const float resx, const float resy, CImgList< tp > &points, CImgList< tf > &primitives)
 Polygonize an implicit 2D function by the marching squares algorithm.
void cimg_library::cimg::warn (const char *format,...)
int cimg_library::cimg::xln (const int x)
char cimg_library::cimg::uncase (const char x)
float cimg_library::cimg::atof (const char *str)
int cimg_library::cimg::strlen (const char *s)
int cimg_library::cimg::strncmp (const char *s1, const char *s2, const int l)
int cimg_library::cimg::strncasecmp (const char *s1, const char *s2, const int l)
int cimg_library::cimg::strcmp (const char *s1, const char *s2)
int cimg_library::cimg::strcasecmp (const char *s1, const char *s2)
int cimg_library::cimg::strfind (const char *s, const char c)
const char * cimg_library::cimg::basename (const char *s)
bool cimg_library::cimg::endian ()
 Return false for little endian CPUs (Intel), true for big endian CPUs (Motorola).
unsigned long cimg_library::cimg::time ()
 Get the value of a system timer with a millisecond precision.
void cimg_library::cimg::sleep (const unsigned int milliseconds)
 Sleep for a certain numbers of milliseconds.
unsigned int cimg_library::cimg::wait (const unsigned int milliseconds, unsigned long &timer)
unsigned int cimg_library::cimg::wait (const unsigned int milliseconds)
 Wait for a certain number of milliseconds since the last call.
void cimg_library::cimg::srand ()
const char * cimg_library::cimg::filenamerand ()
void cimg_library::cimg::system (const char *command, const char *module_name=0)
void cimg_library::cimg::winformat_string (char *const)
const char * cimg_library::cimg::imagemagick_path ()
 Return path of the ImageMagick's convert tool.
const char * cimg_library::cimg::graphicsmagick_path ()
 Return path of the GraphicsMagick's gm tool.
const char * cimg_library::cimg::medcon_path ()
 Return path of the XMedcon tool.
const char * cimg_library::cimg::temporary_path ()
 Return path to store temporary files.
const char * cimg_library::cimg::filename_split (const char *const filename, char *const body=0)
char * cimg_library::cimg::filename_number (const char *const filename, const int number, const unsigned int n, char *const string)
std::FILE * cimg_library::cimg::fopen (const char *const path, const char *const mode)
int cimg_library::cimg::fclose (std::FILE *file)
template<typename T >
int cimg_library::cimg::fread (T *const ptr, const unsigned int nmemb, std::FILE *stream)
template<typename T >
int cimg_library::cimg::fwrite (const T *ptr, const unsigned int nmemb, std::FILE *stream)
template<typename T >
void cimg_library::cimg::swap (T &a, T &b)
template<typename T1 , typename T2 >
void cimg_library::cimg::swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2)
template<typename T1 , typename T2 , typename T3 >
void cimg_library::cimg::swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3)
template<typename T1 , typename T2 , typename T3 , typename T4 >
void cimg_library::cimg::swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
void cimg_library::cimg::swap (T1 &a1, T1 &b1, T2 &a2, T2 &b2, T3 &a3, T3 &b3, T4 &a4, T4 &b4, T5 &a5, T5 &b5)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
void cimg_library::cimg::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)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
void cimg_library::cimg::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)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
void cimg_library::cimg::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)
template<typename T >
void cimg_library::cimg::endian_swap (T *const buffer, const unsigned int size)
template<typename T >
T & cimg_library::cimg::endian_swap (T &a)
const char * cimg_library::cimg::option (const char *const name, const int argc, char **argv, const char *defaut, const char *const usage=0)
bool cimg_library::cimg::option (const char *const name, const int argc, char **argv, const bool defaut, const char *const usage=0)
int cimg_library::cimg::option (const char *const name, const int argc, char **argv, const int defaut, const char *const usage=0)
char cimg_library::cimg::option (const char *const name, const int argc, char **argv, const char defaut, const char *const usage=0)
float cimg_library::cimg::option (const char *const name, const int argc, char **argv, const float defaut, const char *const usage=0)
double cimg_library::cimg::option (const char *const name, const int argc, char **argv, const double defaut, const char *const usage=0)
const char * cimg_library::cimg::argument (const unsigned int nb, const int argc, char **argv, const unsigned int nb_singles=0,...)
template<typename T >
const T cimg_library::cimg::rol (const T a, const unsigned int n=1)
template<typename T >
const T cimg_library::cimg::ror (const T a, const unsigned int n=1)
template<typename T >
cimg_library::cimg::abs (const T a)
 Return the absolute value of a.
bool cimg_library::cimg::abs (const bool a)
unsigned char cimg_library::cimg::abs (const unsigned char a)
unsigned short cimg_library::cimg::abs (const unsigned short a)
unsigned int cimg_library::cimg::abs (const unsigned int a)
unsigned long cimg_library::cimg::abs (const unsigned long a)
double cimg_library::cimg::abs (const double a)
float cimg_library::cimg::abs (const float a)
int cimg_library::cimg::abs (const int a)
template<typename T >
cimg_library::cimg::sqr (const T val)
template<typename t1 , typename t2 >
cimg::superset< t1, t2 >::type cimg_library::cimg::min (const t1 &a, const t2 &b)
 Return the minimum between a and b.
template<typename t1 , typename t2 , typename t3 >
cimg::superset2< t1, t2, t3 >::type cimg_library::cimg::min (const t1 &a, const t2 &b, const t3 &c)
 Return the minimum between a,b and c.
template<typename t1 , typename t2 , typename t3 , typename t4 >
cimg::superset3< t1, t2, t3,
t4 >::type 
cimg_library::cimg::min (const t1 &a, const t2 &b, const t3 &c, const t4 &d)
 Return the minimum between a,b,c and d.
template<typename t1 , typename t2 >
cimg::superset< t1, t2 >::type cimg_library::cimg::max (const t1 &a, const t2 &b)
 Return the maximum between a and b.
template<typename t1 , typename t2 , typename t3 >
cimg::superset2< t1, t2, t3 >::type cimg_library::cimg::max (const t1 &a, const t2 &b, const t3 &c)
 Return the maximum between a,b and c.
template<typename t1 , typename t2 , typename t3 , typename t4 >
cimg::superset3< t1, t2, t3,
t4 >::type 
cimg_library::cimg::max (const t1 &a, const t2 &b, const t3 &c, const t4 &d)
 Return the maximum between a,b,c and d.
template<typename T >
cimg_library::cimg::sign (const T x)
 Return the sign of x.
template<typename T >
unsigned long cimg_library::cimg::nearest_pow2 (const T x)
 Return the nearest power of 2 higher than x.
template<typename T >
cimg_library::cimg::mod (const T &x, const T &m)
 Return x modulo m (generic modulo).
int cimg_library::cimg::mod (const char x, const char m)
int cimg_library::cimg::mod (const short x, const short m)
int cimg_library::cimg::mod (const int x, const int m)
int cimg_library::cimg::mod (const long x, const long m)
int cimg_library::cimg::mod (const unsigned char x, const unsigned char m)
int cimg_library::cimg::mod (const unsigned short x, const unsigned short m)
int cimg_library::cimg::mod (const unsigned int x, const unsigned int m)
int cimg_library::cimg::mod (const unsigned long x, const unsigned long m)
template<typename T >
cimg_library::cimg::minmod (const T a, const T b)
 Return minmod(a,b).
double cimg_library::cimg::rand ()
 Return a random variable between [0,1], followin a uniform distribution.
double cimg_library::cimg::crand ()
 Return a random variable between [-1,1], following a uniform distribution.
double cimg_library::cimg::grand ()
 Return a random variable following a gaussian distribution and a standard deviation of 1.
double cimg_library::cimg::round (const double x, const double y, const unsigned int round_type=0)
 Return a rounded number.
double cimg_library::cimg::pythagore (double a, double b)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator+ (const CImg< t1 > &img, const t2 val)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator+ (const t1 val, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator+ (const CImgList< t1 > &list, const t2 val)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator+ (const t1 val, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator+ (const CImg< t1 > &img1, const CImg< t2 > &img2)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator+ (const CImg< t1 > &img, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator+ (const CImgList< t1 > &list, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator+ (const CImgList< t1 > &list1, const CImgList< t2 > &list2)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator- (const CImg< t1 > &img, const t2 val)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator- (const t1 val, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator- (const CImgList< t1 > &list, const t2 val)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator- (const t1 val, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator- (const CImg< t1 > &img1, const CImg< t2 > &img2)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator- (const CImg< t1 > &img, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator- (const CImgList< t1 > &list, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator- (const CImgList< t1 > &list1, const CImgList< t2 > &list2)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator* (const CImg< t1 > &img, const t2 val)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator* (const t1 val, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator* (const CImgList< t1 > &list, const t2 val)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator* (const t1 val, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator* (const CImg< t1 > &img1, const CImg< t2 > &img2)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator* (const CImg< t1 > &img, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator* (const CImgList< t1 > &list, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator* (const CImgList< t1 > &list1, const CImgList< t2 > &list2)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator/ (const CImg< t1 > &img, const t2 val)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator/ (const t1 val, CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator/ (const CImgList< t1 > &list, const t2 val)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator/ (const t1 val, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator/ (const CImg< t1 > &img1, const CImg< t2 > &img2)
template<typename t1 , typename t2 >
CImg< typename cimg::superset
< t1, t2 >::type > 
cimg_library::operator/ (const CImg< t1 > &img, const CImgList< t2 > &list)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator/ (const CImgList< t1 > &list, const CImg< t2 > &img)
template<typename t1 , typename t2 >
CImgList< typename
cimg::superset< t1, t2 >::type > 
cimg_library::operator/ (const CImgList< t1 > &list1, const CImgList< t2 > &list2)
template<typename T , typename t >
CImg< T > cimg_library::apply (const CImg< T > &instance, t &func)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::mul (const CImg< T > &instance, const CImg< t > &img)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::div (const CImg< T > &instance, const CImg< t > &img)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::max (const CImg< T > &instance, const CImg< t > &img)
template<typename T >
CImg< T > cimg_library::max (const CImg< T > &instance, const T val)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::min (const CImg< T > &instance, const CImg< t > &img)
template<typename T >
CImg< typename cimg::last< T,
double >::type > 
cimg_library::stats (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::min (const CImg< T > &instance, const T val)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::sqr (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::sqrt (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::exp (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::log (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::log10 (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::pow (const CImg< T > &instance, const double p)
template<typename T , typename t >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::pow (const CImg< T > &instance, const CImg< t > &img)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::abs (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::cos (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::sin (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::tan (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::acos (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::asin (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::atan (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::round (const CImg< T > &instance, const float x, const unsigned int round_type=0)
template<typename T >
CImg< T > cimg_library::rand (const CImg< T > &instance, const T val_min, const T val_max)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10, const T val11)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10, const T val11, const T val12)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10, const T val11, const T val12, const T val13)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10, const T val11, const T val12, const T val13, const T val14)
template<typename T >
CImg< T > cimg_library::fill (const CImg< T > &instance, const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7, const T val8, const T val9, const T val10, const T val11, const T val12, const T val13, const T val14, const T val15)
template<typename T , int N>
CImg< T > cimg_library::fill (const CImg< T > &instance, const int val0,...)
template<typename T , int N>
CImg< T > cimg_library::fill (const CImg< T > &instance, const double val0,...)
template<typename T >
CImg< T > cimg_library::normalize (const CImg< T > &instance, const T a, const T b)
template<typename T >
CImg< T > cimg_library::cut (const CImg< T > &instance, const T a, const T b)
template<typename T >
CImg< T > cimg_library::quantize (const CImg< T > &instance, const unsigned int n=256, const bool keep_range=true)
template<typename T >
CImg< T > cimg_library::threshold (const CImg< T > &instance, const T thres)
template<typename T >
CImg< T > cimg_library::rotate (const CImg< T > &instance, const float angle, const unsigned int cond=3)
template<typename T >
CImg< T > cimg_library::rotate (const CImg< T > &instance, const float angle, const float cx, const float cy, const float zoom=1, const unsigned int cond=3)
template<typename T >
CImg< T > cimg_library::resize (const CImg< T > &instance, const int pdx=-100, const int pdy=-100, const int pdz=-100, const int pdv=-100, const int interp=1, const int border_condition=-1, const bool center=false)
template<typename T , typename t >
CImg< T > cimg_library::resize (const CImg< T > &instance, const CImg< t > &src, const int interp=1, const int border_condition=-1, const bool center=false)
template<typename T >
CImg< T > cimg_library::resize (const CImg< T > &instance, const CImgDisplay &disp, const int interp=1, const int border_condition=-1, const bool center=false)
template<typename T , typename t >
CImg< t > cimg_library::permute_axes (const CImg< T > &instance, const char *permut, const t &pixel_type)
template<typename T >
CImg< T > cimg_library::permute_axes (const CImg< T > &instance, const char *permut="vxyz")
template<typename T >
CImg< T > cimg_library::resize_halfXY (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::resize_doubleXY (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::resize_tripleXY (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::crop (const CImg< T > &instance, const int x0, const int y0, const int z0, const int v0, const int x1, const int y1, const int z1, const int v1, const bool border_condition=false)
template<typename T >
CImg< T > cimg_library::crop (const CImg< T > &instance, const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const bool border_condition=false)
template<typename T >
CImg< T > cimg_library::crop (const CImg< T > &instance, const int x0, const int y0, const int x1, const int y1, const bool border_condition=false)
template<typename T >
CImg< T > cimg_library::crop (const CImg< T > &instance, const int x0, const int x1, const bool border_condition=false)
template<typename T >
CImg< T > cimg_library::columns (const CImg< T > &instance, const unsigned int x0, const unsigned int x1)
template<typename T >
CImg< T > cimg_library::column (const CImg< T > &instance, const unsigned int x0)
template<typename T >
CImg< T > cimg_library::lines (const CImg< T > &instance, const unsigned int y0, const unsigned int y1)
template<typename T >
CImg< T > cimg_library::line (const CImg< T > &instance, const unsigned int y0)
template<typename T >
CImg< T > cimg_library::slices (const CImg< T > &instance, const unsigned int z0, const unsigned int z1)
template<typename T >
CImg< T > cimg_library::slice (const CImg< T > &instance, const unsigned int z0)
template<typename T >
CImg< T > cimg_library::channels (const CImg< T > &instance, const unsigned int v0, const unsigned int v1)
template<typename T >
CImg< T > cimg_library::channel (const CImg< T > &instance, const unsigned int v0)
template<typename T >
CImg< T > cimg_library::shared_points (CImg< T > &instance, const unsigned int x0, const unsigned int x1, const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_points (const CImg< T > &instance, const unsigned int x0, const unsigned int x1, const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_lines (CImg< T > &instance, const unsigned int y0, const unsigned int y1, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_lines (const CImg< T > &instance, const unsigned int y0, const unsigned int y1, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_line (CImg< T > &instance, const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_line (const CImg< T > &instance, const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_planes (CImg< T > &instance, const unsigned int z0, const unsigned int z1, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_planes (const CImg< T > &instance, const unsigned int z0, const unsigned int z1, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_plane (CImg< T > &instance, const unsigned int z0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_plane (const CImg< T > &instance, const unsigned int z0, const unsigned int v0=0)
template<typename T >
CImg< T > cimg_library::shared_channels (CImg< T > &instance, const unsigned int v0, const unsigned int v1)
template<typename T >
CImg< T > cimg_library::shared_channels (const CImg< T > &instance, const unsigned int v0, const unsigned int v1)
template<typename T >
CImg< T > cimg_library::shared_channel (CImg< T > &instance, const unsigned int v0)
template<typename T >
CImg< T > cimg_library::shared_channel (const CImg< T > &instance, const unsigned int v0)
template<typename T >
CImg< T > cimg_library::shared (CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::shared (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::mirror (const CImg< T > &instance, const char axe='x')
template<typename T >
CImg< T > cimg_library::translate (const CImg< T > &instance, const int deltax, const int deltay=0, const int deltaz=0, const int deltav=0, const int border_condition=0)
template<typename T >
CImg< T > cimg_library::projections2d (const CImg< T > &instance, const unsigned int x0, const unsigned int y0, const unsigned int z0, const int dx=-100, const int dy=-100, const int dz=-100)
template<typename T >
CImg< typename cimg::last< T,
float >::type > 
cimg_library::histogram (const CImg< T > &instance, const unsigned int nblevels=256, const T val_min=(T) 0, const T val_max=(T) 0)
template<typename T >
CImg< T > cimg_library::equalize_histogram (const CImg< T > &instance, const unsigned int nblevels=256, const T val_min=(T) 0, const T val_max=(T) 0)
template<typename T >
CImg< typename cimg::last< T,
unsigned int >::type > 
cimg_library::label_regions (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::norm_pointwise (const CImg< T > &instance, int norm_type=2)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::orientation_pointwise (const CImg< T > &instance)
template<typename T >
CImgList< T > cimg_library::split (const CImg< T > &instance, const char axe='x', const unsigned int nb=0)
template<typename T >
CImg< T > cimg_library::append (const CImg< T > &instance, const CImg< T > &img, const char axis='x', const char align='c')
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::gradientXY (const CImg< T > &instance, const int scheme=0)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::gradientXYZ (const CImg< T > &instance, const int scheme=0)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::structure_tensorXY (const CImg< T > &instance, const int scheme=1)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::structure_tensorXYZ (const CImg< T > &instance, const int scheme=1)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::distance_function (const CImg< T > &instance, const unsigned int nb_iter=100, const float band_size=0.0f, const float precision=0.5f)
template<typename T , typename t >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::dijkstra (const CImg< T > &instance, const unsigned int starting_node, const unsigned int ending_node, CImg< t > &previous)
template<typename T , typename t >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::dijkstra (const CImg< T > &instance, const unsigned int starting_node, const unsigned int ending_node=~0U)
template<typename T , typename t >
CImg< t > cimg_library::RGBtoLUT (const CImg< T > &instance, const CImg< t > &palette, const bool dithering=true, const bool indexing=false)
template<typename T >
CImg< T > cimg_library::RGBtoLUT (const CImg< T > &instance, const bool dithering=true, const bool indexing=false)
template<typename T , typename t >
CImg< t > cimg_library::LUTtoRGB (const CImg< T > &instance, const CImg< t > &palette)
template<typename T >
CImg< T > cimg_library::LUTtoRGB (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::RGBtoHSV (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::HSVtoRGB (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::RGBtoHSL (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::HSLtoRGB (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::RGBtoHSI (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::HSItoRGB (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::RGBtoYCbCr (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::YCbCrtoRGB (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::RGBtoYUV (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::YUVtoRGB (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::RGBtoXYZ (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::XYZtoRGB (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::XYZtoLab (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::LabtoXYZ (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::XYZtoxyY (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::xyYtoXYZ (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::RGBtoLab (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::LabtoRGB (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::RGBtoxyY (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::xyYtoRGB (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::RGBtoBayer (const CImg< T > &instance, const bool even_mode=true)
template<typename T >
CImg< T > cimg_library::BayertoRGB (const CImg< T > &instance, const unsigned int interpolation_type=3, const bool even_mode=true)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::correlate (const CImg< T > &instance, const CImg< t > &mask, const unsigned int cond=1, const bool weighted_correl=false)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::convolve (const CImg< T > &instance, const CImg< t > &mask, const unsigned int cond=1, const bool weighted_convol=false)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::erode (const CImg< T > &instance, const CImg< t > &mask, const unsigned int cond=1, const bool weighted_erosion=false)
template<typename T >
CImg< T > cimg_library::erode (const CImg< T > &instance, const unsigned int n, const unsigned int cond=1)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::dilate (const CImg< T > &instance, const CImg< t > &mask, const unsigned int cond=1, const bool weighted_dilatation=false)
template<typename T >
CImg< T > cimg_library::dilate (const CImg< T > &instance, const unsigned int n, const unsigned int cond=1)
template<typename T >
CImg< T > cimg_library::noise (const CImg< T > &instance, const double sigma=-20, const unsigned int ntype=0)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::deriche (const CImg< T > &instance, const float sigma, const int order=0, const char axe='x', const bool cond=true)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::blur (const CImg< T > &instance, const float sigmax, const float sigmay, const float sigmaz, const bool cond=true)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::blur (const CImg< T > &instance, const float sigma, const bool cond=true)
template<typename T , typename t >
CImg< T > cimg_library::blur_anisotropic (const CImg< T > &instance, const CImg< t > &G, const float amplitude=60.0f, const float dl=0.8f, const float da=30.0f, const float gauss_prec=2.0f, const unsigned int interpolation=0, const bool fast_approx=true)
template<typename T , typename tm >
CImg< T > cimg_library::blur_anisotropic (const CImg< T > &instance, const CImg< tm > &mask, const float amplitude, const float sharpness=0.7f, const float anisotropy=0.3f, const float alpha=0.6f, const float sigma=1.1f, const float dl=0.8f, const float da=30.0f, const float gauss_prec=2.0f, const unsigned int interpolation=0, const bool fast_approx=true, const float geom_factor=1.0f)
template<typename T >
CImg< T > cimg_library::blur_anisotropic (const CImg< T > &instance, const float amplitude, const float sharpness=0.7f, const float anisotropy=0.3f, const float alpha=0.6f, const float sigma=1.1f, const float dl=0.8f, const float da=30.0f, const float gauss_prec=2.0f, const unsigned int interpolation=0, const bool fast_approx=true, const float geom_factor=1.0f)
template<typename T >
CImg< T > cimg_library::blur_bilateral (const CImg< T > &instance, const float sigmax, const float sigmay, const float sigmaz, const float sigmar, const int bgridx, const int bgridy, const int bgridz, const int bgridr, const bool interpolation=true)
template<typename T >
CImg< T > cimg_library::blur_bilateral (const CImg< T > &instance, const float sigmas, const float sigmar, const int bgrids=-33, const int bgridr=32, const bool interpolation=true)
template<typename T >
CImg< T > cimg_library::blur_patch (const CImg< T > &instance, const unsigned int patch_size=3, const float sigma_p=10.0f, const float sigma_s=10.0f, const unsigned int lookup_size=4, const bool fast_approx=true)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImg< T > &instance, const char axe, const bool invert=false)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImg< T > &instance, const bool invert=false)
template<typename T >
CImg< T > cimg_library::blur_median (const CImg< T > &instance, const unsigned int n=3)
template<typename T >
CImg< T > cimg_library::sharpen (const CImg< T > &instance, const float amplitude=50.0f, const float edge=1.0f, const float alpha=0.0f, const float sigma=0.0f)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::haar (const CImg< T > &instance, const char axis, const bool invert=false, const unsigned int nb_scales=1)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::haar (const CImg< T > &instance, const bool invert=false, const unsigned int nb_scales=1)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::displacement_field (const CImg< T > &instance, const CImg< T > &target, const float smooth=0.1f, const float precision=0.1f, const unsigned int nb_scales=0, const unsigned int itermax=10000)
template<typename T >
CImg< T > cimg_library::matrix (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::tensor (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::unroll (const CImg< T > &instance, const char axe='x')
template<typename T >
CImg< T > cimg_library::diagonal (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::identity_matrix (const CImg< T > &instance)
template<typename T >
CImg< T > cimg_library::sequence (const CImg< T > &instance, const T a0, const T a1)
template<typename T >
CImg< T > cimg_library::vector_at (const CImg< T > &instance, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0)
template<typename T >
CImg< T > cimg_library::matrix_at (const CImg< T > &instance, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0)
template<typename T >
CImg< T > cimg_library::tensor_at (const CImg< T > &instance, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0)
template<typename T >
CImg< T > cimg_library::transpose (const CImg< T > &instance)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::invert (const CImg< T > &instance, const bool use_LU=true)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::pseudoinvert (const CImg< T > &instance)
template<typename T , typename t >
CImg< typename cimg::superset
< T, t >::type > 
cimg_library::cross (const CImg< T > &instance, const CImg< t > &img)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::SVD (const CImg< T > &instance, const bool sorting=true)
template<typename T , typename t >
CImg< typename cimg::superset2
< T, t, float >::type > 
cimg_library::solve (const CImg< T > &instance, const CImg< t > &A)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::eigen (const CImg< T > &instance)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::symmetric_eigen (const CImg< T > &instance)
template<typename T , typename t >
CImg< T > cimg_library::sort (const CImg< T > &instance, CImg< t > &permutations, const bool increasing=true)
template<typename T >
CImg< T > cimg_library::sort (const CImg< T > &instance, const bool increasing=true)
template<typename T , typename t >
CImg< T > cimg_library::permute (const CImg< T > &instance, const CImg< t > &permutation)
template<typename T >
CImg< typename cimg::last< T,
int >::type > 
cimg_library::coordinates (const CImg< T > &instance, const int coords_type, CImgDisplay &disp, unsigned int *const XYZ=0, const unsigned char *const color=0)
template<typename T , typename t >
CImgList< typename
cimg::superset< T, t >::type > 
cimg_library::insert (const CImgList< T > &instance, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
template<typename T , typename t >
CImgList< typename
cimg::superset< T, t >::type > 
cimg_library::insert (const CImgList< T > &instance, const unsigned int n, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
template<typename T , typename t >
CImgList< typename
cimg::superset< T, t >::type > 
cimg_library::insert (const CImgList< T > &instance, const CImgList< t > &list, const unsigned int pos=~0U, int shared=0)
template<typename T , typename t >
CImgList< typename
cimg::superset< T, t >::type > 
cimg_library::insert (const CImgList< T > &instance, const unsigned int n, const CImgList< t > &list, const unsigned int pos=~0U, const int shared=0)
template<typename T >
CImgList< T > cimg_library::remove (const CImgList< T > &instance, const unsigned int pos)
template<typename T >
CImgList< T > cimg_library::remove (const CImgList< T > &instance)
template<typename T >
CImgList< T > cimg_library::reverse (const CImgList< T > &instance)
template<typename T >
CImgList< T > cimg_library::crop (const CImgList< T > &instance, const unsigned int i0, const unsigned int i1, const bool shared=false)
template<typename T >
CImgList< T > cimg_library::crop (const CImgList< T > &instance, const unsigned int i0, const unsigned int i1, const int x0, const int y0, const int z0, const int v0, const int x1, const int y1, const int z1, const int v1)
template<typename T >
CImgList< T > cimg_library::crop (const CImgList< T > &instance, const unsigned int i0, const unsigned int i1, const int x0, const int y0, const int z0, const int x1, const int y1, const int z1)
template<typename T >
CImgList< T > cimg_library::crop (const CImgList< T > &instance, const unsigned int i0, const unsigned int i1, const int x0, const int y0, const int x1, const int y1)
template<typename T >
CImgList< T > cimg_library::crop (const CImgList< T > &instance, const unsigned int i0, const unsigned int i1, const int x0, const int x1)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImgList< T > &instance, const char axe, const bool invert=false)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImgList< T > &instance, const bool invert=false)
template<typename T >
CImgList< T > cimg_library::split (const CImgList< T > &instance, const char axe='x')
template<typename T >
CImg< T > cimg_library::append (const CImgList< T > &instance, const char axe='x', const char align='c')
template<typename T >
CImgList< T > cimg_library::crop_font (const CImgList< T > &instance)
template<typename t >
int cimg_library::cimg::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.
template<typename t >
int cimg_library::cimg::_marching_cubes_indice (const unsigned int edge, const CImg< t > &indices1, const CImg< t > &indices2, const unsigned int x, const unsigned int y, const unsigned int nx, const unsigned int ny)
template<typename t >
int cimg_library::cimg::_marching_squares_indice (const unsigned int edge, const CImg< t > &indices1, const CImg< t > &indices2, const unsigned int x, const unsigned int nx)

Variables

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

Define Documentation

#define _cimg_blur_patch2d ( N,
func   ) 
Value:
{ \
  const unsigned int N2 = N*N; \
  cimg_for##N##XY(*this,x,y) { \
    cimg_plugin_greycstoration_count; \
    cimg_forV(*this,k) cimg_get##N##x##N(*this,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(*this,x0,y0,x1,y1,p,q) { \
      cimg_forV(*this,k) cimg_get##N##x##N(*this,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 = p-x, dy = q-y, alldist = distance2 + (dx*dx+dy*dy)/sigma_s2, weight = func(alldist); \
      sum_weights+=weight; \
      { cimg_forV(*this,k) res(x,y,k)+=weight*(*this)(p,q,k); } \
    } \
    if (sum_weights>0) cimg_forV(*this,k) res(x,y,k)/=sum_weights; else cimg_forV(*this,k) res(x,y,k) = (*this)(x,y,k); \
  }}

Referenced by cimg_library::CImg< T >::blur_patch().

#define _cimg_blur_patch3d ( N,
func   ) 
Value:
{ \
  const unsigned int N3 = N*N*N; \
  cimg_for##N##XYZ(*this,x,y,z) { \
    cimg_plugin_greycstoration_count; \
    cimg_forV(*this,k) cimg_get##N##x##N##x##N(*this,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(*this,x0,y0,z0,x1,y1,z1,p,q,r) { \
      cimg_forV(*this,k) cimg_get##N##x##N##x##N(*this,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 = p-x, dy = q-y, dz = r-z, alldist = distance2 + (dx*dx+dy*dy+dz*dz)/sigma_s2, weight = func(alldist); \
      sum_weights+=weight; \
      { cimg_forV(*this,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k); } \
    } \
    if (sum_weights>0) cimg_forV(*this,k) res(x,y,z,k)/=sum_weights; else cimg_forV(*this,k) res(x,y,z,k) = (*this)(x,y,z,k); \
  }}

Referenced by cimg_library::CImg< T >::blur_patch().

#define _cimg_blur_patch_fastfunc (  )     ((x)>3?0:1)
#define _cimg_blur_patch_slowfunc (  )     std::exp(-(x))
#define _cimg_draw_fill_insert ( x,
y,
 ) 
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; \
}
#define _cimg_draw_fill_set ( x,
y,
 ) 
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; } \
}

Referenced by cimg_library::CImg< T >::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); \
}

Referenced by cimg_library::CImg< T >::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); \
}

Referenced by cimg_library::CImg< T >::draw_fill().

#define _cimg_fillv ( x,
y,
z,
a0,
 ) 
Value:
if (x<width && y<height && z<depth) { \
    va_list ap; va_start(ap,a0); \
    const unsigned int whz = width*height*depth; \
    T *ptrd = ptr(x,y,z,0); *ptrd = (T)a0; \
    for (unsigned int k=1; k<dim; ++k) { ptrd+=whz; *ptrd = (T)va_arg(ap,t); } \
    va_end(ap); }

Referenced by cimg_library::CImg< T >::fillV().

#define _cimg_fillyzv ( x,
a0,
 ) 
Value:
if (x<width) { \
    va_list ap; va_start(ap,a0); \
    const unsigned int hzd = height*depth*dim; \
    T *ptrd = ptr(x,0,0,0); *ptrd = (T)a0; \
    for (unsigned int k=1; k<hzd; ++k) { ptrd+=width; *ptrd = (T)va_arg(ap,t); } \
    va_end(ap); \
}

Referenced by cimg_library::CImg< T >::fillYZV().

#define _cimg_fillzv ( x,
y,
a0,
 ) 
Value:
if (x<width && y<height) { \
    va_list ap; va_start(ap,a0); \
    const unsigned int wh = width*height, zd = depth*dim; \
    T *ptrd = ptr(x,y,0,0); *ptrd = (T)a0; \
    for (unsigned int k=1; k<zd; ++k) { ptrd+=wh; *ptrd = (T)va_arg(ap,t); } \
    va_end(ap); }

Referenced by cimg_library::CImg< T >::fillZV().

#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))

Definition at line 18081 of file cimg.h.

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

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

Definition at line 18110 of file cimg.h.

Referenced by cimg_library::CImg< T >::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 18154 of file cimg.h.

Referenced by cimg_library::CImg< T >::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 18213 of file cimg.h.

Referenced by cimg_library::CImg< T >::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 18287 of file cimg.h.

Referenced by cimg_library::CImg< T >::draw_triangle().

#define _cimg_get_label_test ( p,
 ) 
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); } \
}

Referenced by cimg_library::CImg< T >::get_label_regions().

#define _CImg_stdarg ( img,
a0,
a1,
N,
 ) 
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); \
     }}

Definition at line 1746 of file cimg.h.

Referenced by cimg_library::CImg< T >::assign(), cimg_library::CImg< T >::CImg(), cimg_library::CImg< T >::matrix(), and cimg_library::CImg< T >::vector().

#define _CImgList_stdarg (  ) 
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); \
   }

Definition at line 1760 of file cimg.h.

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

#define _median_sort ( a,
b   )     if ((a)>(b)) cimg::swap(a,b)
#define CImg_2x2 ( I,
 ) 
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 310 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_gradientXY().

#define CImg_2x2x2 ( I,
 ) 
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 347 of file cimg.h.

#define CImg_3x3 ( I,
 ) 
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 316 of file cimg.h.

Referenced by cimg_library::CImg< T >::distance_function(), cimg_library::CImg< T >::get_BayertoRGB(), cimg_library::CImg< T >::get_blur_median(), cimg_library::CImg< T >::get_displacement_field(), cimg_library::CImg< T >::get_gradientXY(), cimg_library::CImg< T >::get_hessianXY(), cimg_library::CImg< T >::get_resize_doubleXY(), cimg_library::CImg< T >::get_resize_tripleXY(), cimg_library::CImg< T >::get_structure_tensorXY(), and cimg_library::CImg< T >::sharpen().

#define CImg_3x3x3 ( I,
 ) 
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 357 of file cimg.h.

Referenced by cimg_library::CImg< T >::distance_function(), cimg_library::CImg< T >::get_displacement_field(), cimg_library::CImg< T >::get_gradientXYZ(), cimg_library::CImg< T >::get_hessianXYZ(), cimg_library::CImg< T >::get_structure_tensorXYZ(), and cimg_library::CImg< T >::sharpen().

#define CImg_4x4 ( I,
 ) 
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 325 of file cimg.h.

#define CImg_5x5 ( I,
 ) 
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 335 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_blur_median().

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

Definition at line 297 of file cimg.h.

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

Definition at line 298 of file cimg.h.

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

Definition at line 299 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 300 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 301 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 302 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 303 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 304 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 305 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 306 of file cimg.h.

#define cimg_debug   2

Definition at line 109 of file cimg.h.

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

#define cimg_deriche2_apply
Value:
ftype *ptrY = Y.data, yb = 0, yp = 0; \
  T xp = (T)0; \
  if (cond) { xp = *ptrX; yb = yp = (ftype)(coefp*xp); } \
  for (int m=0; m<N; ++m) { \
    const T xc = *ptrX; ptrX+=off; \
    const ftype yc = *(ptrY++) = (ftype)(a0*xc + a1*xp - b1*yp - b2*yb); \
    xp = xc; yb = yp; yp = yc; \
  } \
  T xn = (T)0, xa = (T)0; \
  ftype yn = 0, ya = 0; \
  if (cond) { xn = xa = *(ptrX-off); yn = ya = (ftype)coefn*xn; } \
  for (int n=N-1; n>=0; --n) { \
    const T xc = *(ptrX-=off); \
    const ftype yc = (ftype)(a2*xn + a3*xa - b1*yn - b2*ya); \
    xa = xn; xn = xc; ya = yn; yn = yc; \
    *ptrX = (T)(*(--ptrY)+yc); \
  }

Referenced by cimg_library::CImg< T >::deriche().

#define cimg_display_type   0

Definition at line 96 of file cimg.h.

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

#define cimg_exception_err ( etype,
disp_flag   ) 
Value:
std::va_list ap; \
  va_start(ap,format); \
  std::vsprintf(message,format,ap); \
  va_end(ap); \
  if (cimg::exception_mode()>=1) { \
    if (cimg::exception_mode()>=2 && disp_flag) { \
      try { cimg::dialog(etype,message,"Abort"); } \
      catch (CImgException&) { std::fprintf(stderr,"\n# %s :\n%s\n\n",etype,message); } \
    } else std::fprintf(stderr,"\n# %s :\n%s\n\n",etype,message); \
  } \
  if (cimg::exception_mode()>=3) cimg_library::cimg::info(); \

Definition at line 1841 of file cimg.h.

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

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

Definition at line 456 of file cimg.h.

Referenced by cimg_library::CImg< T >::abs(), cimg_library::CImg< T >::acos(), cimg_library::CImg< T >::apply(), cimg_library::CImg< T >::asin(), cimg_library::CImg< T >::assign(), cimg_library::CImg< T >::atan(), cimg_library::CImg< T >::blur_anisotropic(), cimg_library::CImg< T >::CImg(), cimg_library::CImg< T >::cos(), cimg_library::CImg< T >::cut(), cimg_library::CImg< T >::draw_fill(), cimg_library::CImg< T >::equalize_histogram(), cimg_library::CImg< T >::exp(), cimg_library::CImg< T >::fill(), cimg_library::CImg< T >::get_coordinates(), cimg_library::CImg< T >::get_histogram(), cimg_library::CImg< T >::get_label_regions(), cimg_library::CImg< T >::get_permute(), cimg_library::CImg< T >::log(), cimg_library::CImg< T >::log10(), cimg_library::CImgList< T >::max(), cimg_library::CImg< T >::max(), cimg_library::CImgList< T >::maxmin(), cimg_library::CImg< T >::maxmin(), cimg_library::CImgList< T >::mean(), cimg_library::CImg< T >::mean(), cimg_library::CImgList< T >::min(), cimg_library::CImg< T >::min(), cimg_library::CImgList< T >::minmax(), cimg_library::CImg< T >::minmax(), cimg_library::CImg< T >::MSE(), cimg_library::CImg< T >::noise(), cimg_library::CImg< T >::normalize(), cimg_library::CImg< T >::operator%=(), cimg_library::CImg< T >::operator&=(), cimg_library::CImg< T >::operator*=(), cimg_library::CImg< T >::operator++(), cimg_library::CImg< T >::operator+=(), cimg_library::CImg< T >::operator--(), cimg_library::CImg< T >::operator-=(), cimg_library::CImg< T >::operator/=(), cimg_library::CImg< T >::operator<<=(), cimg_library::CImg< T >::operator>>=(), cimg_library::CImg< T >::operator^=(), cimg_library::CImg< T >::operator|=(), cimg_library::CImg< T >::operator~(), cimg_library::CImg< T >::pow(), cimg_library::CImg< T >::quantize(), cimg_library::CImg< T >::rand(), cimg_library::CImg< T >::round(), cimg_library::CImg< T >::sin(), cimg_library::CImg< T >::sqr(), cimg_library::CImg< T >::sqrt(), cimg_library::CImg< T >::stats(), cimg_library::CImg< T >::sum(), cimg_library::CImg< T >::tan(), cimg_library::CImg< T >::threshold(), cimg_library::CImgList< T >::variance(), and cimg_library::CImg< T >::variancemean().

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

Definition at line 461 of file cimg.h.

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

Definition at line 560 of file cimg.h.

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

Definition at line 567 of file cimg.h.

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

Definition at line 564 of file cimg.h.

#define cimg_for2x2 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 922 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_blur_median(), cimg_library::CImg< T >::get_correlate(), and cimg_library::CImg< T >::get_gradientXY().

#define cimg_for2x2x2 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 1643 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_correlate().

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

Definition at line 570 of file cimg.h.

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

Definition at line 568 of file cimg.h.

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

Definition at line 574 of file cimg.h.

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

Definition at line 577 of file cimg.h.

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

Definition at line 569 of file cimg.h.

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

Definition at line 575 of file cimg.h.

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

Definition at line 565 of file cimg.h.

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

Definition at line 572 of file cimg.h.

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

Definition at line 571 of file cimg.h.

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

Definition at line 576 of file cimg.h.

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

Definition at line 566 of file cimg.h.

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

Definition at line 573 of file cimg.h.

#define cimg_for3 ( bound,
 ) 
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)

Definition at line 599 of file cimg.h.

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

Definition at line 607 of file cimg.h.

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

Definition at line 604 of file cimg.h.

#define cimg_for3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 950 of file cimg.h.

Referenced by cimg_library::CImg< T >::distance_function(), cimg_library::CImg< T >::get_blur_median(), cimg_library::CImg< T >::get_correlate(), cimg_library::CImg< T >::get_gradientXY(), cimg_library::CImg< T >::get_hessianXY(), cimg_library::CImg< T >::get_resize_halfXY(), cimg_library::CImg< T >::get_structure_tensorXY(), and cimg_library::CImg< T >::sharpen().

#define cimg_for3x3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 1677 of file cimg.h.

Referenced by cimg_library::CImg< T >::distance_function(), cimg_library::CImg< T >::get_correlate(), cimg_library::CImg< T >::get_gradientXYZ(), cimg_library::CImg< T >::get_hessianXYZ(), cimg_library::CImg< T >::get_structure_tensorXYZ(), and cimg_library::CImg< T >::sharpen().

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

Definition at line 610 of file cimg.h.

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

Definition at line 608 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_displacement_field().

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

Definition at line 614 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_displacement_field().

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

Definition at line 617 of file cimg.h.

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

Definition at line 609 of file cimg.h.

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

Definition at line 615 of file cimg.h.

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

Definition at line 605 of file cimg.h.

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

Definition at line 612 of file cimg.h.

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

Definition at line 611 of file cimg.h.

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

Definition at line 616 of file cimg.h.

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

Definition at line 606 of file cimg.h.

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

Definition at line 613 of file cimg.h.

#define cimg_for4 ( bound,
 ) 
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)

Definition at line 640 of file cimg.h.

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

Definition at line 648 of file cimg.h.

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

Definition at line 645 of file cimg.h.

#define cimg_for4x4 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 989 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_correlate().

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

Definition at line 651 of file cimg.h.

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

Definition at line 649 of file cimg.h.

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

Definition at line 655 of file cimg.h.

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

Definition at line 658 of file cimg.h.

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

Definition at line 650 of file cimg.h.

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

Definition at line 656 of file cimg.h.

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

Definition at line 646 of file cimg.h.

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

Definition at line 653 of file cimg.h.

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

Definition at line 652 of file cimg.h.

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

Definition at line 657 of file cimg.h.

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

Definition at line 647 of file cimg.h.

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

Definition at line 654 of file cimg.h.

#define cimg_for5 ( bound,
 ) 
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)

Definition at line 682 of file cimg.h.

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

Definition at line 691 of file cimg.h.

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

Definition at line 688 of file cimg.h.

#define cimg_for5x5 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 1045 of file cimg.h.

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

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

Definition at line 694 of file cimg.h.

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

Definition at line 692 of file cimg.h.

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

Definition at line 698 of file cimg.h.

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

Definition at line 701 of file cimg.h.

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

Definition at line 693 of file cimg.h.

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

Definition at line 699 of file cimg.h.

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

Definition at line 689 of file cimg.h.

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

Definition at line 696 of file cimg.h.

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

Definition at line 695 of file cimg.h.

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

Definition at line 700 of file cimg.h.

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

Definition at line 690 of file cimg.h.

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

Definition at line 697 of file cimg.h.

#define cimg_for6 ( bound,
 ) 
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)

Definition at line 726 of file cimg.h.

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

Definition at line 736 of file cimg.h.

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

Definition at line 733 of file cimg.h.

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

Definition at line 1116 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_correlate().

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

Definition at line 739 of file cimg.h.

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

Definition at line 737 of file cimg.h.

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

Definition at line 743 of file cimg.h.

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

Definition at line 746 of file cimg.h.

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

Definition at line 738 of file cimg.h.

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

Definition at line 744 of file cimg.h.

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

Definition at line 734 of file cimg.h.

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

Definition at line 741 of file cimg.h.

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

Definition at line 740 of file cimg.h.

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

Definition at line 745 of file cimg.h.

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

Definition at line 735 of file cimg.h.

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

Definition at line 742 of file cimg.h.

#define cimg_for7 ( bound,
 ) 
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)

Definition at line 772 of file cimg.h.

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

Definition at line 782 of file cimg.h.

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

Definition at line 779 of file cimg.h.

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

Definition at line 1211 of file cimg.h.

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

Definition at line 785 of file cimg.h.

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

Definition at line 783 of file cimg.h.

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

Definition at line 789 of file cimg.h.

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

Definition at line 792 of file cimg.h.

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

Definition at line 784 of file cimg.h.

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

Definition at line 790 of file cimg.h.

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

Definition at line 780 of file cimg.h.

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

Definition at line 787 of file cimg.h.

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

Definition at line 786 of file cimg.h.

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

Definition at line 791 of file cimg.h.

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

Definition at line 781 of file cimg.h.

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

Definition at line 788 of file cimg.h.

#define cimg_for8 ( bound,
 ) 
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)

Definition at line 819 of file cimg.h.

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

Definition at line 831 of file cimg.h.

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

Definition at line 828 of file cimg.h.

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

Definition at line 1326 of file cimg.h.

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

Definition at line 834 of file cimg.h.

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

Definition at line 832 of file cimg.h.

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

Definition at line 838 of file cimg.h.

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

Definition at line 841 of file cimg.h.

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

Definition at line 833 of file cimg.h.

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

Definition at line 839 of file cimg.h.

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

Definition at line 829 of file cimg.h.

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

Definition at line 836 of file cimg.h.

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

Definition at line 835 of file cimg.h.

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

Definition at line 840 of file cimg.h.

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

Definition at line 830 of file cimg.h.

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

Definition at line 837 of file cimg.h.

#define cimg_for9 ( bound,
 ) 
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)

Definition at line 870 of file cimg.h.

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

Definition at line 882 of file cimg.h.

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

Definition at line 879 of file cimg.h.

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

Definition at line 1472 of file cimg.h.

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

Definition at line 885 of file cimg.h.

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

Definition at line 883 of file cimg.h.

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

Definition at line 889 of file cimg.h.

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

Definition at line 892 of file cimg.h.

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

Definition at line 884 of file cimg.h.

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

Definition at line 890 of file cimg.h.

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

Definition at line 880 of file cimg.h.

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

Definition at line 887 of file cimg.h.

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

Definition at line 886 of file cimg.h.

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

Definition at line 891 of file cimg.h.

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

Definition at line 881 of file cimg.h.

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

Definition at line 888 of file cimg.h.

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

Definition at line 539 of file cimg.h.

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

Definition at line 536 of file cimg.h.

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

Definition at line 540 of file cimg.h.

#define cimg_for_borderXYZ ( img,
x,
y,
z,
 )     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 541 of file cimg.h.

#define cimg_for_borderXYZV ( img,
x,
y,
z,
v,
 )     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 542 of file cimg.h.

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

Definition at line 537 of file cimg.h.

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

Definition at line 538 of file cimg.h.

#define cimg_for_in1 ( bound,
i0,
i1,
 )     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 478 of file cimg.h.

#define cimg_for_in2 ( bound,
i0,
i1,
 ) 
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)

Definition at line 579 of file cimg.h.

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

Definition at line 587 of file cimg.h.

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

Definition at line 584 of file cimg.h.

#define cimg_for_in2x2 ( img,
x0,
y0,
x1,
y1,
x,
y,
z,
v,
 ) 
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)

Definition at line 936 of file cimg.h.

#define cimg_for_in2x2x2 ( img,
x0,
y0,
z0,
x1,
y1,
z1,
x,
y,
z,
v,
 ) 
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)

Definition at line 1660 of file cimg.h.

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

Definition at line 590 of file cimg.h.

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

Definition at line 588 of file cimg.h.

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

Definition at line 594 of file cimg.h.

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

Definition at line 597 of file cimg.h.

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

Definition at line 589 of file cimg.h.

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

Definition at line 595 of file cimg.h.

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

Definition at line 585 of file cimg.h.

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

Definition at line 592 of file cimg.h.

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

Definition at line 591 of file cimg.h.

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

Definition at line 596 of file cimg.h.

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

Definition at line 586 of file cimg.h.

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

Definition at line 593 of file cimg.h.

#define cimg_for_in3 ( bound,
i0,
i1,
 ) 
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)

Definition at line 619 of file cimg.h.

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

Definition at line 628 of file cimg.h.

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

Definition at line 625 of file cimg.h.

#define cimg_for_in3x3 ( img,
x0,
y0,
x1,
y1,
x,
y,
z,
v,
 ) 
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)

Definition at line 968 of file cimg.h.

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

Definition at line 1707 of file cimg.h.

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

Definition at line 631 of file cimg.h.

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

Definition at line 629 of file cimg.h.

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

Definition at line 635 of file cimg.h.

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

Definition at line 638 of file cimg.h.

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

Definition at line 630 of file cimg.h.

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

Definition at line 636 of file cimg.h.

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

Definition at line 626 of file cimg.h.

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

Definition at line 633 of file cimg.h.

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

Definition at line 632 of file cimg.h.

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

Definition at line 637 of file cimg.h.

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

Definition at line 627 of file cimg.h.

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

Definition at line 634 of file cimg.h.

#define cimg_for_in4 ( bound,
i0,
i1,
 ) 
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)

Definition at line 660 of file cimg.h.

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

Definition at line 670 of file cimg.h.

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

Definition at line 667 of file cimg.h.

#define cimg_for_in4x4 ( img,
x0,
y0,
x1,
y1,
x,
y,
z,
v,
 ) 
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)

Definition at line 1015 of file cimg.h.

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

Definition at line 673 of file cimg.h.

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

Definition at line 671 of file cimg.h.

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

Definition at line 677 of file cimg.h.

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

Definition at line 680 of file cimg.h.

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

Definition at line 672 of file cimg.h.

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

Definition at line 678 of file cimg.h.

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

Definition at line 668 of file cimg.h.

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

Definition at line 675 of file cimg.h.

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

Definition at line 674 of file cimg.h.

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

Definition at line 679 of file cimg.h.

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

Definition at line 669 of file cimg.h.

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

Definition at line 676 of file cimg.h.

#define cimg_for_in5 ( bound,
i0,
i1,
 ) 
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)

Definition at line 703 of file cimg.h.

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

Definition at line 714 of file cimg.h.

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

Definition at line 711 of file cimg.h.

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

Definition at line 1075 of file cimg.h.

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

Definition at line 717 of file cimg.h.

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

Definition at line 715 of file cimg.h.

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

Definition at line 721 of file cimg.h.

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

Definition at line 724 of file cimg.h.

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

Definition at line 716 of file cimg.h.

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

Definition at line 722 of file cimg.h.

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

Definition at line 712 of file cimg.h.

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

Definition at line 719 of file cimg.h.

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

Definition at line 718 of file cimg.h.

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

Definition at line 723 of file cimg.h.

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

Definition at line 713 of file cimg.h.

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

Definition at line 720 of file cimg.h.

#define cimg_for_in6 ( bound,
i0,
i1,
 ) 
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)

Definition at line 748 of file cimg.h.

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

Definition at line 760 of file cimg.h.

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

Definition at line 757 of file cimg.h.

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

Definition at line 1157 of file cimg.h.

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

Definition at line 763 of file cimg.h.

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

Definition at line 761 of file cimg.h.

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

Definition at line 767 of file cimg.h.

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

Definition at line 770 of file cimg.h.

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

Definition at line 762 of file cimg.h.

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

Definition at line 768 of file cimg.h.

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

Definition at line 758 of file cimg.h.

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

Definition at line 765 of file cimg.h.

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

Definition at line 764 of file cimg.h.

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

Definition at line 769 of file cimg.h.

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

Definition at line 759 of file cimg.h.

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

Definition at line 766 of file cimg.h.

#define cimg_for_in7 ( bound,
i0,
i1,
 ) 
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)

Definition at line 794 of file cimg.h.

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

Definition at line 807 of file cimg.h.

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

Definition at line 804 of file cimg.h.

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

Definition at line 1257 of file cimg.h.

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

Definition at line 810 of file cimg.h.

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

Definition at line 808 of file cimg.h.

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

Definition at line 814 of file cimg.h.

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

Definition at line 817 of file cimg.h.

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

Definition at line 809 of file cimg.h.

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

Definition at line 815 of file cimg.h.

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

Definition at line 805 of file cimg.h.

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

Definition at line 812 of file cimg.h.

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

Definition at line 811 of file cimg.h.

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

Definition at line 816 of file cimg.h.

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

Definition at line 806 of file cimg.h.

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

Definition at line 813 of file cimg.h.

#define cimg_for_in8 ( bound,
i0,
i1,
 ) 
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)

Definition at line 843 of file cimg.h.

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

Definition at line 858 of file cimg.h.

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

Definition at line 855 of file cimg.h.

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

Definition at line 1386 of file cimg.h.

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

Definition at line 861 of file cimg.h.

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

Definition at line 859 of file cimg.h.

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

Definition at line 865 of file cimg.h.

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

Definition at line 868 of file cimg.h.

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

Definition at line 860 of file cimg.h.

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

Definition at line 866 of file cimg.h.

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

Definition at line 856 of file cimg.h.

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

Definition at line 863 of file cimg.h.

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

Definition at line 862 of file cimg.h.

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

Definition at line 867 of file cimg.h.

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

Definition at line 857 of file cimg.h.

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

Definition at line 864 of file cimg.h.

#define cimg_for_in9 ( bound,
i0,
i1,
 ) 
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)

Definition at line 894 of file cimg.h.

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

Definition at line 910 of file cimg.h.

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

Definition at line 907 of file cimg.h.

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

Definition at line 1538 of file cimg.h.

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

Definition at line 913 of file cimg.h.

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

Definition at line 911 of file cimg.h.

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

Definition at line 917 of file cimg.h.

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

Definition at line 920 of file cimg.h.

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

Definition at line 912 of file cimg.h.

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

Definition at line 918 of file cimg.h.

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

Definition at line 908 of file cimg.h.

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

Definition at line 915 of file cimg.h.

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

Definition at line 914 of file cimg.h.

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

Definition at line 919 of file cimg.h.

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

Definition at line 909 of file cimg.h.

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

Definition at line 916 of file cimg.h.

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

Definition at line 498 of file cimg.h.

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

Definition at line 495 of file cimg.h.

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

Definition at line 499 of file cimg.h.

#define cimg_for_insideXYZ ( img,
x,
y,
z,
 )     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 500 of file cimg.h.

#define cimg_for_insideXYZV ( img,
x,
y,
z,
v,
 )     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 501 of file cimg.h.

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

Definition at line 496 of file cimg.h.

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

Definition at line 497 of file cimg.h.

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

Definition at line 483 of file cimg.h.

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

Definition at line 480 of file cimg.h.

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

Definition at line 486 of file cimg.h.

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

Definition at line 491 of file cimg.h.

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

Definition at line 490 of file cimg.h.

Referenced by cimg_library::CImg< T >::blur_patch().

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

Definition at line 494 of file cimg.h.

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

Definition at line 485 of file cimg.h.

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

Definition at line 492 of file cimg.h.

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

Definition at line 481 of file cimg.h.

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

Definition at line 488 of file cimg.h.

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

Definition at line 487 of file cimg.h.

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

Definition at line 493 of file cimg.h.

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

Definition at line 482 of file cimg.h.

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

Definition at line 489 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))

Definition at line 549 of file cimg.h.

#define cimg_for_out1 ( boundi,
i0,
i1,
 )     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 503 of file cimg.h.

#define cimg_for_out2 ( boundi,
boundj,
i0,
j0,
i1,
j1,
i,
 ) 
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))

Definition at line 505 of file cimg.h.

#define cimg_for_out3 ( boundi,
boundj,
boundk,
i0,
j0,
k0,
i1,
j1,
k1,
i,
j,
 ) 
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))

Definition at line 509 of file cimg.h.

#define cimg_for_out4 ( boundi,
boundj,
boundk,
boundl,
i0,
j0,
k0,
l0,
i1,
j1,
k1,
l1,
i,
j,
k,
 ) 
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))

Definition at line 514 of file cimg.h.

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

Definition at line 523 of file cimg.h.

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

Definition at line 520 of file cimg.h.

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

Definition at line 526 of file cimg.h.

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

Definition at line 524 of file cimg.h.

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

Definition at line 531 of file cimg.h.

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

Definition at line 530 of file cimg.h.

#define cimg_for_outXYZV ( img,
x0,
y0,
z0,
v0,
x1,
y1,
z1,
v1,
x,
y,
z,
 )     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 534 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_resize().

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

Definition at line 525 of file cimg.h.

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

Definition at line 532 of file cimg.h.

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

Definition at line 521 of file cimg.h.

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

Definition at line 528 of file cimg.h.

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

Definition at line 527 of file cimg.h.

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

Definition at line 533 of file cimg.h.

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

Definition at line 522 of file cimg.h.

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

Definition at line 529 of file cimg.h.

#define cimg_for_spiralXY ( img,
x,
 ) 
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)

Definition at line 545 of file cimg.h.

#define cimg_foroff ( img,
off   )     for (unsigned int off = 0; off<(img).size(); ++off)
#define cimg_forV ( img,
 )     cimg_for1((img).dim,v)
#define cimg_forX ( img,
 )     cimg_for1((img).width,x)
#define cimg_forXV ( img,
x,
 )     cimg_forV(img,v) cimg_forX(img,x)

Definition at line 469 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_blur_median().

#define cimg_forXY ( img,
x,
 )     cimg_forY(img,y) cimg_forX(img,x)
#define cimg_forXYV ( img,
x,
y,
 )     cimg_forV(img,v) cimg_forXY(img,x,y)
#define cimg_forXYZ ( img,
x,
y,
 )     cimg_forZ(img,z) cimg_forXY(img,x,y)
#define cimg_forXYZV ( img,
x,
y,
z,
 )     cimg_forV(img,v) cimg_forXYZ(img,x,y,z)
#define cimg_forXZ ( img,
x,
 )     cimg_forZ(img,z) cimg_forX(img,x)

Definition at line 467 of file cimg.h.

#define cimg_forXZV ( img,
x,
z,
 )     cimg_forV(img,v) cimg_forXZ(img,x,z)
#define cimg_forY ( img,
 )     cimg_for1((img).height,y)
#define cimg_forYV ( img,
y,
 )     cimg_forV(img,v) cimg_forY(img,y)

Definition at line 470 of file cimg.h.

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

Definition at line 468 of file cimg.h.

#define cimg_forYZV ( img,
y,
z,
 )     cimg_forV(img,v) cimg_forYZ(img,y,z)
#define cimg_forZ ( img,
 )     cimg_for1((img).depth,z)
#define cimg_forZV ( img,
z,
 )     cimg_forV(img,v) cimg_forZ(img,z)
#define cimg_get2x2 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 377 of file cimg.h.

#define cimg_get2x2x2 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 436 of file cimg.h.

#define cimg_get3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 381 of file cimg.h.

Referenced by cimg_library::CImg< T >::get_BayertoRGB().

#define cimg_get3x3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 442 of file cimg.h.

#define cimg_get4x4 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 386 of file cimg.h.

#define cimg_get5x5 ( img,
x,
y,
z,
v,
 ) 
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)

Definition at line 392 of file cimg.h.

#define cimg_get6x6 ( img,
x,
y,
z,
v,
 ) 
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);

Definition at line 398 of file cimg.h.

#define cimg_get7x7 ( img,
x,
y,
z,
v,
 ) 
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);

Definition at line 406 of file cimg.h.

#define cimg_get8x8 ( img,
x,
y,
z,
v,
 ) 
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);

Definition at line 415 of file cimg.h.

#define cimg_get9x9 ( img,
x,
y,
z,
v,
 ) 
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);

Definition at line 425 of file cimg.h.

#define cimg_gs2x_for3 ( bound,
 ) 
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)
#define cimg_gs2x_for3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Referenced by cimg_library::CImg< T >::get_resize_doubleXY().

#define cimg_gs3x_for3 ( bound,
 ) 
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)
#define cimg_gs3x_for3x3 ( img,
x,
y,
z,
v,
 ) 
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)

Referenced by cimg_library::CImg< T >::get_resize_tripleXY().

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

Definition at line 295 of file cimg.h.

#define cimg_Labf (  )     ((x)>=0.008856?(std::pow(x,1/3.0)):(7.787*(x)+16.0/116.0))
#define cimg_Labfi (  )     ((x)>=0.206893?((x)*(x)*(x)):(((x)-16.0/116.0)/7.787))
#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') tmp[j++] = (char)i; tmp[j] = '\0'; \
          W = H = D = V = 0; \
          if (std::sscanf(tmp,"%u %u %u %u",&W,&H,&D,&V)!=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; \
            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::endian()) cimg::endian_swap(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; \
      }

Referenced by cimg_library::CImgList< T >::load_cimg().

#define cimg_load_cimg_case2 ( Ts,
Tss   ) 
#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::endian_swap(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; \
      }

Referenced by cimg_library::CImg< T >::load_inr().

#define cimg_load_pandore_case ( nid,
nbdim,
nwidth,
nheight,
ndepth,
ndim,
stype   ) 
Value:
case nid: { \
        cimg::fread(dims,nbdim,nfile); \
        if (endian) cimg::endian_swap(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::endian_swap(buffer,siz); \
        T *ptrd = data; \
        cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++); \
        buffer-=siz; \
        delete[] buffer; \
       } \
       break;

Referenced by cimg_library::CImg< T >::load_pandore().

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

Definition at line 296 of file cimg.h.

#define cimg_OS   0
#define cimg_plugin_greycstoration_count
#define cimg_plugin_greycstoration_lock

Definition at line 10328 of file cimg.h.

Referenced by cimg_library::CImg< T >::blur_anisotropic().

#define cimg_plugin_greycstoration_unlock

Definition at line 10331 of file cimg.h.

Referenced by cimg_library::CImg< T >::blur_anisotropic().

#define cimg_save_cimg_case ( Ts,
Tss   ) 
#define cimg_save_pandore_case ( sy,
sz,
sv,
stype,
id   ) 

Definition at line 27807 of file cimg.h.

Referenced by cimg_library::CImg< T >::save_pandore().

#define cimg_test_temporary_path ( p   ) 
Value:
if (!path_found) { \
        std::sprintf(st_temporary_path,"%s",p);                         \
        std::sprintf(tmp,"%s%s%s",st_temporary_path,cimg_OS==2?"\\":"/",filetmp); \
        if ((file=std::fopen(tmp,"wb"))!=0) { std::fclose(file); std::remove(tmp); path_found = true; } \
      }

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

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

Definition at line 294 of file cimg.h.

#define cimg_valign2d ( i,
 ) 
Value:
{ ftype &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_library::CImg< T >::blur_anisotropic().

#define cimg_valign3d ( i,
j,
 ) 
Value:
{ ftype &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_library::CImg< T >::blur_anisotropic().

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

Definition at line 459 of file cimg.h.

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

Definition at line 458 of file cimg.h.

Referenced by cimg_library::CImgList< T >::assign(), cimg_library::CImgList< T >::CImgList(), cimg_library::CImgList< T >::contains(), cimg_library::cimg::dialog(), cimg_library::CImg< T >::display_object3d(), cimg_library::CImg< T >::draw_line(), cimg_library::CImg< T >::draw_object3d(), cimg_library::CImg< T >::draw_point(), cimg_library::CImg< T >::draw_polygon(), cimg_library::CImg< T >::draw_spline(), cimg_library::CImgList< T >::get_append(), cimg_library::CImgList< T >::get_crop(), cimg_library::CImgList< T >::get_crop_font(), cimg_library::CImgList< T >::get_font(), cimg_library::CImgList< T >::get_split(), cimg_library::CImgList< T >::insert(), cimg_library::CImgList< T >::load_parrec(), cimg_library::CImgList< T >::load_tiff(), cimg_library::CImgList< T >::max(), cimg_library::CImgList< T >::maxmin(), cimg_library::CImgList< T >::mean(), cimg_library::CImgList< T >::min(), cimg_library::CImgList< T >::minmax(), cimg_library::operator*(), cimg_library::CImgList< T >::operator*=(), cimg_library::CImgList< T >::operator++(), cimg_library::CImgList< T >::operator+=(), cimg_library::CImgList< T >::operator-(), cimg_library::operator-(), cimg_library::CImgList< T >::operator--(), cimg_library::CImgList< T >::operator-=(), cimg_library::operator/(), cimg_library::CImgList< T >::operator/=(), cimg_library::CImgList< T >::operator=(), cimg_library::CImgList< T >::print(), cimg_library::CImgList< T >::save(), cimg_library::CImgList< T >::save_cimg(), cimg_library::CImgList< T >::save_ffmpeg_external(), cimg_library::CImg< T >::save_off(), cimg_library::CImgList< T >::save_yuv(), and cimg_library::CImgList< T >::variance().

Generated by  doxygen 1.6.2-20100208