cimg.h File Reference

#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <cstring>
#include <cmath>
#include <ctime>
#include "png.h"
#include "jpeglib.h"

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::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_version   128
#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_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_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_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 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_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 _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 _CImgList_stdarg(t)
#define cimg_load_cimg_case(Ts, Tss)
#define cimg_load_cimg_case2(Ts, Tss)
#define cimg_save_cimg_case(Ts, Tss)
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 int & cimg_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 *const 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 T >
cimg_library::cimg::min (const T a, const T b)
 Return the minimum between a and b.
template<typename T >
cimg_library::cimg::min (const T a, const T b, const T c)
 Return the minimum between a,b and c.
template<typename T >
cimg_library::cimg::min (const T a, const T b, const T c, const T d)
 Return the minimum between a,b,c and d.
template<typename T >
cimg_library::cimg::max (const T a, const T b)
 Return the maximum between a and b.
template<typename T >
cimg_library::cimg::max (const T a, const T b, const T c)
 Return the maximum between a,b and c.
template<typename T >
cimg_library::cimg::max (const T a, const T b, const T c, const T 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 >
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::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< 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 >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImg< T > &instance, const char axe, const bool inverse=false)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImg< T > &instance, const bool inverse=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 inverse=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 inverse=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 > &reference, const float smooth=0.1f, const float precision=1e-6f, const unsigned int nb_scale=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::inverse (const CImg< T > &instance, const bool use_LU=true)
template<typename T >
CImg< typename cimg::superset
< T, float >::type > 
cimg_library::pseudoinverse (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 inverse=false)
template<typename T >
CImgList< typename
cimg::superset< T, float >
::type > 
cimg_library::FFT (const CImgList< T > &instance, const bool inverse=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::PI = 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_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 15736 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 15765 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 15809 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 15868 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 15942 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 1244 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);

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

#define _median_sort ( a,
 )     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 249 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 286 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 255 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_gradientXY(), cimg_library::CImg< T >::get_hessianXY(), 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 296 of file cimg.h.

Referenced by cimg_library::CImg< T >::distance_function(), 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 264 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 274 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 236 of file cimg.h.

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

Definition at line 237 of file cimg.h.

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

Definition at line 238 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 239 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 240 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 241 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 242 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 243 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 244 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 245 of file cimg.h.

#define cimg_debug   2

Definition at line 124 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 112 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 1327 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 374 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_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 379 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 478 of file cimg.h.

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

Definition at line 485 of file cimg.h.

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

Definition at line 482 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 737 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 1141 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 488 of file cimg.h.

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

Definition at line 486 of file cimg.h.

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

Definition at line 492 of file cimg.h.

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

Definition at line 495 of file cimg.h.

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

Definition at line 487 of file cimg.h.

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

Definition at line 493 of file cimg.h.

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

Definition at line 483 of file cimg.h.

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

Definition at line 490 of file cimg.h.

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

Definition at line 489 of file cimg.h.

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

Definition at line 494 of file cimg.h.

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

Definition at line 484 of file cimg.h.

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

Definition at line 491 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 517 of file cimg.h.

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

Definition at line 525 of file cimg.h.

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

Definition at line 522 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 765 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 1175 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 528 of file cimg.h.

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

Definition at line 526 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 532 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 535 of file cimg.h.

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

Definition at line 527 of file cimg.h.

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

Definition at line 533 of file cimg.h.

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

Definition at line 523 of file cimg.h.

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

Definition at line 530 of file cimg.h.

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

Definition at line 529 of file cimg.h.

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

Definition at line 534 of file cimg.h.

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

Definition at line 524 of file cimg.h.

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

Definition at line 531 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 558 of file cimg.h.

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

Definition at line 566 of file cimg.h.

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

Definition at line 563 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 804 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 569 of file cimg.h.

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

Definition at line 567 of file cimg.h.

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

Definition at line 573 of file cimg.h.

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

Definition at line 576 of file cimg.h.

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

Definition at line 568 of file cimg.h.

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

Definition at line 574 of file cimg.h.

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

Definition at line 564 of file cimg.h.

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

Definition at line 571 of file cimg.h.

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

Definition at line 570 of file cimg.h.

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

Definition at line 575 of file cimg.h.

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

Definition at line 565 of file cimg.h.

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

Definition at line 572 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 600 of file cimg.h.

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

Definition at line 609 of file cimg.h.

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

Definition at line 606 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 860 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 612 of file cimg.h.

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

Definition at line 610 of file cimg.h.

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

Definition at line 616 of file cimg.h.

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

Definition at line 619 of file cimg.h.

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

Definition at line 611 of file cimg.h.

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

Definition at line 617 of file cimg.h.

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

Definition at line 607 of file cimg.h.

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

Definition at line 614 of file cimg.h.

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

Definition at line 613 of file cimg.h.

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

Definition at line 618 of file cimg.h.

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

Definition at line 608 of file cimg.h.

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

Definition at line 615 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 644 of file cimg.h.

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

Definition at line 654 of file cimg.h.

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

Definition at line 651 of file cimg.h.

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

Definition at line 931 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 657 of file cimg.h.

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

Definition at line 655 of file cimg.h.

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

Definition at line 661 of file cimg.h.

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

Definition at line 664 of file cimg.h.

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

Definition at line 656 of file cimg.h.

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

Definition at line 662 of file cimg.h.

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

Definition at line 652 of file cimg.h.

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

Definition at line 659 of file cimg.h.

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

Definition at line 658 of file cimg.h.

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

Definition at line 663 of file cimg.h.

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

Definition at line 653 of file cimg.h.

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

Definition at line 660 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 690 of file cimg.h.

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

Definition at line 700 of file cimg.h.

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

Definition at line 697 of file cimg.h.

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

Definition at line 1026 of file cimg.h.

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

Definition at line 703 of file cimg.h.

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

Definition at line 701 of file cimg.h.

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

Definition at line 707 of file cimg.h.

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

Definition at line 710 of file cimg.h.

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

Definition at line 702 of file cimg.h.

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

Definition at line 708 of file cimg.h.

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

Definition at line 698 of file cimg.h.

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

Definition at line 705 of file cimg.h.

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

Definition at line 704 of file cimg.h.

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

Definition at line 709 of file cimg.h.

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

Definition at line 699 of file cimg.h.

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

Definition at line 706 of file cimg.h.

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

Definition at line 457 of file cimg.h.

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

Definition at line 454 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 458 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 459 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 460 of file cimg.h.

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

Definition at line 455 of file cimg.h.

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

Definition at line 456 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 396 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 497 of file cimg.h.

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

Definition at line 505 of file cimg.h.

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

Definition at line 502 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 751 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 1158 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 508 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 506 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 512 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 515 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 507 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 513 of file cimg.h.

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

Definition at line 503 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 510 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 509 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 514 of file cimg.h.

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

Definition at line 504 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 511 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 537 of file cimg.h.

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

Definition at line 546 of file cimg.h.

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

Definition at line 543 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 783 of file cimg.h.

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

Definition at line 1205 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 549 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 547 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 553 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 556 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 548 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 554 of file cimg.h.

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

Definition at line 544 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 551 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 550 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 555 of file cimg.h.

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

Definition at line 545 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 552 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 578 of file cimg.h.

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

Definition at line 588 of file cimg.h.

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

Definition at line 585 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 830 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 591 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 589 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 595 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 598 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 590 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 596 of file cimg.h.

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

Definition at line 586 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 593 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 592 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 597 of file cimg.h.

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

Definition at line 587 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 594 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 621 of file cimg.h.

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

Definition at line 632 of file cimg.h.

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

Definition at line 629 of file cimg.h.

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

Definition at line 890 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 635 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 633 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 639 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 642 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 634 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 640 of file cimg.h.

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

Definition at line 630 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 637 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 636 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 641 of file cimg.h.

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

Definition at line 631 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 638 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 666 of file cimg.h.

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

Definition at line 678 of file cimg.h.

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

Definition at line 675 of file cimg.h.

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

Definition at line 972 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 681 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 679 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 685 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 688 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 680 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 686 of file cimg.h.

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

Definition at line 676 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 683 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 682 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 687 of file cimg.h.

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

Definition at line 677 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 684 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 712 of file cimg.h.

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

Definition at line 725 of file cimg.h.

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

Definition at line 722 of file cimg.h.

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

Definition at line 1072 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 728 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 726 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 732 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 735 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 727 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 733 of file cimg.h.

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

Definition at line 723 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 730 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 729 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 734 of file cimg.h.

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

Definition at line 724 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 731 of file cimg.h.

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

Definition at line 416 of file cimg.h.

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

Definition at line 413 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 417 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 418 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 419 of file cimg.h.

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

Definition at line 414 of file cimg.h.

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

Definition at line 415 of file cimg.h.

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

Definition at line 401 of file cimg.h.

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

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

Definition at line 402 of file cimg.h.

#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 409 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 408 of file cimg.h.

#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 412 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 403 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 410 of file cimg.h.

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

Definition at line 399 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 406 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 405 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 411 of file cimg.h.

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

Definition at line 400 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 407 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 467 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 421 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 423 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 427 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 432 of file cimg.h.

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

Definition at line 441 of file cimg.h.

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

Definition at line 438 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 444 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 442 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 449 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 448 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 452 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 443 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 450 of file cimg.h.

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

Definition at line 439 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 446 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 445 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 451 of file cimg.h.

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

Definition at line 440 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 447 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 463 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 387 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 385 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 388 of file cimg.h.

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

Definition at line 386 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 316 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 354 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 320 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 360 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 325 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 331 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 337 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 345 of file cimg.h.

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

Definition at line 234 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 235 of file cimg.h.

#define cimg_OS   0

#define cimg_save_cimg_case ( Ts,
Tss   ) 

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

Definition at line 24865 of file cimg.h.

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

#define cimg_test_temporary_path (  ) 

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 233 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 cimg_version   128

Definition at line 53 of file cimg.h.

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

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

Definition at line 377 of file cimg.h.

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

Definition at line 376 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 >::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::CImg< T >::save_off(), cimg_library::CImgList< T >::save_yuv(), and cimg_library::CImgList< T >::variance().


Generated on Sat Aug 15 14:16:32 2009 for lux by  doxygen 1.5.9