Rocstar-legacy/CImg_8h_source.html

 /*

  #

  #  File            : CImg.h

  #                    ( C++ header file )

  #

  #  Description     : The C++ Template Image Processing Library.

  #                    This file is the main part of the CImg Library project.

  #                    ( http://cimg.sourceforge.net )

  #

  #  Project manager : David Tschumperle.

  #                    ( http://www.greyc.ensicaen.fr/~dtschump/ )

  #

  #                    The complete contributor list can be seen in the 'README.txt' file.

  #

  #  Licenses        : This file is "dual-licensed", you have to choose one

  #                    of the two licenses below to apply on this file.

  #

  #                    CeCILL-C

  #                    The CeCILL-C license is close to the GNU LGPL.

  #                    ( http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html )

  #

  #                or  CeCILL v2.0

  #                    The CeCILL license is compatible with the GNU GPL.

  #                    ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )

  #

  #  This software is governed either by the CeCILL or the CeCILL-C license

  #  under French law and abiding by the rules of distribution of free software.

  #  You can  use, modify and or redistribute the software under the terms of

  #  the CeCILL or CeCILL-C licenses as circulated by CEA, CNRS and INRIA

  #  at the following URL : "http://www.cecill.info".

  #

  #  As a counterpart to the access to the source code and  rights to copy,

  #  modify and redistribute granted by the license, users are provided only

  #  with a limited warranty  and the software's author,  the holder of the

  #  economic rights,  and the successive licensors  have only  limited

  #  liability.

  #

  #  In this respect, the user's attention is drawn to the risks associated

  #  with loading,  using,  modifying and/or developing or reproducing the

  #  software by the user in light of its specific status of free software,

  #  that may mean  that it is complicated to manipulate,  and  that  also

  #  therefore means  that it is reserved for developers  and  experienced

  #  professionals having in-depth computer knowledge. Users are therefore

  #  encouraged to load and test the software's suitability as regards their

  #  requirements in conditions enabling the security of their systems and/or

  #  data to be ensured and,  more generally, to use and operate it in the

  #  same conditions as regards security.

  #

  #  The fact that you are presently reading this means that you have had

  #  knowledge of the CeCILL and CeCILL-C licenses and that you accept its terms.

  #

 */


 // Define version number of the current file.

 #ifndef cimg_version

 #define cimg_version 132


 /*-----------------------------------------------------------

  #

  # Test/auto-set CImg configuration variables

  # and include required headers.

  #

  # If you find that default configuration variables are

  # not adapted, you can override their values before including

  # the header file "CImg.h" (using the #define directive).

  #

  ------------------------------------------------------------*/


 // Include required standard C++ headers.

 #include <cstdio>

 #include <cstdlib>

 #include <cstdarg>

 #include <cstring>

 #include <cmath>

 #include <ctime>


 // Operating system configuration.

 //

 // Define 'cimg_OS' to : 0 for an unknown OS (will try to minize library dependancies).

 //                       1 for a Unix-like OS (Linux, Solaris, BSD, MacOSX, Irix, ...).

 //                       2 for Microsoft Windows.

 #ifndef cimg_OS

 #if defined(unix)        || defined(__unix)      || defined(__unix__) \

  || defined(linux)       || defined(__linux)     || defined(__linux__) \

  || defined(sun)         || defined(__sun) \

  || defined(BSD)         || defined(__OpenBSD__) || defined(__NetBSD__) \

  || defined(__FreeBSD__) || defined __DragonFly__ \

  || defined(sgi)         || defined(__sgi) \

  || defined(__MACOSX__)  || defined(__APPLE__) \

  || defined(__CYGWIN__)

 #define cimg_OS 1

 #elif defined(_MSC_VER) || defined(WIN32)  || defined(_WIN32) || defined(__WIN32__) \

    || defined(WIN64)    || defined(_WIN64) || defined(__WIN64__)

 #define cimg_OS 2

 #else

 #define cimg_OS 0

 #endif

 #elif !(cimg_OS==0 || cimg_OS==1 || cimg_OS==2)

 #error CImg Library : Configuration variable 'cimg_OS' is badly defined.

 #error (valid values are '0=unknown OS', '1=Unix-like OS', '2=Microsoft Windows').

 #endif


 // Compiler configuration.

 //

 // Try to detect Microsoft VC++ compilers.

 // (lot of workarounds are needed afterwards to

 // make CImg working, particularly with VC++ 6.0).

 #ifdef _MSC_VER

 #pragma warning(push)

 #pragma warning(disable:4311)

 #pragma warning(disable:4312)

 #pragma warning(disable:4800)

 #pragma warning(disable:4804)

 #pragma warning(disable:4996)

 #define _CRT_SECURE_NO_DEPRECATE 1

 #define _CRT_NONSTDC_NO_DEPRECATE 1

 #endif


 // Include OS-specific headers.

 #if cimg_OS==1

 #include <sys/time.h>

 #include <unistd.h>

 #elif cimg_OS==2

 #include <windows.h>

 #ifndef _WIN32_IE

 #define _WIN32_IE 0x0400

 #endif

 #include <shlobj.h>

 #endif


 // Define default pipe for output messages.

 //

 // Define 'cimg_stdout' to : stdout to print CImg messages on the standard output.

 //                           stderr to print CImg messages on the standart error output (default behavior).

 #ifndef cimg_stdout

 #define cimg_stdout stderr

 #endif


 // Define default filename separator.

 #ifndef cimg_file_separator

 #if cimg_OS==2

 #define cimg_file_separator '\\'

 #else

 #define cimg_file_separator '/'

 #endif

 #endif


 // Output messages configuration.

 //

 // Define 'cimg_debug' to : 0 to hide debug messages (quiet mode, but exceptions are still thrown).

 //                          1 to display debug messages on the console.

 //                          2 to display debug messages with dialog windows (default behavior).

 //                          3 to do as 1 + add extra warnings (may slow down the code !).

 //                          4 to do as 2 + add extra warnings (may slow down the code !).

 //

 // Define 'cimg_strict_warnings' to replace warning messages by exception throwns.

 //

 // Define 'cimg_use_vt100' to allow output of color messages (require VT100-compatible terminal).

 #ifndef cimg_debug

 #define cimg_debug 2

 #elif !(cimg_debug==0 || cimg_debug==1 || cimg_debug==2 || cimg_debug==3 || cimg_debug==4)

 #error CImg Library : Configuration variable 'cimg_debug' is badly defined.

 #error (valid values are '0=quiet', '1=console', '2=dialog', '3=console+warnings', '4=dialog+warnings').

 #endif


 // Display framework configuration.

 //

 // Define 'cimg_display' to : 0 to disable display capabilities.

 //                            1 to use X-Window framework (X11).

 //                            2 to use Microsoft GDI32 framework.

 //                            3 to use Apple Carbon framework.

 #define cimg_display 0

 #ifndef cimg_display

 #if cimg_OS==0

 #define cimg_display 0

 #elif cimg_OS==1

 #if defined(__MACOSX__) || defined(__APPLE__)

 #define cimg_display 1

 #else

 #define cimg_display 1

 #endif

 #elif cimg_OS==2

 #define cimg_display 2

 #endif

 #elif !(cimg_display==0 || cimg_display==1 || cimg_display==2 || cimg_display==3)

 #error CImg Library : Configuration variable 'cimg_display' is badly defined.

 #error (valid values are '0=disable', '1=X-Window (X11)', '2=Microsoft GDI32', '3=Apple Carbon').

 #endif


 // Include display-specific headers.

 #if cimg_display==1

 #include <X11/Xlib.h>

 #include <X11/Xutil.h>

 #include <X11/keysym.h>

 #include <pthread.h>

 #ifdef cimg_use_xshm

 #include <sys/ipc.h>

 #include <sys/shm.h>

 #include <X11/extensions/XShm.h>

 #endif

 #ifdef cimg_use_xrandr

 #include <X11/extensions/Xrandr.h>

 #endif

 #elif cimg_display==3

 #include <Carbon/Carbon.h>

 #include <pthread.h>

 #endif


 // OpenMP configuration.

 // (http://www.openmp.org)

 //

 // Define 'cimg_use_openmp' to enable OpenMP support.

 //

 // OpenMP directives can be used in few CImg functions to get

 // advantages of multi-core CPUs. Using OpenMP is not mandatory.

 #ifdef cimg_use_openmp

 #include "omp.h"

 #endif


 // LibPNG configuration.

 // (http://www.libpng.org)

 //

 // Define 'cimg_use_png' to enable LibPNG support.

 //

 // LibPNG can be used in functions 'CImg<T>::{load,save}_png()'

 // to get a builtin support of PNG files. Using LibPNG is not mandatory.

 #ifdef cimg_use_png

 extern "C" {

 #include "png.h"

 }

 #endif


 // LibJPEG configuration.

 // (http://en.wikipedia.org/wiki/Libjpeg)

 //

 // Define 'cimg_use_jpeg' to enable LibJPEG support.

 //

 // LibJPEG can be used in functions 'CImg<T>::{load,save}_jpeg()'

 // to get a builtin support of JPEG files. Using LibJPEG is not mandatory.

 #ifdef cimg_use_jpeg

 extern "C" {

 #include "jpeglib.h"

 }

 #endif


 // LibTIFF configuration.

 // (http://www.libtiff.org)

 //

 // Define 'cimg_use_tiff' to enable LibTIFF support.

 //

 // LibTIFF can be used in functions 'CImg[List]<T>::{load,save}_tiff()'

 // to get a builtin support of TIFF files. Using LibTIFF is not mandatory.

 #ifdef cimg_use_tiff

 extern "C" {

 #include "tiffio.h"

 }

 #endif


 // FFMPEG Avcodec and Avformat libraries configuration.

 // (http://www.ffmpeg.org)

 //

 // Define 'cimg_use_ffmpeg' to enable FFMPEG lib support.

 //

 // Avcodec and Avformat libraries can be used in functions

 // 'CImg[List]<T>::load_ffmpeg()' to get a builtin

 // support of various image sequences files.

 // Using FFMPEG libraries is not mandatory.

 #ifdef cimg_use_ffmpeg

 extern "C" {

 #include "avformat.h"

 #include "avcodec.h"

 #include "swscale.h"

 }

 #endif


 // Zlib configuration

 // (http://www.zlib.net)

 //

 // Define 'cimg_use_zlib' to enable Zlib support.

 //

 // Zlib can be used in functions 'CImg[List]<T>::{load,save}_cimg()'

 // to allow compressed data in '.cimg' files. Using Zlib is not mandatory.

 #ifdef cimg_use_zlib

 extern "C" {

 #include "zlib.h"

 }

 #endif


 // Magick++ configuration.

 // (http://www.imagemagick.org/Magick++)

 //

 // Define 'cimg_use_magick' to enable Magick++ support.

 //

 // Magick++ library can be used in functions 'CImg<T>::{load,save}()'

 // to get a builtin support of various image formats (PNG,JPEG,TIFF,...).

 // Using Magick++ is not mandatory.

 #ifdef cimg_use_magick

 #include "Magick++.h"

 #endif


 // FFTW3 configuration.

 // (http://www.fftw.org)

 //

 // Define 'cimg_use_fftw3' to enable libFFTW3 support.

 //

 // FFTW3 library can be used in functions 'CImg[List]<T>::FFT()' to

 // efficiently compile the Fast Fourier Transform of image data.

 #ifdef cimg_use_fftw3

 extern "C" {

 #include "fftw3.h"

 }

 #endif


 // Board configuration

 // (http://libboard.sourceforge.net/)

 //

 // Define 'cimg_use_board' to enable Board support.

 //

 // Board library can be used in functions 'CImg<T>::draw_object3d()'

 // to draw objects 3D in vector-graphics canvas that can be saved

 // as .PS or .SVG files afterwards.

 #ifdef cimg_use_board

 #ifdef None

 #undef None

 #define _cimg_redefine_None

 #endif

 #include "Board.h"

 #endif


 // Lapack configuration.

 // (http://www.netlib.org/lapack)

 //

 // Define 'cimg_use_lapack' to enable LAPACK support.

 //

 // Lapack can be used in various CImg functions dealing with

 // matrix computation and algorithms (eigenvalues, inverse, ...).

 // Using Lapack is not mandatory.

 #ifdef cimg_use_lapack

 extern "C" {

   extern void sgetrf_(int*, int*, float*, int*, int*, int*);

   extern void sgetri_(int*, float*, int*, int*, float*, int*, int*);

   extern void sgetrs_(char*, int*, int*, float*, int*, int*, float*, int*, int*);

   extern void sgesvd_(char*, char*, int*, int*, float*, int*, float*, float*, int*, float*, int*, float*, int*, int*);

   extern void ssyev_(char*, char*, int*, float*, int*, float*, float*, int*, int*);

   extern void dgetrf_(int*, int*, double*, int*, int*, int*);

   extern void dgetri_(int*, double*, int*, int*, double*, int*, int*);

   extern void dgetrs_(char*, int*, int*, double*, int*, int*, double*, int*, int*);

   extern void dgesvd_(char*, char*, int*, int*, double*, int*, double*, double*, int*, double*, int*, double*, int*, int*);

   extern void dsyev_(char*, char*, int*, double*, int*, double*, double*, int*, int*);

 }

 #endif


 // Check if min/max macros are defined.

 //

 // CImg does not compile if macros 'min' or 'max' are defined,

 // because min() and max() functions are also defined in the cimg:: namespace.

 // so it '#undef' these macros if necessary, and restore them to reasonable

 // values at the end of the file.

 #ifdef min

 #undef min

 #define _cimg_redefine_min

 #endif

 #ifdef max

 #undef max

 #define _cimg_redefine_max

 #endif


 // Set the current working directory for native MacOSX bundled applications.

 //

 // By default, MacOS bundled applications set the cwd at the root directory '/',

 // the code below allows to set it to the current exec directory instead when

 // a CImg-based program is executed.

 #if cimg_OS==1 && cimg_display==3

 static struct _cimg_macosx_setcwd {

   _cimg_macosx_setcwd() {

     FSRef location;

     ProcessSerialNumber psn;

     char filePath[512] = { 0 };

     if (GetCurrentProcess(&psn)!=noErr) return;

     if (GetProcessBundleLocation(&psn,&location)!=noErr) return;

     FSRefMakePath(&location,(UInt8*)filePath,sizeof(filePath)-1);

     unsigned int p = std::strlen(filePath);

     while (filePath[p] != '/') --p;

     filePath[p] = 0;

     chdir(filePath);

   }

 } cimg_macosx_setcwd;

 #endif


 /*------------------------------------------------------------------------------

   #

   # Define user-friendly macros.

   #

   # User macros are prefixed by 'cimg_' and can be used in your own code.

   # They are particularly useful for option parsing, and image loops creation.

   #

   ------------------------------------------------------------------------------*/


 // Define the program usage, and retrieve command line arguments.

 #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 and manipulate local neighborhoods.

 #define CImg_2x2(I,T) 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


 #define CImg_3x3(I,T) 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


 #define CImg_4x4(I,T) 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


 #define CImg_5x5(I,T) 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


 #define CImg_2x2x2(I,T) 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


 #define CImg_3x3x3(I,T) 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


 #define cimg_get2x2(img,x,y,z,v,I) \

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


 #define cimg_get3x3(img,x,y,z,v,I) \

   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)


 #define cimg_get4x4(img,x,y,z,v,I) \

   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)


 #define cimg_get5x5(img,x,y,z,v,I) \

   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)


 #define cimg_get6x6(img,x,y,z,v,I) \

  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)


 #define cimg_get7x7(img,x,y,z,v,I) \

  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)


 #define cimg_get8x8(img,x,y,z,v,I) \

  I[0] = (img)(_p3##x,_p3##y,z,v), I[1] = (img)(_p2##x,_p3##y,z,v), I[2] = (img)(_p1##x,_p3##y,z,v), I[3] = (img)(x,_p3##y,z,v), \

  I[4] = (img)(_n1##x,_p3##y,z,v), I[5] = (img)(_n2##x,_p3##y,z,v), I[6] = (img)(_n3##x,_p3##y,z,v), I[7] = (img)(_n4##x,_p3##y,z,v), \

  I[8] = (img)(_p3##x,_p2##y,z,v), I[9] = (img)(_p2##x,_p2##y,z,v), I[10] = (img)(_p1##x,_p2##y,z,v), I[11] = (img)(x,_p2##y,z,v), \

  I[12] = (img)(_n1##x,_p2##y,z,v), I[13] = (img)(_n2##x,_p2##y,z,v), I[14] = (img)(_n3##x,_p2##y,z,v), I[15] = (img)(_n4##x,_p2##y,z,v), \

  I[16] = (img)(_p3##x,_p1##y,z,v), I[17] = (img)(_p2##x,_p1##y,z,v), I[18] = (img)(_p1##x,_p1##y,z,v), I[19] = (img)(x,_p1##y,z,v), \

  I[20] = (img)(_n1##x,_p1##y,z,v), I[21] = (img)(_n2##x,_p1##y,z,v), I[22] = (img)(_n3##x,_p1##y,z,v), I[23] = (img)(_n4##x,_p1##y,z,v), \

  I[24] = (img)(_p3##x,y,z,v), I[25] = (img)(_p2##x,y,z,v), I[26] = (img)(_p1##x,y,z,v), I[27] = (img)(x,y,z,v), \

  I[28] = (img)(_n1##x,y,z,v), I[29] = (img)(_n2##x,y,z,v), I[30] = (img)(_n3##x,y,z,v), I[31] = (img)(_n4##x,y,z,v), \

  I[32] = (img)(_p3##x,_n1##y,z,v), I[33] = (img)(_p2##x,_n1##y,z,v), I[34] = (img)(_p1##x,_n1##y,z,v), I[35] = (img)(x,_n1##y,z,v), \

  I[36] = (img)(_n1##x,_n1##y,z,v), I[37] = (img)(_n2##x,_n1##y,z,v), I[38] = (img)(_n3##x,_n1##y,z,v), I[39] = (img)(_n4##x,_n1##y,z,v), \

  I[40] = (img)(_p3##x,_n2##y,z,v), I[41] = (img)(_p2##x,_n2##y,z,v), I[42] = (img)(_p1##x,_n2##y,z,v), I[43] = (img)(x,_n2##y,z,v), \

  I[44] = (img)(_n1##x,_n2##y,z,v), I[45] = (img)(_n2##x,_n2##y,z,v), I[46] = (img)(_n3##x,_n2##y,z,v), I[47] = (img)(_n4##x,_n2##y,z,v), \

  I[48] = (img)(_p3##x,_n3##y,z,v), I[49] = (img)(_p2##x,_n3##y,z,v), I[50] = (img)(_p1##x,_n3##y,z,v), I[51] = (img)(x,_n3##y,z,v), \

  I[52] = (img)(_n1##x,_n3##y,z,v), I[53] = (img)(_n2##x,_n3##y,z,v), I[54] = (img)(_n3##x,_n3##y,z,v), I[55] = (img)(_n4##x,_n3##y,z,v), \

  I[56] = (img)(_p3##x,_n4##y,z,v), I[57] = (img)(_p2##x,_n4##y,z,v), I[58] = (img)(_p1##x,_n4##y,z,v), I[59] = (img)(x,_n4##y,z,v), \

  I[60] = (img)(_n1##x,_n4##y,z,v), I[61] = (img)(_n2##x,_n4##y,z,v), I[62] = (img)(_n3##x,_n4##y,z,v), I[63] = (img)(_n4##x,_n4##y,z,v);


 #define cimg_get9x9(img,x,y,z,v,I) \

  I[0] = (img)(_p4##x,_p4##y,z,v), I[1] = (img)(_p3##x,_p4##y,z,v), I[2] = (img)(_p2##x,_p4##y,z,v), I[3] = (img)(_p1##x,_p4##y,z,v), \

  I[4] = (img)(x,_p4##y,z,v), I[5] = (img)(_n1##x,_p4##y,z,v), I[6] = (img)(_n2##x,_p4##y,z,v), I[7] = (img)(_n3##x,_p4##y,z,v), \

  I[8] = (img)(_n4##x,_p4##y,z,v), I[9] = (img)(_p4##x,_p3##y,z,v), I[10] = (img)(_p3##x,_p3##y,z,v), I[11] = (img)(_p2##x,_p3##y,z,v), \

  I[12] = (img)(_p1##x,_p3##y,z,v), I[13] = (img)(x,_p3##y,z,v), I[14] = (img)(_n1##x,_p3##y,z,v), I[15] = (img)(_n2##x,_p3##y,z,v), \

  I[16] = (img)(_n3##x,_p3##y,z,v), I[17] = (img)(_n4##x,_p3##y,z,v), I[18] = (img)(_p4##x,_p2##y,z,v), I[19] = (img)(_p3##x,_p2##y,z,v), \

  I[20] = (img)(_p2##x,_p2##y,z,v), I[21] = (img)(_p1##x,_p2##y,z,v), I[22] = (img)(x,_p2##y,z,v), I[23] = (img)(_n1##x,_p2##y,z,v), \

  I[24] = (img)(_n2##x,_p2##y,z,v), I[25] = (img)(_n3##x,_p2##y,z,v), I[26] = (img)(_n4##x,_p2##y,z,v), I[27] = (img)(_p4##x,_p1##y,z,v), \

  I[28] = (img)(_p3##x,_p1##y,z,v), I[29] = (img)(_p2##x,_p1##y,z,v), I[30] = (img)(_p1##x,_p1##y,z,v), I[31] = (img)(x,_p1##y,z,v), \

  I[32] = (img)(_n1##x,_p1##y,z,v), I[33] = (img)(_n2##x,_p1##y,z,v), I[34] = (img)(_n3##x,_p1##y,z,v), I[35] = (img)(_n4##x,_p1##y,z,v), \

  I[36] = (img)(_p4##x,y,z,v), I[37] = (img)(_p3##x,y,z,v), I[38] = (img)(_p2##x,y,z,v), I[39] = (img)(_p1##x,y,z,v), \

  I[40] = (img)(x,y,z,v), I[41] = (img)(_n1##x,y,z,v), I[42] = (img)(_n2##x,y,z,v), I[43] = (img)(_n3##x,y,z,v), \

  I[44] = (img)(_n4##x,y,z,v), I[45] = (img)(_p4##x,_n1##y,z,v), I[46] = (img)(_p3##x,_n1##y,z,v), I[47] = (img)(_p2##x,_n1##y,z,v), \

  I[48] = (img)(_p1##x,_n1##y,z,v), I[49] = (img)(x,_n1##y,z,v), I[50] = (img)(_n1##x,_n1##y,z,v), I[51] = (img)(_n2##x,_n1##y,z,v), \

  I[52] = (img)(_n3##x,_n1##y,z,v), I[53] = (img)(_n4##x,_n1##y,z,v), I[54] = (img)(_p4##x,_n2##y,z,v), I[55] = (img)(_p3##x,_n2##y,z,v), \

  I[56] = (img)(_p2##x,_n2##y,z,v), I[57] = (img)(_p1##x,_n2##y,z,v), I[58] = (img)(x,_n2##y,z,v), I[59] = (img)(_n1##x,_n2##y,z,v), \

  I[60] = (img)(_n2##x,_n2##y,z,v), I[61] = (img)(_n3##x,_n2##y,z,v), I[62] = (img)(_n4##x,_n2##y,z,v), I[63] = (img)(_p4##x,_n3##y,z,v), \

  I[64] = (img)(_p3##x,_n3##y,z,v), I[65] = (img)(_p2##x,_n3##y,z,v), I[66] = (img)(_p1##x,_n3##y,z,v), I[67] = (img)(x,_n3##y,z,v), \

  I[68] = (img)(_n1##x,_n3##y,z,v), I[69] = (img)(_n2##x,_n3##y,z,v), I[70] = (img)(_n3##x,_n3##y,z,v), I[71] = (img)(_n4##x,_n3##y,z,v), \

  I[72] = (img)(_p4##x,_n4##y,z,v), I[73] = (img)(_p3##x,_n4##y,z,v), I[74] = (img)(_p2##x,_n4##y,z,v), I[75] = (img)(_p1##x,_n4##y,z,v), \

  I[76] = (img)(x,_n4##y,z,v), I[77] = (img)(_n1##x,_n4##y,z,v), I[78] = (img)(_n2##x,_n4##y,z,v), I[79] = (img)(_n3##x,_n4##y,z,v), \

  I[80] = (img)(_n4##x,_n4##y,z,v)


 #define cimg_get2x2x2(img,x,y,z,v,I) \

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

   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)


 #define cimg_get3x3x3(img,x,y,z,v,I) \

   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)


 // Define various image loops.

 //

 // These macros generally avoid the use of iterators, but you are not forced to used them !

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for_in1(bound,i0,i1,i) \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for_out1(boundi,i0,i1,i) \

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

 #define cimg_for_out2(boundi,boundj,i0,j0,i1,j1,i,j) \

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

 #define cimg_for_out3(boundi,boundj,boundk,i0,j0,k0,i1,j1,k1,i,j,k) \

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

 #define cimg_for_out4(boundi,boundj,boundk,boundl,i0,j0,k0,l0,i1,j1,k1,l1,i,j,k,l) \

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

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

  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)


 #define cimg_for_lineXY(x,y,x0,y0,x1,y1) \

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


 #define cimg_for2(bound,i) \

  for (int i = 0, _n1##i = 1>=(bound)?(int)(bound)-1:1; \

       _n1##i<(int)(bound) || i==--_n1##i; \

       ++i, ++_n1##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) \

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

  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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for8(bound,i) \

  for (int i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \

       _n1##i = 1>=(bound)?(int)(bound)-1:1, \

       _n2##i = 2>=(bound)?(int)(bound)-1:2, \

       _n3##i = 3>=(bound)?(int)(bound)-1:3, \

       _n4##i = 4>=(bound)?(int)(bound)-1:4; \

       _n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \

       i==(_n4##i = _n3##i = _n2##i = --_n1##i); \

       _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for_in8(bound,i0,i1,i) \

  for (int i = (int)(i0)<0?0:(int)(i0), \

       _p3##i = i-3<0?0:i-3, \

       _p2##i = i-2<0?0:i-2, \

       _p1##i = i-1<0?0:i-1, \

       _n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \

       _n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \

       _n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3, \

       _n4##i = i+4>=(int)(bound)?(int)(bound)-1:i+4; \

       i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \

       i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \

       _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for9(bound,i) \

   for (int i = 0, _p4##i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \

        _n1##i = 1>=(int)(bound)?(int)(bound)-1:1, \

        _n2##i = 2>=(int)(bound)?(int)(bound)-1:2, \

        _n3##i = 3>=(int)(bound)?(int)(bound)-1:3, \

        _n4##i = 4>=(int)(bound)?(int)(bound)-1:4; \

        _n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \

        i==(_n4##i = _n3##i = _n2##i = --_n1##i); \

        _p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for_in9(bound,i0,i1,i) \

   for (int i = (int)(i0)<0?0:(int)(i0), \

        _p4##i = i-4<0?0:i-4, \

        _p3##i = i-3<0?0:i-3, \

        _p2##i = i-2<0?0:i-2, \

        _p1##i = i-1<0?0:i-1, \

        _n1##i = i+1>=(int)(bound)?(int)(bound)-1:i+1, \

        _n2##i = i+2>=(int)(bound)?(int)(bound)-1:i+2, \

        _n3##i = i+3>=(int)(bound)?(int)(bound)-1:i+3, \

        _n4##i = i+4>=(int)(bound)?(int)(bound)-1:i+4; \

        i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \

        i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \

        _p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


 #define cimg_for2x2(img,x,y,z,v,I) \

   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)


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

   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)


 #define cimg_for3x3(img,x,y,z,v,I) \

   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)


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

   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)


 #define cimg_for4x4(img,x,y,z,v,I) \

   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)


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

   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)


 #define cimg_for5x5(img,x,y,z,v,I) \

  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)


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

  cimg_for_in5((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \

    _p2##x = x-2<0?0:x-2, \

    _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)(_p2##x,_p2##y,z,v)), \

    (I[5] = (img)(_p2##x,_p1##y,z,v)), \

    (I[10] = (img)(_p2##x,y,z,v)), \

    (I[15] = (img)(_p2##x,_n1##y,z,v)), \

    (I[20] = (img)(_p2##x,_n2##y,z,v)), \

    (I[1] = (img)(_p1##x,_p2##y,z,v)), \

    (I[6] = (img)(_p1##x,_p1##y,z,v)), \

    (I[11] = (img)(_p1##x,y,z,v)), \

    (I[16] = (img)(_p1##x,_n1##y,z,v)), \

    (I[21] = (img)(_p1##x,_n2##y,z,v)), \

    (I[2] = (img)(x,_p2##y,z,v)), \

    (I[7] = (img)(x,_p1##y,z,v)), \

    (I[12] = (img)(x,y,z,v)), \

    (I[17] = (img)(x,_n1##y,z,v)), \

    (I[22] = (img)(x,_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)), \

    x+2>=(int)(img).width?(int)((img).width)-1:x+2); \

    x<=(int)(x1) && ((_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)


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

  cimg_for6((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 = 2>=(img).width?(int)((img).width)-1:2, \

    _n3##x = (int)( \

    (I[0] = I[1] = I[2] = (img)(0,_p2##y,z,v)), \

    (I[6] = I[7] = I[8] = (img)(0,_p1##y,z,v)), \

    (I[12] = I[13] = I[14] = (img)(0,y,z,v)), \

    (I[18] = I[19] = I[20] = (img)(0,_n1##y,z,v)), \

    (I[24] = I[25] = I[26] = (img)(0,_n2##y,z,v)), \

    (I[30] = I[31] = I[32] = (img)(0,_n3##y,z,v)), \

    (I[3] = (img)(_n1##x,_p2##y,z,v)), \

    (I[9] = (img)(_n1##x,_p1##y,z,v)), \

    (I[15] = (img)(_n1##x,y,z,v)), \

    (I[21] = (img)(_n1##x,_n1##y,z,v)), \

    (I[27] = (img)(_n1##x,_n2##y,z,v)), \

    (I[33] = (img)(_n1##x,_n3##y,z,v)), \

    (I[4] = (img)(_n2##x,_p2##y,z,v)), \

    (I[10] = (img)(_n2##x,_p1##y,z,v)), \

    (I[16] = (img)(_n2##x,y,z,v)), \

    (I[22] = (img)(_n2##x,_n1##y,z,v)), \

    (I[28] = (img)(_n2##x,_n2##y,z,v)), \

    (I[34] = (img)(_n2##x,_n3##y,z,v)), \

    3>=(img).width?(int)((img).width)-1:3); \

    (_n3##x<(int)((img).width) && ( \

    (I[5] = (img)(_n3##x,_p2##y,z,v)), \

    (I[11] = (img)(_n3##x,_p1##y,z,v)), \

    (I[17] = (img)(_n3##x,y,z,v)), \

    (I[23] = (img)(_n3##x,_n1##y,z,v)), \

    (I[29] = (img)(_n3##x,_n2##y,z,v)), \

    (I[35] = (img)(_n3##x,_n3##y,z,v)),1)) || \

    _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3## x = _n2##x = --_n1##x); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], \

    I[6] = I[7], I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], \

    I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \

    I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \

    I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], \

    I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \

    _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)


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

   cimg_for_in6((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)x0, \

    _p2##x = x-2<0?0:x-2, \

    _p1##x = x-1<0?0:x-1, \

    _n1##x = x+1>=(int)(img).width?(int)((img).width)-1:x+1, \

    _n2##x = x+2>=(int)(img).width?(int)((img).width)-1:x+2, \

    _n3##x = (int)( \

    (I[0] = (img)(_p2##x,_p2##y,z,v)), \

    (I[6] = (img)(_p2##x,_p1##y,z,v)), \

    (I[12] = (img)(_p2##x,y,z,v)), \

    (I[18] = (img)(_p2##x,_n1##y,z,v)), \

    (I[24] = (img)(_p2##x,_n2##y,z,v)), \

    (I[30] = (img)(_p2##x,_n3##y,z,v)), \

    (I[1] = (img)(_p1##x,_p2##y,z,v)), \

    (I[7] = (img)(_p1##x,_p1##y,z,v)), \

    (I[13] = (img)(_p1##x,y,z,v)), \

    (I[19] = (img)(_p1##x,_n1##y,z,v)), \

    (I[25] = (img)(_p1##x,_n2##y,z,v)), \

    (I[31] = (img)(_p1##x,_n3##y,z,v)), \

    (I[2] = (img)(x,_p2##y,z,v)), \

    (I[8] = (img)(x,_p1##y,z,v)), \

    (I[14] = (img)(x,y,z,v)), \

    (I[20] = (img)(x,_n1##y,z,v)), \

    (I[26] = (img)(x,_n2##y,z,v)), \

    (I[32] = (img)(x,_n3##y,z,v)), \

    (I[3] = (img)(_n1##x,_p2##y,z,v)), \

    (I[9] = (img)(_n1##x,_p1##y,z,v)), \

    (I[15] = (img)(_n1##x,y,z,v)), \

    (I[21] = (img)(_n1##x,_n1##y,z,v)), \

    (I[27] = (img)(_n1##x,_n2##y,z,v)), \

    (I[33] = (img)(_n1##x,_n3##y,z,v)), \

    (I[4] = (img)(_n2##x,_p2##y,z,v)), \

    (I[10] = (img)(_n2##x,_p1##y,z,v)), \

    (I[16] = (img)(_n2##x,y,z,v)), \

    (I[22] = (img)(_n2##x,_n1##y,z,v)), \

    (I[28] = (img)(_n2##x,_n2##y,z,v)), \

    (I[34] = (img)(_n2##x,_n3##y,z,v)), \

    x+3>=(int)(img).width?(int)((img).width)-1:x+3); \

    x<=(int)(x1) && ((_n3##x<(int)((img).width) && ( \

    (I[5] = (img)(_n3##x,_p2##y,z,v)), \

    (I[11] = (img)(_n3##x,_p1##y,z,v)), \

    (I[17] = (img)(_n3##x,y,z,v)), \

    (I[23] = (img)(_n3##x,_n1##y,z,v)), \

    (I[29] = (img)(_n3##x,_n2##y,z,v)), \

    (I[35] = (img)(_n3##x,_n3##y,z,v)),1)) || \

    _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3## x = _n2##x = --_n1##x)); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], \

    I[6] = I[7], I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], \

    I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \

    I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \

    I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], \

    I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \

    _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)


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

   cimg_for7((img).height,y) for (int x = 0, \

    _p3##x = 0, _p2##x = 0, _p1##x = 0, \

    _n1##x = 1>=(img).width?(int)((img).width)-1:1, \

    _n2##x = 2>=(img).width?(int)((img).width)-1:2, \

    _n3##x = (int)( \

    (I[0] = I[1] = I[2] = I[3] = (img)(0,_p3##y,z,v)), \

    (I[7] = I[8] = I[9] = I[10] = (img)(0,_p2##y,z,v)), \

    (I[14] = I[15] = I[16] = I[17] = (img)(0,_p1##y,z,v)), \

    (I[21] = I[22] = I[23] = I[24] = (img)(0,y,z,v)), \

    (I[28] = I[29] = I[30] = I[31] = (img)(0,_n1##y,z,v)), \

    (I[35] = I[36] = I[37] = I[38] = (img)(0,_n2##y,z,v)), \

    (I[42] = I[43] = I[44] = I[45] = (img)(0,_n3##y,z,v)), \

    (I[4] = (img)(_n1##x,_p3##y,z,v)), \

    (I[11] = (img)(_n1##x,_p2##y,z,v)), \

    (I[18] = (img)(_n1##x,_p1##y,z,v)), \

    (I[25] = (img)(_n1##x,y,z,v)), \

    (I[32] = (img)(_n1##x,_n1##y,z,v)), \

    (I[39] = (img)(_n1##x,_n2##y,z,v)), \

    (I[46] = (img)(_n1##x,_n3##y,z,v)), \

    (I[5] = (img)(_n2##x,_p3##y,z,v)), \

    (I[12] = (img)(_n2##x,_p2##y,z,v)), \

    (I[19] = (img)(_n2##x,_p1##y,z,v)), \

    (I[26] = (img)(_n2##x,y,z,v)), \

    (I[33] = (img)(_n2##x,_n1##y,z,v)), \

    (I[40] = (img)(_n2##x,_n2##y,z,v)), \

    (I[47] = (img)(_n2##x,_n3##y,z,v)), \

    3>=(img).width?(int)((img).width)-1:3); \

    (_n3##x<(int)((img).width) && ( \

    (I[6] = (img)(_n3##x,_p3##y,z,v)), \

    (I[13] = (img)(_n3##x,_p2##y,z,v)), \

    (I[20] = (img)(_n3##x,_p1##y,z,v)), \

    (I[27] = (img)(_n3##x,y,z,v)), \

    (I[34] = (img)(_n3##x,_n1##y,z,v)), \

    (I[41] = (img)(_n3##x,_n2##y,z,v)), \

    (I[48] = (img)(_n3##x,_n3##y,z,v)),1)) || \

    _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3##x = _n2##x = --_n1##x); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], I[5] = I[6], \

    I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], I[11] = I[12], I[12] = I[13], \

    I[14] = I[15], I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], I[19] = I[20], \

    I[21] = I[22], I[22] = I[23], I[23] = I[24], I[24] = I[25], I[25] = I[26], I[26] = I[27], \

    I[28] = I[29], I[29] = I[30], I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], \

    I[35] = I[36], I[36] = I[37], I[37] = I[38], I[38] = I[39], I[39] = I[40], I[40] = I[41], \

    I[42] = I[43], I[43] = I[44], I[44] = I[45], I[45] = I[46], I[46] = I[47], I[47] = I[48], \

    _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)


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

   cimg_for_in7((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \

    _p3##x = x-3<0?0:x-3, \

    _p2##x = x-2<0?0:x-2, \

    _p1##x = x-1<0?0:x-1, \

    _n1##x = x+1>=(int)(img).width?(int)((img).width)-1:x+1, \

    _n2##x = x+2>=(int)(img).width?(int)((img).width)-1:x+2, \

    _n3##x = (int)( \

    (I[0] = (img)(_p3##x,_p3##y,z,v)), \

    (I[7] = (img)(_p3##x,_p2##y,z,v)), \

    (I[14] = (img)(_p3##x,_p1##y,z,v)), \

    (I[21] = (img)(_p3##x,y,z,v)), \

    (I[28] = (img)(_p3##x,_n1##y,z,v)), \

    (I[35] = (img)(_p3##x,_n2##y,z,v)), \

    (I[42] = (img)(_p3##x,_n3##y,z,v)), \

    (I[1] = (img)(_p2##x,_p3##y,z,v)), \

    (I[8] = (img)(_p2##x,_p2##y,z,v)), \

    (I[15] = (img)(_p2##x,_p1##y,z,v)), \

    (I[22] = (img)(_p2##x,y,z,v)), \

    (I[29] = (img)(_p2##x,_n1##y,z,v)), \

    (I[36] = (img)(_p2##x,_n2##y,z,v)), \

    (I[43] = (img)(_p2##x,_n3##y,z,v)), \

    (I[2] = (img)(_p1##x,_p3##y,z,v)), \

    (I[9] = (img)(_p1##x,_p2##y,z,v)), \

    (I[16] = (img)(_p1##x,_p1##y,z,v)), \

    (I[23] = (img)(_p1##x,y,z,v)), \

    (I[30] = (img)(_p1##x,_n1##y,z,v)), \

    (I[37] = (img)(_p1##x,_n2##y,z,v)), \

    (I[44] = (img)(_p1##x,_n3##y,z,v)), \

    (I[3] = (img)(x,_p3##y,z,v)), \

    (I[10] = (img)(x,_p2##y,z,v)), \

    (I[17] = (img)(x,_p1##y,z,v)), \

    (I[24] = (img)(x,y,z,v)), \

    (I[31] = (img)(x,_n1##y,z,v)), \

    (I[38] = (img)(x,_n2##y,z,v)), \

    (I[45] = (img)(x,_n3##y,z,v)), \

    (I[4] = (img)(_n1##x,_p3##y,z,v)), \

    (I[11] = (img)(_n1##x,_p2##y,z,v)), \

    (I[18] = (img)(_n1##x,_p1##y,z,v)), \

    (I[25] = (img)(_n1##x,y,z,v)), \

    (I[32] = (img)(_n1##x,_n1##y,z,v)), \

    (I[39] = (img)(_n1##x,_n2##y,z,v)), \

    (I[46] = (img)(_n1##x,_n3##y,z,v)), \

    (I[5] = (img)(_n2##x,_p3##y,z,v)), \

    (I[12] = (img)(_n2##x,_p2##y,z,v)), \

    (I[19] = (img)(_n2##x,_p1##y,z,v)), \

    (I[26] = (img)(_n2##x,y,z,v)), \

    (I[33] = (img)(_n2##x,_n1##y,z,v)), \

    (I[40] = (img)(_n2##x,_n2##y,z,v)), \

    (I[47] = (img)(_n2##x,_n3##y,z,v)), \

    x+3>=(int)(img).width?(int)((img).width)-1:x+3); \

    x<=(int)(x1) && ((_n3##x<(int)((img).width) && ( \

    (I[6] = (img)(_n3##x,_p3##y,z,v)), \

    (I[13] = (img)(_n3##x,_p2##y,z,v)), \

    (I[20] = (img)(_n3##x,_p1##y,z,v)), \

    (I[27] = (img)(_n3##x,y,z,v)), \

    (I[34] = (img)(_n3##x,_n1##y,z,v)), \

    (I[41] = (img)(_n3##x,_n2##y,z,v)), \

    (I[48] = (img)(_n3##x,_n3##y,z,v)),1)) || \

    _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3##x = _n2##x = --_n1##x)); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], I[5] = I[6], \

    I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], I[11] = I[12], I[12] = I[13], \

    I[14] = I[15], I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], I[19] = I[20], \

    I[21] = I[22], I[22] = I[23], I[23] = I[24], I[24] = I[25], I[25] = I[26], I[26] = I[27], \

    I[28] = I[29], I[29] = I[30], I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], \

    I[35] = I[36], I[36] = I[37], I[37] = I[38], I[38] = I[39], I[39] = I[40], I[40] = I[41], \

    I[42] = I[43], I[43] = I[44], I[44] = I[45], I[45] = I[46], I[46] = I[47], I[47] = I[48], \

    _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)


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

   cimg_for8((img).height,y) for (int x = 0, \

    _p3##x = 0, _p2##x = 0, _p1##x = 0, \

    _n1##x = 1>=((img).width)?(int)((img).width)-1:1, \

    _n2##x = 2>=((img).width)?(int)((img).width)-1:2, \

    _n3##x = 3>=((img).width)?(int)((img).width)-1:3, \

    _n4##x = (int)( \

    (I[0] = I[1] = I[2] = I[3] = (img)(0,_p3##y,z,v)), \

    (I[8] = I[9] = I[10] = I[11] = (img)(0,_p2##y,z,v)), \

    (I[16] = I[17] = I[18] = I[19] = (img)(0,_p1##y,z,v)), \

    (I[24] = I[25] = I[26] = I[27] = (img)(0,y,z,v)), \

    (I[32] = I[33] = I[34] = I[35] = (img)(0,_n1##y,z,v)), \

    (I[40] = I[41] = I[42] = I[43] = (img)(0,_n2##y,z,v)), \

    (I[48] = I[49] = I[50] = I[51] = (img)(0,_n3##y,z,v)), \

    (I[56] = I[57] = I[58] = I[59] = (img)(0,_n4##y,z,v)), \

    (I[4] = (img)(_n1##x,_p3##y,z,v)), \

    (I[12] = (img)(_n1##x,_p2##y,z,v)), \

    (I[20] = (img)(_n1##x,_p1##y,z,v)), \

    (I[28] = (img)(_n1##x,y,z,v)), \

    (I[36] = (img)(_n1##x,_n1##y,z,v)), \

    (I[44] = (img)(_n1##x,_n2##y,z,v)), \

    (I[52] = (img)(_n1##x,_n3##y,z,v)), \

    (I[60] = (img)(_n1##x,_n4##y,z,v)), \

    (I[5] = (img)(_n2##x,_p3##y,z,v)), \

    (I[13] = (img)(_n2##x,_p2##y,z,v)), \

    (I[21] = (img)(_n2##x,_p1##y,z,v)), \

    (I[29] = (img)(_n2##x,y,z,v)), \

    (I[37] = (img)(_n2##x,_n1##y,z,v)), \

    (I[45] = (img)(_n2##x,_n2##y,z,v)), \

    (I[53] = (img)(_n2##x,_n3##y,z,v)), \

    (I[61] = (img)(_n2##x,_n4##y,z,v)), \

    (I[6] = (img)(_n3##x,_p3##y,z,v)), \

    (I[14] = (img)(_n3##x,_p2##y,z,v)), \

    (I[22] = (img)(_n3##x,_p1##y,z,v)), \

    (I[30] = (img)(_n3##x,y,z,v)), \

    (I[38] = (img)(_n3##x,_n1##y,z,v)), \

    (I[46] = (img)(_n3##x,_n2##y,z,v)), \

    (I[54] = (img)(_n3##x,_n3##y,z,v)), \

    (I[62] = (img)(_n3##x,_n4##y,z,v)), \

    4>=((img).width)?(int)((img).width)-1:4); \

    (_n4##x<(int)((img).width) && ( \

    (I[7] = (img)(_n4##x,_p3##y,z,v)), \

    (I[15] = (img)(_n4##x,_p2##y,z,v)), \

    (I[23] = (img)(_n4##x,_p1##y,z,v)), \

    (I[31] = (img)(_n4##x,y,z,v)), \

    (I[39] = (img)(_n4##x,_n1##y,z,v)), \

    (I[47] = (img)(_n4##x,_n2##y,z,v)), \

    (I[55] = (img)(_n4##x,_n3##y,z,v)), \

    (I[63] = (img)(_n4##x,_n4##y,z,v)),1)) || \

    _n3##x==--_n4##x || _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n4##x = _n3##x = _n2##x = --_n1##x); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], 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[11] = I[12], I[12] = I[13], I[13] = I[14], I[14] = I[15], \

    I[16] = I[17], I[17] = I[18], I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \

    I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], I[29] = I[30], I[30] = I[31], \

    I[32] = I[33], I[33] = I[34], I[34] = I[35], I[35] = I[36], I[36] = I[37], I[37] = I[38], I[38] = I[39], \

    I[40] = I[41], I[41] = I[42], I[42] = I[43], I[43] = I[44], I[44] = I[45], I[45] = I[46], I[46] = I[47], \

    I[48] = I[49], I[49] = I[50], I[50] = I[51], I[51] = I[52], I[52] = I[53], I[53] = I[54], I[54] = I[55], \

    I[56] = I[57], I[57] = I[58], I[58] = I[59], I[59] = I[60], I[60] = I[61], I[61] = I[62], I[62] = I[63], \

    _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x, ++_n4##x)


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

   cimg_for_in8((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \

    _p3##x = x-3<0?0:x-3, \

    _p2##x = x-2<0?0:x-2, \

    _p1##x = x-1<0?0:x-1, \

    _n1##x = x+1>=(int)((img).width)?(int)((img).width)-1:x+1, \

    _n2##x = x+2>=(int)((img).width)?(int)((img).width)-1:x+2, \

    _n3##x = x+3>=(int)((img).width)?(int)((img).width)-1:x+3, \

    _n4##x = (int)( \

    (I[0] = (img)(_p3##x,_p3##y,z,v)), \

    (I[8] = (img)(_p3##x,_p2##y,z,v)), \

    (I[16] = (img)(_p3##x,_p1##y,z,v)), \

    (I[24] = (img)(_p3##x,y,z,v)), \

    (I[32] = (img)(_p3##x,_n1##y,z,v)), \

    (I[40] = (img)(_p3##x,_n2##y,z,v)), \

    (I[48] = (img)(_p3##x,_n3##y,z,v)), \

    (I[56] = (img)(_p3##x,_n4##y,z,v)), \

    (I[1] = (img)(_p2##x,_p3##y,z,v)), \

    (I[9] = (img)(_p2##x,_p2##y,z,v)), \

    (I[17] = (img)(_p2##x,_p1##y,z,v)), \

    (I[25] = (img)(_p2##x,y,z,v)), \

    (I[33] = (img)(_p2##x,_n1##y,z,v)), \

    (I[41] = (img)(_p2##x,_n2##y,z,v)), \

    (I[49] = (img)(_p2##x,_n3##y,z,v)), \

    (I[57] = (img)(_p2##x,_n4##y,z,v)), \

    (I[2] = (img)(_p1##x,_p3##y,z,v)), \

    (I[10] = (img)(_p1##x,_p2##y,z,v)), \

    (I[18] = (img)(_p1##x,_p1##y,z,v)), \

    (I[26] = (img)(_p1##x,y,z,v)), \

    (I[34] = (img)(_p1##x,_n1##y,z,v)), \

    (I[42] = (img)(_p1##x,_n2##y,z,v)), \

    (I[50] = (img)(_p1##x,_n3##y,z,v)), \

    (I[58] = (img)(_p1##x,_n4##y,z,v)), \

    (I[3] = (img)(x,_p3##y,z,v)), \

    (I[11] = (img)(x,_p2##y,z,v)), \

    (I[19] = (img)(x,_p1##y,z,v)), \

    (I[27] = (img)(x,y,z,v)), \

    (I[35] = (img)(x,_n1##y,z,v)), \

    (I[43] = (img)(x,_n2##y,z,v)), \

    (I[51] = (img)(x,_n3##y,z,v)), \

    (I[59] = (img)(x,_n4##y,z,v)), \

    (I[4] = (img)(_n1##x,_p3##y,z,v)), \

    (I[12] = (img)(_n1##x,_p2##y,z,v)), \

    (I[20] = (img)(_n1##x,_p1##y,z,v)), \

    (I[28] = (img)(_n1##x,y,z,v)), \

    (I[36] = (img)(_n1##x,_n1##y,z,v)), \

    (I[44] = (img)(_n1##x,_n2##y,z,v)), \

    (I[52] = (img)(_n1##x,_n3##y,z,v)), \

    (I[60] = (img)(_n1##x,_n4##y,z,v)), \

    (I[5] = (img)(_n2##x,_p3##y,z,v)), \

    (I[13] = (img)(_n2##x,_p2##y,z,v)), \

    (I[21] = (img)(_n2##x,_p1##y,z,v)), \

    (I[29] = (img)(_n2##x,y,z,v)), \

    (I[37] = (img)(_n2##x,_n1##y,z,v)), \

    (I[45] = (img)(_n2##x,_n2##y,z,v)), \

    (I[53] = (img)(_n2##x,_n3##y,z,v)), \

    (I[61] = (img)(_n2##x,_n4##y,z,v)), \

    (I[6] = (img)(_n3##x,_p3##y,z,v)), \

    (I[14] = (img)(_n3##x,_p2##y,z,v)), \

    (I[22] = (img)(_n3##x,_p1##y,z,v)), \

    (I[30] = (img)(_n3##x,y,z,v)), \

    (I[38] = (img)(_n3##x,_n1##y,z,v)), \

    (I[46] = (img)(_n3##x,_n2##y,z,v)), \

    (I[54] = (img)(_n3##x,_n3##y,z,v)), \

    (I[62] = (img)(_n3##x,_n4##y,z,v)), \

    x+4>=(int)((img).width)?(int)((img).width)-1:x+4); \

    x<=(int)(x1) && ((_n4##x<(int)((img).width) && ( \

    (I[7] = (img)(_n4##x,_p3##y,z,v)), \

    (I[15] = (img)(_n4##x,_p2##y,z,v)), \

    (I[23] = (img)(_n4##x,_p1##y,z,v)), \

    (I[31] = (img)(_n4##x,y,z,v)), \

    (I[39] = (img)(_n4##x,_n1##y,z,v)), \

    (I[47] = (img)(_n4##x,_n2##y,z,v)), \

    (I[55] = (img)(_n4##x,_n3##y,z,v)), \

    (I[63] = (img)(_n4##x,_n4##y,z,v)),1)) || \

    _n3##x==--_n4##x || _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n4##x = _n3##x = _n2##x = --_n1##x)); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], 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[11] = I[12], I[12] = I[13], I[13] = I[14], I[14] = I[15], \

    I[16] = I[17], I[17] = I[18], I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \

    I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], I[29] = I[30], I[30] = I[31], \

    I[32] = I[33], I[33] = I[34], I[34] = I[35], I[35] = I[36], I[36] = I[37], I[37] = I[38], I[38] = I[39], \

    I[40] = I[41], I[41] = I[42], I[42] = I[43], I[43] = I[44], I[44] = I[45], I[45] = I[46], I[46] = I[47], \

    I[48] = I[49], I[49] = I[50], I[50] = I[51], I[51] = I[52], I[52] = I[53], I[53] = I[54], I[54] = I[55], \

    I[56] = I[57], I[57] = I[58], I[58] = I[59], I[59] = I[60], I[60] = I[61], I[61] = I[62], I[62] = I[63], \

    _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x, ++_n4##x)


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

   cimg_for9((img).height,y) for (int x = 0, \

    _p4##x = 0, _p3##x = 0, _p2##x = 0, _p1##x = 0, \

    _n1##x = 1>=((img).width)?(int)((img).width)-1:1, \

    _n2##x = 2>=((img).width)?(int)((img).width)-1:2, \

    _n3##x = 3>=((img).width)?(int)((img).width)-1:3, \

    _n4##x = (int)( \

    (I[0] = I[1] = I[2] = I[3] = I[4] = (img)(0,_p4##y,z,v)), \

    (I[9] = I[10] = I[11] = I[12] = I[13] = (img)(0,_p3##y,z,v)), \

    (I[18] = I[19] = I[20] = I[21] = I[22] = (img)(0,_p2##y,z,v)), \

    (I[27] = I[28] = I[29] = I[30] = I[31] = (img)(0,_p1##y,z,v)), \

    (I[36] = I[37] = I[38] = I[39] = I[40] = (img)(0,y,z,v)), \

    (I[45] = I[46] = I[47] = I[48] = I[49] = (img)(0,_n1##y,z,v)), \

    (I[54] = I[55] = I[56] = I[57] = I[58] = (img)(0,_n2##y,z,v)), \

    (I[63] = I[64] = I[65] = I[66] = I[67] = (img)(0,_n3##y,z,v)), \

    (I[72] = I[73] = I[74] = I[75] = I[76] = (img)(0,_n4##y,z,v)), \

    (I[5] = (img)(_n1##x,_p4##y,z,v)), \

    (I[14] = (img)(_n1##x,_p3##y,z,v)), \

    (I[23] = (img)(_n1##x,_p2##y,z,v)), \

    (I[32] = (img)(_n1##x,_p1##y,z,v)), \

    (I[41] = (img)(_n1##x,y,z,v)), \

    (I[50] = (img)(_n1##x,_n1##y,z,v)), \

    (I[59] = (img)(_n1##x,_n2##y,z,v)), \

    (I[68] = (img)(_n1##x,_n3##y,z,v)), \

    (I[77] = (img)(_n1##x,_n4##y,z,v)), \

    (I[6] = (img)(_n2##x,_p4##y,z,v)), \

    (I[15] = (img)(_n2##x,_p3##y,z,v)), \

    (I[24] = (img)(_n2##x,_p2##y,z,v)), \

    (I[33] = (img)(_n2##x,_p1##y,z,v)), \

    (I[42] = (img)(_n2##x,y,z,v)), \

    (I[51] = (img)(_n2##x,_n1##y,z,v)), \

    (I[60] = (img)(_n2##x,_n2##y,z,v)), \

    (I[69] = (img)(_n2##x,_n3##y,z,v)), \

    (I[78] = (img)(_n2##x,_n4##y,z,v)), \

    (I[7] = (img)(_n3##x,_p4##y,z,v)), \

    (I[16] = (img)(_n3##x,_p3##y,z,v)), \

    (I[25] = (img)(_n3##x,_p2##y,z,v)), \

    (I[34] = (img)(_n3##x,_p1##y,z,v)), \

    (I[43] = (img)(_n3##x,y,z,v)), \

    (I[52] = (img)(_n3##x,_n1##y,z,v)), \

    (I[61] = (img)(_n3##x,_n2##y,z,v)), \

    (I[70] = (img)(_n3##x,_n3##y,z,v)), \

    (I[79] = (img)(_n3##x,_n4##y,z,v)), \

    4>=((img).width)?(int)((img).width)-1:4); \

    (_n4##x<(int)((img).width) && ( \

    (I[8] = (img)(_n4##x,_p4##y,z,v)), \

    (I[17] = (img)(_n4##x,_p3##y,z,v)), \

    (I[26] = (img)(_n4##x,_p2##y,z,v)), \

    (I[35] = (img)(_n4##x,_p1##y,z,v)), \

    (I[44] = (img)(_n4##x,y,z,v)), \

    (I[53] = (img)(_n4##x,_n1##y,z,v)), \

    (I[62] = (img)(_n4##x,_n2##y,z,v)), \

    (I[71] = (img)(_n4##x,_n3##y,z,v)), \

    (I[80] = (img)(_n4##x,_n4##y,z,v)),1)) || \

    _n3##x==--_n4##x || _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n4##x = _n3##x = _n2##x = --_n1##x); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], I[5] = I[6], I[6] = I[7], I[7] = I[8], \

    I[9] = I[10], I[10] = I[11], I[11] = I[12], I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \

    I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], I[23] = I[24], I[24] = I[25], I[25] = I[26], \

    I[27] = I[28], I[28] = I[29], I[29] = I[30], I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \

    I[36] = I[37], I[37] = I[38], I[38] = I[39], I[39] = I[40], I[40] = I[41], I[41] = I[42], I[42] = I[43], I[43] = I[44], \

    I[45] = I[46], I[46] = I[47], I[47] = I[48], I[48] = I[49], I[49] = I[50], I[50] = I[51], I[51] = I[52], I[52] = I[53], \

    I[54] = I[55], I[55] = I[56], I[56] = I[57], I[57] = I[58], I[58] = I[59], I[59] = I[60], I[60] = I[61], I[61] = I[62], \

    I[63] = I[64], I[64] = I[65], I[65] = I[66], I[66] = I[67], I[67] = I[68], I[68] = I[69], I[69] = I[70], I[70] = I[71], \

    I[72] = I[73], I[73] = I[74], I[74] = I[75], I[75] = I[76], I[76] = I[77], I[77] = I[78], I[78] = I[79], I[79] = I[80], \

    _p4##x = _p3##x, _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x, ++_n4##x)


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

   cimg_for_in9((img).height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \

    _p4##x = x-4<0?0:x-4, \

    _p3##x = x-3<0?0:x-3, \

    _p2##x = x-2<0?0:x-2, \

    _p1##x = x-1<0?0:x-1, \

    _n1##x = x+1>=(int)((img).width)?(int)((img).width)-1:x+1, \

    _n2##x = x+2>=(int)((img).width)?(int)((img).width)-1:x+2, \

    _n3##x = x+3>=(int)((img).width)?(int)((img).width)-1:x+3, \

    _n4##x = (int)( \

    (I[0] = (img)(_p4##x,_p4##y,z,v)), \

    (I[9] = (img)(_p4##x,_p3##y,z,v)), \

    (I[18] = (img)(_p4##x,_p2##y,z,v)), \

    (I[27] = (img)(_p4##x,_p1##y,z,v)), \

    (I[36] = (img)(_p4##x,y,z,v)), \

    (I[45] = (img)(_p4##x,_n1##y,z,v)), \

    (I[54] = (img)(_p4##x,_n2##y,z,v)), \

    (I[63] = (img)(_p4##x,_n3##y,z,v)), \

    (I[72] = (img)(_p4##x,_n4##y,z,v)), \

    (I[1] = (img)(_p3##x,_p4##y,z,v)), \

    (I[10] = (img)(_p3##x,_p3##y,z,v)), \

    (I[19] = (img)(_p3##x,_p2##y,z,v)), \

    (I[28] = (img)(_p3##x,_p1##y,z,v)), \

    (I[37] = (img)(_p3##x,y,z,v)), \

    (I[46] = (img)(_p3##x,_n1##y,z,v)), \

    (I[55] = (img)(_p3##x,_n2##y,z,v)), \

    (I[64] = (img)(_p3##x,_n3##y,z,v)), \

    (I[73] = (img)(_p3##x,_n4##y,z,v)), \

    (I[2] = (img)(_p2##x,_p4##y,z,v)), \

    (I[11] = (img)(_p2##x,_p3##y,z,v)), \

    (I[20] = (img)(_p2##x,_p2##y,z,v)), \

    (I[29] = (img)(_p2##x,_p1##y,z,v)), \

    (I[38] = (img)(_p2##x,y,z,v)), \

    (I[47] = (img)(_p2##x,_n1##y,z,v)), \

    (I[56] = (img)(_p2##x,_n2##y,z,v)), \

    (I[65] = (img)(_p2##x,_n3##y,z,v)), \

    (I[74] = (img)(_p2##x,_n4##y,z,v)), \

    (I[3] = (img)(_p1##x,_p4##y,z,v)), \

    (I[12] = (img)(_p1##x,_p3##y,z,v)), \

    (I[21] = (img)(_p1##x,_p2##y,z,v)), \

    (I[30] = (img)(_p1##x,_p1##y,z,v)), \

    (I[39] = (img)(_p1##x,y,z,v)), \

    (I[48] = (img)(_p1##x,_n1##y,z,v)), \

    (I[57] = (img)(_p1##x,_n2##y,z,v)), \

    (I[66] = (img)(_p1##x,_n3##y,z,v)), \

    (I[75] = (img)(_p1##x,_n4##y,z,v)), \

    (I[4] = (img)(x,_p4##y,z,v)), \

    (I[13] = (img)(x,_p3##y,z,v)), \

    (I[22] = (img)(x,_p2##y,z,v)), \

    (I[31] = (img)(x,_p1##y,z,v)), \

    (I[40] = (img)(x,y,z,v)), \

    (I[49] = (img)(x,_n1##y,z,v)), \

    (I[58] = (img)(x,_n2##y,z,v)), \

    (I[67] = (img)(x,_n3##y,z,v)), \

    (I[76] = (img)(x,_n4##y,z,v)), \

    (I[5] = (img)(_n1##x,_p4##y,z,v)), \

    (I[14] = (img)(_n1##x,_p3##y,z,v)), \

    (I[23] = (img)(_n1##x,_p2##y,z,v)), \

    (I[32] = (img)(_n1##x,_p1##y,z,v)), \

    (I[41] = (img)(_n1##x,y,z,v)), \

    (I[50] = (img)(_n1##x,_n1##y,z,v)), \

    (I[59] = (img)(_n1##x,_n2##y,z,v)), \

    (I[68] = (img)(_n1##x,_n3##y,z,v)), \

    (I[77] = (img)(_n1##x,_n4##y,z,v)), \

    (I[6] = (img)(_n2##x,_p4##y,z,v)), \

    (I[15] = (img)(_n2##x,_p3##y,z,v)), \

    (I[24] = (img)(_n2##x,_p2##y,z,v)), \

    (I[33] = (img)(_n2##x,_p1##y,z,v)), \

    (I[42] = (img)(_n2##x,y,z,v)), \

    (I[51] = (img)(_n2##x,_n1##y,z,v)), \

    (I[60] = (img)(_n2##x,_n2##y,z,v)), \

    (I[69] = (img)(_n2##x,_n3##y,z,v)), \

    (I[78] = (img)(_n2##x,_n4##y,z,v)), \

    (I[7] = (img)(_n3##x,_p4##y,z,v)), \

    (I[16] = (img)(_n3##x,_p3##y,z,v)), \

    (I[25] = (img)(_n3##x,_p2##y,z,v)), \

    (I[34] = (img)(_n3##x,_p1##y,z,v)), \

    (I[43] = (img)(_n3##x,y,z,v)), \

    (I[52] = (img)(_n3##x,_n1##y,z,v)), \

    (I[61] = (img)(_n3##x,_n2##y,z,v)), \

    (I[70] = (img)(_n3##x,_n3##y,z,v)), \

    (I[79] = (img)(_n3##x,_n4##y,z,v)), \

    x+4>=(int)((img).width)?(int)((img).width)-1:x+4); \

    x<=(int)(x1) && ((_n4##x<(int)((img).width) && ( \

    (I[8] = (img)(_n4##x,_p4##y,z,v)), \

    (I[17] = (img)(_n4##x,_p3##y,z,v)), \

    (I[26] = (img)(_n4##x,_p2##y,z,v)), \

    (I[35] = (img)(_n4##x,_p1##y,z,v)), \

    (I[44] = (img)(_n4##x,y,z,v)), \

    (I[53] = (img)(_n4##x,_n1##y,z,v)), \

    (I[62] = (img)(_n4##x,_n2##y,z,v)), \

    (I[71] = (img)(_n4##x,_n3##y,z,v)), \

    (I[80] = (img)(_n4##x,_n4##y,z,v)),1)) || \

    _n3##x==--_n4##x || _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n4##x = _n3##x = _n2##x = --_n1##x)); \

    I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], I[5] = I[6], I[6] = I[7], I[7] = I[8], \

    I[9] = I[10], I[10] = I[11], I[11] = I[12], I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \

    I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], I[23] = I[24], I[24] = I[25], I[25] = I[26], \

    I[27] = I[28], I[28] = I[29], I[29] = I[30], I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \

    I[36] = I[37], I[37] = I[38], I[38] = I[39], I[39] = I[40], I[40] = I[41], I[41] = I[42], I[42] = I[43], I[43] = I[44], \

    I[45] = I[46], I[46] = I[47], I[47] = I[48], I[48] = I[49], I[49] = I[50], I[50] = I[51], I[51] = I[52], I[52] = I[53], \

    I[54] = I[55], I[55] = I[56], I[56] = I[57], I[57] = I[58], I[58] = I[59], I[59] = I[60], I[60] = I[61], I[61] = I[62], \

    I[63] = I[64], I[64] = I[65], I[65] = I[66], I[66] = I[67], I[67] = I[68], I[68] = I[69], I[69] = I[70], I[70] = I[71], \

    I[72] = I[73], I[73] = I[74], I[74] = I[75], I[75] = I[76], I[76] = I[77], I[77] = I[78], I[78] = I[79], I[79] = I[80], \

    _p4##x = _p3##x, _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x, ++_n4##x)


 #define cimg_for2x2x2(img,x,y,z,v,I) \

  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)


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

  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)


 #define cimg_for3x3x3(img,x,y,z,v,I) \

  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)


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

  cimg_for_in3((img).depth,z0,z1,z) 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,_p1##z,v)), \

    (I[3] = (img)(_p1##x,y,_p1##z,v)),  \

    (I[6] = (img)(_p1##x,_n1##y,_p1##z,v)), \

    (I[9] = (img)(_p1##x,_p1##y,z,v)), \

    (I[12] = (img)(_p1##x,y,z,v)), \

    (I[15] = (img)(_p1##x,_n1##y,z,v)), \

    (I[18] = (img)(_p1##x,_p1##y,_n1##z,v)), \

    (I[21] = (img)(_p1##x,y,_n1##z,v)), \

    (I[24] = (img)(_p1##x,_n1##y,_n1##z,v)), \

    (I[1] = (img)(x,_p1##y,_p1##z,v)), \

    (I[4] = (img)(x,y,_p1##z,v)),  \

    (I[7] = (img)(x,_n1##y,_p1##z,v)), \

    (I[10] = (img)(x,_p1##y,z,v)), \

    (I[13] = (img)(x,y,z,v)), \

    (I[16] = (img)(x,_n1##y,z,v)), \

    (I[19] = (img)(x,_p1##y,_n1##z,v)), \

    (I[22] = (img)(x,y,_n1##z,v)), \

    (I[25] = (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[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)


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

 #define cimglist_for_in(list,l0,l1,l) \

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


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


 /*------------------------------------------------

  #

  #

  #  Definition of the cimg_library:: namespace

  #

  #

  -------------------------------------------------*/


 namespace cimg_library {


   // Declare the only four classes of the CImg Library.

   template<typename T=float> struct CImg;

   template<typename T=float> struct CImgList;

   struct CImgDisplay;

   struct CImgException;


   // (Pre)declare the cimg namespace.

   // This is not the complete namespace declaration. It only contains some

   // necessary stuffs to ensure a correct declaration order of classes and functions

   // defined afterwards.

   namespace cimg {


 #ifdef cimg_use_vt100

     const char t_normal[] = { 0x1b, '[', '0', ';', '0', ';', '0', 'm', 0 };

     const char t_red[] = { 0x1b, '[', '4', ';', '3', '1', ';', '5', '9', 'm', 0 };

     const char t_bold[] = { 0x1b, '[', '1', 'm', 0 };

     const char t_purple[] = { 0x1b, '[', '0', ';', '3', '5', ';', '5', '9', 'm', 0 };

     const char t_green[] = { 0x1b, '[', '0', ';', '3', '2', ';', '5', '9', 'm', 0 };

 #else

     const char t_normal[] = { 0 };

     const char *const t_red = cimg::t_normal, *const t_bold = cimg::t_normal,

       *const t_purple = cimg::t_normal, *const t_green = cimg::t_normal;

 #endif


     inline void info();


     inline unsigned int& exception_mode() { static unsigned int mode = cimg_debug; return mode; }


     inline int dialog(const char *title, const char *msg, const char *button1_txt="OK",

                       const char *button2_txt=0, const char *button3_txt=0,

                       const char *button4_txt=0, const char *button5_txt=0,

                       const char *button6_txt=0, const bool centering=false);


     inline double eval(const char *const expression, const double x=0, const double y=0, const double z=0, const double v=0);

   }


   /*----------------------------------------------

    #

    # Definition of the CImgException structures

    #

    ----------------------------------------------*/


   struct CImgException {

 #define _cimg_exception_err(etype,disp_flag) \

   std::va_list ap; va_start(ap,format); std::vsprintf(message,format,ap); va_end(ap); \

   switch (cimg::exception_mode()) { \

   case 0 : break; \

   case 2 : case 4 : try { cimg::dialog(etype,message,"Abort"); } catch (CImgException&) { \

     std::fprintf(cimg_stdout,"\n%s# %s%s :\n%s\n\n",cimg::t_red,etype,cimg::t_normal,message); \

   } break; \

   default : std::fprintf(cimg_stdout,"\n%s# %s%s :\n%s\n\n",cimg::t_red,etype,cimg::t_normal,message); \

   } \

   if (cimg::exception_mode()>=3) cimg_library::cimg::info();


     char message[16384];

     CImgException() { message[0] = 0; }

     CImgException(const char *format, ...) { _cimg_exception_err("CImgException",true); }

   };


   // The \ref CImgInstanceException class is used to throw an exception related

   // to a non suitable instance encountered in a library function call.

   struct CImgInstanceException: public CImgException {

     CImgInstanceException(const char *format, ...) { _cimg_exception_err("CImgInstanceException",true); }

   };


   // The \ref CImgArgumentException class is used to throw an exception related

   // to invalid arguments encountered in a library function call.

   struct CImgArgumentException: public CImgException {

     CImgArgumentException(const char *format, ...) { _cimg_exception_err("CImgArgumentException",true); }

   };


   // The \ref CImgIOException class is used to throw an exception related

   // to Input/Output file problems encountered in a library function call.

   struct CImgIOException: public CImgException {

     CImgIOException(const char *format, ...) { _cimg_exception_err("CImgIOException",true); }

   };


   // The CImgDisplayException class is used to throw an exception related to display problems

   // encountered in a library function call.

   struct CImgDisplayException: public CImgException {

     CImgDisplayException(const char *format, ...) { _cimg_exception_err("CImgDisplayException",false); }

   };


   // The CImgWarningException class is used to throw an exception for warnings

   // encountered in a library function call.

   struct CImgWarningException: public CImgException {

     CImgWarningException(const char *format, ...) { _cimg_exception_err("CImgWarningException",false); }

   };


   /*-------------------------------------

    #

    # Definition of the namespace 'cimg'

    #

    --------------------------------------*/


   namespace cimg {


     // Define the traits that will be used to determine the best data type to work with.

     //

     template<typename T> struct type {

       static const char* string() {

         static const char* s[] = { "unknown",   "unknown8",   "unknown16",  "unknown24",

                                    "unknown32", "unknown40",  "unknown48",  "unknown56",

                                    "unknown64", "unknown72",  "unknown80",  "unknown88",

                                    "unknown96", "unknown104", "unknown112", "unknown120",

                                    "unknown128" };

         return s[(sizeof(T)<17)?sizeof(T):0];

       }

       static bool is_float() { return false; }

       static T min() { return (T)-1>0?(T)0:(T)-1<<(8*sizeof(T)-1); }

       static T max() { return (T)-1>0?(T)-1:~((T)-1<<(8*sizeof(T)-1)); }

       static const char* format() { return "%s"; }

       static const char* format(const T val) { static const char *s = "unknown"; return s; }

     };


     template<> struct type<bool> {

       static const char* string() { static const char *const s = "bool"; return s; }

       static bool is_float() { return false; }

       static bool min() { return false; }

       static bool max() { return true; }

       static const char* format() { return "%s"; }

       static const char* format(const bool val) { static const char* s[] = { "false", "true" }; return s[val?1:0]; }

     };


     template<> struct type<unsigned char> {

       static const char* string() { static const char *const s = "unsigned char"; return s; }

       static bool is_float() { return false; }

       static unsigned char min() { return 0; }

       static unsigned char max() { return (unsigned char)~0U; }

       static const char* format() { return "%u"; }

       static unsigned int format(const unsigned char val) { return (unsigned int)val; }

     };


     template<> struct type<char> {

       static const char* string() { static const char *const s = "char"; return s; }

       static bool is_float() { return false; }

       static char min() { return (char)(-1L<<(8*sizeof(char)-1)); }

       static char max() { return ~((char)(-1L<<(8*sizeof(char)-1))); }

       static const char* format() { return "%d"; }

       static int format(const char val) { return (int)val; }

     };


     template<> struct type<signed char> {

       static const char* string() { static const char *const s = "signed char"; return s; }

       static bool is_float() { return false; }

       static signed char min() { return (signed char)(-1L<<(8*sizeof(signed char)-1)); }

       static signed char max() { return ~((signed char)(-1L<<(8*sizeof(signed char)-1))); }

       static const char* format() { return "%d"; }

       static unsigned int format(const signed char val) { return (int)val; }

     };


     template<> struct type<unsigned short> {

       static const char* string() { static const char *const s = "unsigned short"; return s; }

       static bool is_float() { return false; }

       static unsigned short min() { return 0; }

       static unsigned short max() { return (unsigned short)~0U; }

       static const char* format() { return "%u"; }

       static unsigned int format(const unsigned short val) { return (unsigned int)val; }

     };


     template<> struct type<short> {

       static const char* string() { static const char *const s = "short"; return s; }

       static bool is_float() { return false; }

       static short min() { return (short)(-1L<<(8*sizeof(short)-1)); }

       static short max() { return ~((short)(-1L<<(8*sizeof(short)-1))); }

       static const char* format() { return "%d"; }

       static int format(const short val) { return (int)val; }

     };


     template<> struct type<unsigned int> {

       static const char* string() { static const char *const s = "unsigned int"; return s; }

       static bool is_float() { return false; }

       static unsigned int min() { return 0; }

       static unsigned int max() { return (unsigned int)~0U; }

       static const char* format() { return "%u"; }

       static unsigned int format(const unsigned int val) { return val; }

     };


     template<> struct type<int> {

       static const char* string() { static const char *const s = "int"; return s; }

       static bool is_float() { return false; }

       static int min() { return (int)(-1L<<(8*sizeof(int)-1)); }

       static int max() { return ~((int)(-1L<<(8*sizeof(int)-1))); }

       static const char* format() { return "%d"; }

       static int format(const int val) { return val; }

     };


     template<> struct type<unsigned long> {

       static const char* string() { static const char *const s = "unsigned long"; return s; }

       static bool is_float() { return false; }

       static unsigned long min() { return 0; }

       static unsigned long max() { return (unsigned long)~0UL; }

       static const char* format() { return "%lu"; }

       static unsigned long format(const unsigned long val) { return val; }

     };


     template<> struct type<long> {

       static const char* string() { static const char *const s = "long"; return s; }

       static bool is_float() { return false; }

       static long min() { return (long)(-1L<<(8*sizeof(long)-1)); }

       static long max() { return ~((long)(-1L<<(8*sizeof(long)-1))); }

       static const char* format() { return "%ld"; }

       static long format(const long val) { return val; }

     };


     template<> struct type<float> {

       static const char* string() { static const char *const s = "float"; return s; }

       static bool is_float() { return true; }

       static float min() { return -3.4E38f; }

       static float max() { return  3.4E38f; }

       static const char* format() { return "%g"; }

       static double format(const float val) { return (double)val; }

     };


     template<> struct type<double> {

       static const char* string() { static const char *const s = "double"; return s; }

       static bool is_float() { return true; }

       static double min() { return -1.7E308; }

       static double max() { return  1.7E308; }

       static const char* format() { return "%g"; }

       static double format(const double val) { return val; }

     };


     template<typename T, typename t> struct superset { typedef T type; };

     template<> struct superset<bool,unsigned char> { typedef unsigned char type; };

     template<> struct superset<bool,char> { typedef char type; };

     template<> struct superset<bool,signed char> { typedef signed char type; };

     template<> struct superset<bool,unsigned short> { typedef unsigned short type; };

     template<> struct superset<bool,short> { typedef short type; };

     template<> struct superset<bool,unsigned int> { typedef unsigned int type; };

     template<> struct superset<bool,int> { typedef int type; };

     template<> struct superset<bool,unsigned long> { typedef unsigned long type; };

     template<> struct superset<bool,long> { typedef long type; };

     template<> struct superset<bool,float> { typedef float type; };

     template<> struct superset<bool,double> { typedef double type; };

     template<> struct superset<unsigned char,char> { typedef short type; };

     template<> struct superset<unsigned char,signed char> { typedef short type; };

     template<> struct superset<unsigned char,unsigned short> { typedef unsigned short type; };

     template<> struct superset<unsigned char,short> { typedef short type; };

     template<> struct superset<unsigned char,unsigned int> { typedef unsigned int type; };

     template<> struct superset<unsigned char,int> { typedef int type; };

     template<> struct superset<unsigned char,unsigned long> { typedef unsigned long type; };

     template<> struct superset<unsigned char,long> { typedef long type; };

     template<> struct superset<unsigned char,float> { typedef float type; };

     template<> struct superset<unsigned char,double> { typedef double type; };

     template<> struct superset<signed char,unsigned char> { typedef short type; };

     template<> struct superset<signed char,char> { typedef short type; };

     template<> struct superset<signed char,unsigned short> { typedef int type; };

     template<> struct superset<signed char,short> { typedef short type; };

     template<> struct superset<signed char,unsigned int> { typedef long type; };

     template<> struct superset<signed char,int> { typedef int type; };

     template<> struct superset<signed char,unsigned long> { typedef long type; };

     template<> struct superset<signed char,long> { typedef long type; };

     template<> struct superset<signed char,float> { typedef float type; };

     template<> struct superset<signed char,double> { typedef double type; };

     template<> struct superset<char,unsigned char> { typedef short type; };

     template<> struct superset<char,signed char> { typedef short type; };

     template<> struct superset<char,unsigned short> { typedef int type; };

     template<> struct superset<char,short> { typedef short type; };

     template<> struct superset<char,unsigned int> { typedef long type; };

     template<> struct superset<char,int> { typedef int type; };

     template<> struct superset<char,unsigned long> { typedef long type; };

     template<> struct superset<char,long> { typedef long type; };

     template<> struct superset<char,float> { typedef float type; };

     template<> struct superset<char,double> { typedef double type; };

     template<> struct superset<unsigned short,char> { typedef int type; };

     template<> struct superset<unsigned short,signed char> { typedef int type; };

     template<> struct superset<unsigned short,short> { typedef int type; };

     template<> struct superset<unsigned short,unsigned int> { typedef unsigned int type; };

     template<> struct superset<unsigned short,int> { typedef int type; };

     template<> struct superset<unsigned short,unsigned long> { typedef unsigned long type; };

     template<> struct superset<unsigned short,long> { typedef long type; };

     template<> struct superset<unsigned short,float> { typedef float type; };

     template<> struct superset<unsigned short,double> { typedef double type; };

     template<> struct superset<short,unsigned short> { typedef int type; };

     template<> struct superset<short,unsigned int> { typedef long type; };

     template<> struct superset<short,int> { typedef int type; };

     template<> struct superset<short,unsigned long> { typedef long type; };

     template<> struct superset<short,long> { typedef long type; };

     template<> struct superset<short,float> { typedef float type; };

     template<> struct superset<short,double> { typedef double type; };

     template<> struct superset<unsigned int,char> { typedef long type; };

     template<> struct superset<unsigned int,signed char> { typedef long type; };

     template<> struct superset<unsigned int,short> { typedef long type; };

     template<> struct superset<unsigned int,int> { typedef long type; };

     template<> struct superset<unsigned int,unsigned long> { typedef unsigned long type; };

     template<> struct superset<unsigned int,long> { typedef long type; };

     template<> struct superset<unsigned int,float> { typedef float type; };

     template<> struct superset<unsigned int,double> { typedef double type; };

     template<> struct superset<int,unsigned int> { typedef long type; };

     template<> struct superset<int,unsigned long> { typedef long type; };

     template<> struct superset<int,long> { typedef long type; };

     template<> struct superset<int,float> { typedef float type; };

     template<> struct superset<int,double> { typedef double type; };

     template<> struct superset<unsigned long,char> { typedef long type; };

     template<> struct superset<unsigned long,signed char> { typedef long type; };

     template<> struct superset<unsigned long,short> { typedef long type; };

     template<> struct superset<unsigned long,int> { typedef long type; };

     template<> struct superset<unsigned long,long> { typedef long type; };

     template<> struct superset<unsigned long,float> { typedef float type; };

     template<> struct superset<unsigned long,double> { typedef double type; };

     template<> struct superset<long,float> { typedef float type; };

     template<> struct superset<long,double> { typedef double type; };

     template<> struct superset<float,double> { typedef double type; };


     template<typename t1, typename t2, typename t3> struct superset2 {

       typedef typename superset<t1, typename superset<t2,t3>::type>::type type;

     };


     template<typename t1, typename t2, typename t3, typename t4> struct superset3 {

       typedef typename superset<t1, typename superset2<t2,t3,t4>::type>::type type;

     };


     template<typename t1, typename t2> struct last { typedef t2 type; };


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

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

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


     // Define internal library variables.

 #if cimg_display==1

     struct X11info {

       volatile unsigned int nb_wins;

       pthread_t*       event_thread;

       CImgDisplay*     wins[1024];

       Display*         display;

       unsigned int     nb_bits;

       GC*              gc;

       bool             blue_first;

       bool             byte_order;

       bool             shm_enabled;

 #ifdef cimg_use_xrandr

       XRRScreenSize *resolutions;

       Rotation curr_rotation;

       unsigned int curr_resolution;

       unsigned int nb_resolutions;

 #endif

       X11info():nb_wins(0),event_thread(0),display(0),

                 nb_bits(0),gc(0),blue_first(false),byte_order(false),shm_enabled(false) {

 #ifdef cimg_use_xrandr

         resolutions = 0;

         curr_rotation = 0;

         curr_resolution = nb_resolutions = 0;

 #endif

       }

     };

 #if defined(cimg_module)

     X11info& X11attr();

 #elif defined(cimg_main)

     X11info& X11attr() { static X11info val; return val; }

 #else

     inline X11info& X11attr() { static X11info val; return val; }

 #endif


 #elif cimg_display==2

     struct Win32info {

       HANDLE wait_event;

       Win32info() { wait_event = CreateEvent(0,FALSE,FALSE,0); }

     };

 #if defined(cimg_module)

     Win32info& Win32attr();

 #elif defined(cimg_main)

     Win32info& Win32attr() { static Win32info val; return val; }

 #else

     inline Win32info& Win32attr() { static Win32info val; return val; }

 #endif


 #elif cimg_display==3

     struct CarbonInfo {

       MPCriticalRegionID windowListCR; // Protects access to the list of windows

       int windowCount;                 // Count of displays used on the screen

       pthread_t event_thread;          // The background event thread

       MPSemaphoreID sync_event;        // Event used to perform tasks synchronizations

       MPSemaphoreID wait_event;        // Event used to notify that new events occured on the display

       MPQueueID com_queue;             // The message queue

       CarbonInfo(): windowCount(0),event_thread(0),sync_event(0),com_queue(0) {

         if (MPCreateCriticalRegion(&windowListCR) != noErr) // Create the critical region

           throw CImgDisplayException("MPCreateCriticalRegion failed.");

         if (MPCreateSemaphore(1, 0, &sync_event) != noErr) // Create the inter-thread sync object

           throw CImgDisplayException("MPCreateSemaphore failed.");

         if (MPCreateSemaphore(1, 0, &wait_event) != noErr) // Create the event sync object

           throw CImgDisplayException("MPCreateSemaphore failed.");

         if (MPCreateQueue(&com_queue) != noErr) // Create the shared queue

           throw CImgDisplayException("MPCreateQueue failed.");

       }

       ~CarbonInfo() {

         if (event_thread != 0) { // Terminates the resident thread, if needed

           pthread_cancel(event_thread);

           pthread_join(event_thread, NULL);

           event_thread = 0;

         }

         if (MPDeleteCriticalRegion(windowListCR) != noErr) // Delete the critical region

           throw CImgDisplayException("MPDeleteCriticalRegion failed.");

         if (MPDeleteSemaphore(wait_event) != noErr) // Delete the event sync event

           throw CImgDisplayException("MPDeleteEvent failed.");

         if (MPDeleteSemaphore(sync_event) != noErr) // Delete the inter-thread sync event

           throw CImgDisplayException("MPDeleteEvent failed.");

         if (MPDeleteQueue(com_queue) != noErr) // Delete the shared queue

           throw CImgDisplayException("MPDeleteQueue failed.");

       }

     };

 #if defined(cimg_module)

     CarbonInfo& CarbonAttr();

 #elif defined(cimg_main)

     CarbonInfo CarbonAttr() { static CarbonInfo val; return val; }

 #else

     inline CarbonInfo& CarbonAttr() { static CarbonInfo val; return val; }

 #endif

 #endif


 #if cimg_display==1

     // Keycodes for X11-based graphical systems.

     const unsigned int keyESC        = XK_Escape;

     const unsigned int keyF1         = XK_F1;

     const unsigned int keyF2         = XK_F2;

     const unsigned int keyF3         = XK_F3;

     const unsigned int keyF4         = XK_F4;

     const unsigned int keyF5         = XK_F5;

     const unsigned int keyF6         = XK_F6;

     const unsigned int keyF7         = XK_F7;

     const unsigned int keyF8         = XK_F8;

     const unsigned int keyF9         = XK_F9;

     const unsigned int keyF10        = XK_F10;

     const unsigned int keyF11        = XK_F11;

     const unsigned int keyF12        = XK_F12;

     const unsigned int keyPAUSE      = XK_Pause;

     const unsigned int key1          = XK_1;

     const unsigned int key2          = XK_2;

     const unsigned int key3          = XK_3;

     const unsigned int key4          = XK_4;

     const unsigned int key5          = XK_5;

     const unsigned int key6          = XK_6;

     const unsigned int key7          = XK_7;

     const unsigned int key8          = XK_8;

     const unsigned int key9          = XK_9;

     const unsigned int key0          = XK_0;

     const unsigned int keyBACKSPACE  = XK_BackSpace;

     const unsigned int keyINSERT     = XK_Insert;

     const unsigned int keyHOME       = XK_Home;

     const unsigned int keyPAGEUP     = XK_Page_Up;

     const unsigned int keyTAB        = XK_Tab;

     const unsigned int keyQ          = XK_q;

     const unsigned int keyW          = XK_w;

     const unsigned int keyE          = XK_e;

     const unsigned int keyR          = XK_r;

     const unsigned int keyT          = XK_t;

     const unsigned int keyY          = XK_y;

     const unsigned int keyU          = XK_u;

     const unsigned int keyI          = XK_i;

     const unsigned int keyO          = XK_o;

     const unsigned int keyP          = XK_p;

     const unsigned int keyDELETE     = XK_Delete;

     const unsigned int keyEND        = XK_End;

     const unsigned int keyPAGEDOWN   = XK_Page_Down;

     const unsigned int keyCAPSLOCK   = XK_Caps_Lock;

     const unsigned int keyA          = XK_a;

     const unsigned int keyS          = XK_s;

     const unsigned int keyD          = XK_d;

     const unsigned int keyF          = XK_f;

     const unsigned int keyG          = XK_g;

     const unsigned int keyH          = XK_h;

     const unsigned int keyJ          = XK_j;

     const unsigned int keyK          = XK_k;

     const unsigned int keyL          = XK_l;

     const unsigned int keyENTER      = XK_Return;

     const unsigned int keySHIFTLEFT  = XK_Shift_L;

     const unsigned int keyZ          = XK_z;

     const unsigned int keyX          = XK_x;

     const unsigned int keyC          = XK_c;

     const unsigned int keyV          = XK_v;

     const unsigned int keyB          = XK_b;

     const unsigned int keyN          = XK_n;

     const unsigned int keyM          = XK_m;

     const unsigned int keySHIFTRIGHT = XK_Shift_R;

     const unsigned int keyARROWUP    = XK_Up;

     const unsigned int keyCTRLLEFT   = XK_Control_L;

     const unsigned int keyAPPLEFT    = XK_Super_L;

     const unsigned int keyALT        = XK_Alt_L;

     const unsigned int keySPACE      = XK_space;

     const unsigned int keyALTGR      = XK_Alt_R;

     const unsigned int keyAPPRIGHT   = XK_Super_R;

     const unsigned int keyMENU       = XK_Menu;

     const unsigned int keyCTRLRIGHT  = XK_Control_R;

     const unsigned int keyARROWLEFT  = XK_Left;

     const unsigned int keyARROWDOWN  = XK_Down;

     const unsigned int keyARROWRIGHT = XK_Right;

     const unsigned int keyPAD0       = XK_KP_0;

     const unsigned int keyPAD1       = XK_KP_1;

     const unsigned int keyPAD2       = XK_KP_2;

     const unsigned int keyPAD3       = XK_KP_3;

     const unsigned int keyPAD4       = XK_KP_4;

     const unsigned int keyPAD5       = XK_KP_5;

     const unsigned int keyPAD6       = XK_KP_6;

     const unsigned int keyPAD7       = XK_KP_7;

     const unsigned int keyPAD8       = XK_KP_8;

     const unsigned int keyPAD9       = XK_KP_9;

     const unsigned int keyPADADD     = XK_KP_Add;

     const unsigned int keyPADSUB     = XK_KP_Subtract;

     const unsigned int keyPADMUL     = XK_KP_Multiply;

     const unsigned int keyPADDIV     = XK_KP_Divide;


 #elif cimg_display==2

     // Keycodes for Windows.

     const unsigned int keyESC        = VK_ESCAPE;

     const unsigned int keyF1         = VK_F1;

     const unsigned int keyF2         = VK_F2;

     const unsigned int keyF3         = VK_F3;

     const unsigned int keyF4         = VK_F4;

     const unsigned int keyF5         = VK_F5;

     const unsigned int keyF6         = VK_F6;

     const unsigned int keyF7         = VK_F7;

     const unsigned int keyF8         = VK_F8;

     const unsigned int keyF9         = VK_F9;

     const unsigned int keyF10        = VK_F10;

     const unsigned int keyF11        = VK_F11;

     const unsigned int keyF12        = VK_F12;

     const unsigned int keyPAUSE      = VK_PAUSE;

     const unsigned int key1          = '1';

     const unsigned int key2          = '2';

     const unsigned int key3          = '3';

     const unsigned int key4          = '4';

     const unsigned int key5          = '5';

     const unsigned int key6          = '6';

     const unsigned int key7          = '7';

     const unsigned int key8          = '8';

     const unsigned int key9          = '9';

     const unsigned int key0          = '0';

     const unsigned int keyBACKSPACE  = VK_BACK;

     const unsigned int keyINSERT     = VK_INSERT;

     const unsigned int keyHOME       = VK_HOME;

     const unsigned int keyPAGEUP     = VK_PRIOR;

     const unsigned int keyTAB        = VK_TAB;

     const unsigned int keyQ          = 'Q';

     const unsigned int keyW          = 'W';

     const unsigned int keyE          = 'E';

     const unsigned int keyR          = 'R';

     const unsigned int keyT          = 'T';

     const unsigned int keyY          = 'Y';

     const unsigned int keyU          = 'U';

     const unsigned int keyI          = 'I';

     const unsigned int keyO          = 'O';

     const unsigned int keyP          = 'P';

     const unsigned int keyDELETE     = VK_DELETE;

     const unsigned int keyEND        = VK_END;

     const unsigned int keyPAGEDOWN   = VK_NEXT;

     const unsigned int keyCAPSLOCK   = VK_CAPITAL;

     const unsigned int keyA          = 'A';

     const unsigned int keyS          = 'S';

     const unsigned int keyD          = 'D';

     const unsigned int keyF          = 'F';

     const unsigned int keyG          = 'G';

     const unsigned int keyH          = 'H';

     const unsigned int keyJ          = 'J';

     const unsigned int keyK          = 'K';

     const unsigned int keyL          = 'L';

     const unsigned int keyENTER      = VK_RETURN;

     const unsigned int keySHIFTLEFT  = VK_SHIFT;

     const unsigned int keyZ          = 'Z';

     const unsigned int keyX          = 'X';

     const unsigned int keyC          = 'C';

     const unsigned int keyV          = 'V';

     const unsigned int keyB          = 'B';

     const unsigned int keyN          = 'N';

     const unsigned int keyM          = 'M';

     const unsigned int keySHIFTRIGHT = VK_SHIFT;

     const unsigned int keyARROWUP    = VK_UP;

     const unsigned int keyCTRLLEFT   = VK_CONTROL;

     const unsigned int keyAPPLEFT    = VK_LWIN;

     const unsigned int keyALT        = VK_LMENU;

     const unsigned int keySPACE      = VK_SPACE;

     const unsigned int keyALTGR      = VK_CONTROL;

     const unsigned int keyAPPRIGHT   = VK_RWIN;

     const unsigned int keyMENU       = VK_APPS;

     const unsigned int keyCTRLRIGHT  = VK_CONTROL;

     const unsigned int keyARROWLEFT  = VK_LEFT;

     const unsigned int keyARROWDOWN  = VK_DOWN;

     const unsigned int keyARROWRIGHT = VK_RIGHT;

     const unsigned int keyPAD0       = 0x60;

     const unsigned int keyPAD1       = 0x61;

     const unsigned int keyPAD2       = 0x62;

     const unsigned int keyPAD3       = 0x63;

     const unsigned int keyPAD4       = 0x64;

     const unsigned int keyPAD5       = 0x65;

     const unsigned int keyPAD6       = 0x66;

     const unsigned int keyPAD7       = 0x67;

     const unsigned int keyPAD8       = 0x68;

     const unsigned int keyPAD9       = 0x69;

     const unsigned int keyPADADD     = VK_ADD;

     const unsigned int keyPADSUB     = VK_SUBTRACT;

     const unsigned int keyPADMUL     = VK_MULTIPLY;

     const unsigned int keyPADDIV     = VK_DIVIDE;


 #elif cimg_display==3

     // Keycodes for MacOSX, when using the Carbon framework.

     const unsigned int keyESC        = kEscapeCharCode;

     const unsigned int keyF1         = 2U;

     const unsigned int keyF2         = 3U;

     const unsigned int keyF3         = 4U;

     const unsigned int keyF4         = 5U;

     const unsigned int keyF5         = 6U;

     const unsigned int keyF6         = 7U;

     const unsigned int keyF7         = 8U;

     const unsigned int keyF8         = 9U;

     const unsigned int keyF9         = 10U;

     const unsigned int keyF10        = 11U;

     const unsigned int keyF11        = 12U;

     const unsigned int keyF12        = 13U;

     const unsigned int keyPAUSE      = 14U;

     const unsigned int key1          = '1';

     const unsigned int key2          = '2';

     const unsigned int key3          = '3';

     const unsigned int key4          = '4';

     const unsigned int key5          = '5';

     const unsigned int key6          = '6';

     const unsigned int key7          = '7';

     const unsigned int key8          = '8';

     const unsigned int key9          = '9';

     const unsigned int key0          = '0';

     const unsigned int keyBACKSPACE  = kBackspaceCharCode;

     const unsigned int keyINSERT     = 26U;

     const unsigned int keyHOME       = kHomeCharCode;

     const unsigned int keyPAGEUP     = kPageUpCharCode;

     const unsigned int keyTAB        = kTabCharCode;

     const unsigned int keyQ          = 'q';

     const unsigned int keyW          = 'w';

     const unsigned int keyE          = 'e';

     const unsigned int keyR          = 'r';

     const unsigned int keyT          = 't';

     const unsigned int keyY          = 'y';

     const unsigned int keyU          = 'u';

     const unsigned int keyI          = 'i';

     const unsigned int keyO          = 'o';

     const unsigned int keyP          = 'p';

     const unsigned int keyDELETE     = kDeleteCharCode;

     const unsigned int keyEND        = kEndCharCode;

     const unsigned int keyPAGEDOWN   = kPageDownCharCode;

     const unsigned int keyCAPSLOCK   = 43U;

     const unsigned int keyA          = 'a';

     const unsigned int keyS          = 's';

     const unsigned int keyD          = 'd';

     const unsigned int keyF          = 'f';

     const unsigned int keyG          = 'g';

     const unsigned int keyH          = 'h';

     const unsigned int keyJ          = 'j';

     const unsigned int keyK          = 'k';

     const unsigned int keyL          = 'l';

     const unsigned int keyENTER      = kEnterCharCode;

     const unsigned int keySHIFTLEFT  = 54U; //Macintosh modifier key, emulated

     const unsigned int keyZ          = 'z';

     const unsigned int keyX          = 'x';

     const unsigned int keyC          = 'c';

     const unsigned int keyV          = 'v';

     const unsigned int keyB          = 'b';

     const unsigned int keyN          = 'n';

     const unsigned int keyM          = 'm';

     const unsigned int keySHIFTRIGHT = 62U; //Macintosh modifier key, emulated

     const unsigned int keyARROWUP    = kUpArrowCharCode;

     const unsigned int keyCTRLLEFT   = 64U; //Macintosh modifier key, emulated

     const unsigned int keyAPPLEFT    = 65U; //Macintosh modifier key, emulated

     const unsigned int keyALT        = 66U;

     const unsigned int keySPACE      = kSpaceCharCode;

     const unsigned int keyALTGR      = 67U; //Macintosh modifier key, emulated

     const unsigned int keyAPPRIGHT   = 68U; //Aliased on keyAPPLEFT

     const unsigned int keyMENU       = 69U;

     const unsigned int keyCTRLRIGHT  = 70U; //Macintosh modifier key, emulated

     const unsigned int keyARROWLEFT  = kLeftArrowCharCode;

     const unsigned int keyARROWDOWN  = kDownArrowCharCode;

     const unsigned int keyARROWRIGHT = kRightArrowCharCode;

     const unsigned int keyPAD0       = 74U;

     const unsigned int keyPAD1       = 75U;

     const unsigned int keyPAD2       = 76U;

     const unsigned int keyPAD3       = 77U;

     const unsigned int keyPAD4       = 78U;

     const unsigned int keyPAD5       = 79U;

     const unsigned int keyPAD6       = 80U;

     const unsigned int keyPAD7       = 81U;

     const unsigned int keyPAD8       = 82U;

     const unsigned int keyPAD9       = 83U;

     const unsigned int keyPADADD     = 84U;

     const unsigned int keyPADSUB     = 85U;

     const unsigned int keyPADMUL     = 86U;

     const unsigned int keyPADDIV     = 87U;


 #else

     // Define unknow keycodes when no display are available.

     // (should rarely be used then !).

     const unsigned int keyESC        = 1U;

     const unsigned int keyF1         = 2U;

     const unsigned int keyF2         = 3U;

     const unsigned int keyF3         = 4U;

     const unsigned int keyF4         = 5U;

     const unsigned int keyF5         = 6U;

     const unsigned int keyF6         = 7U;

     const unsigned int keyF7         = 8U;

     const unsigned int keyF8         = 9U;

     const unsigned int keyF9         = 10U;

     const unsigned int keyF10        = 11U;

     const unsigned int keyF11        = 12U;

     const unsigned int keyF12        = 13U;

     const unsigned int keyPAUSE      = 14U;

     const unsigned int key1          = 15U;

     const unsigned int key2          = 16U;

     const unsigned int key3          = 17U;

     const unsigned int key4          = 18U;

     const unsigned int key5          = 19U;

     const unsigned int key6          = 20U;

     const unsigned int key7          = 21U;

     const unsigned int key8          = 22U;

     const unsigned int key9          = 23U;

     const unsigned int key0          = 24U;

     const unsigned int keyBACKSPACE  = 25U;

     const unsigned int keyINSERT     = 26U;

     const unsigned int keyHOME       = 27U;

     const unsigned int keyPAGEUP     = 28U;

     const unsigned int keyTAB        = 29U;

     const unsigned int keyQ          = 30U;

     const unsigned int keyW          = 31U;

     const unsigned int keyE          = 32U;

     const unsigned int keyR          = 33U;

     const unsigned int keyT          = 34U;

     const unsigned int keyY          = 35U;

     const unsigned int keyU          = 36U;

     const unsigned int keyI          = 37U;

     const unsigned int keyO          = 38U;

     const unsigned int keyP          = 39U;

     const unsigned int keyDELETE     = 40U;

     const unsigned int keyEND        = 41U;

     const unsigned int keyPAGEDOWN   = 42U;

     const unsigned int keyCAPSLOCK   = 43U;

     const unsigned int keyA          = 44U;

     const unsigned int keyS          = 45U;

     const unsigned int keyD          = 46U;

     const unsigned int keyF          = 47U;

     const unsigned int keyG          = 48U;

     const unsigned int keyH          = 49U;

     const unsigned int keyJ          = 50U;

     const unsigned int keyK          = 51U;

     const unsigned int keyL          = 52U;

     const unsigned int keyENTER      = 53U;

     const unsigned int keySHIFTLEFT  = 54U;

     const unsigned int keyZ          = 55U;

     const unsigned int keyX          = 56U;

     const unsigned int keyC          = 57U;

     const unsigned int keyV          = 58U;

     const unsigned int keyB          = 59U;

     const unsigned int keyN          = 60U;

     const unsigned int keyM          = 61U;

     const unsigned int keySHIFTRIGHT = 62U;

     const unsigned int keyARROWUP    = 63U;

     const unsigned int keyCTRLLEFT   = 64U;

     const unsigned int keyAPPLEFT    = 65U;

     const unsigned int keyALT        = 66U;

     const unsigned int keySPACE      = 67U;

     const unsigned int keyALTGR      = 68U;

     const unsigned int keyAPPRIGHT   = 69U;

     const unsigned int keyMENU       = 70U;

     const unsigned int keyCTRLRIGHT  = 71U;

     const unsigned int keyARROWLEFT  = 72U;

     const unsigned int keyARROWDOWN  = 73U;

     const unsigned int keyARROWRIGHT = 74U;

     const unsigned int keyPAD0       = 75U;

     const unsigned int keyPAD1       = 76U;

     const unsigned int keyPAD2       = 77U;

     const unsigned int keyPAD3       = 78U;

     const unsigned int keyPAD4       = 79U;

     const unsigned int keyPAD5       = 80U;

     const unsigned int keyPAD6       = 81U;

     const unsigned int keyPAD7       = 82U;

     const unsigned int keyPAD8       = 83U;

     const unsigned int keyPAD9       = 84U;

     const unsigned int keyPADADD     = 85U;

     const unsigned int keyPADSUB     = 86U;

     const unsigned int keyPADMUL     = 87U;

     const unsigned int keyPADDIV     = 88U;

 #endif


     const double valuePI = 3.14159265358979323846;


     // Definition of a 7x11 font, used to return a default font for drawing text.

     const unsigned int font7x11[7*11*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x90,0x0,0x7f0000,0x40000,0x0,0x0,0x4010c0a4,0x82000040,0x11848402,0x18480050,0x80430292,0x8023,0x9008000,

       0x40218140,0x4000040,0x21800402,0x18000051,0x1060500,0x8083,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x24002,0x4031,0x80000000,0x10000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x81c0400,0x40020000,0x80070080,0x40440e00,0x0,0x0,0x1,0x88180000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x200000,0x0,0x0,0x80000,0x0,0x0,0x20212140,0x5000020,0x22400204,0x240000a0,0x40848500,0x4044,0x80010038,0x20424285,0xa000020,

       0x42428204,0x2428e0a0,0x82090a14,0x4104,0x85022014,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10240a7,0x88484040,0x40800000,0x270c3,0x87811e0e,

       0x7c70e000,0x78,0x3c23c1ef,0x1f3e1e89,0xf1c44819,0xa23cf0f3,0xc3cff120,0xc18307f4,0x4040400,0x20000,0x80080080,0x40200,0x0,

       0x40000,0x2,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8188,0x50603800,0xf3c00000,0x1c004003,0xc700003e,0x18180,0xc993880,0x10204081,

       0x2071ef9,0xf3e7cf9f,0x3e7c7911,0xe3c78f1e,0x7d1224,0x48906048,0x0,0x4000000,0x0,0x9000,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x10240aa,0x14944080,0x23610000,0x68940,0x40831010,0x8891306,0x802044,0x44522208,0x90202088,0x40448819,0xb242890a,0x24011111,

       0x49448814,0x4040a00,0xe2c3c7,0x8e3f3cb9,0xc1c44216,0xee38b0f2,0xe78f9120,0xc18507e2,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x101c207,0x88a04001,0x9c00000,0x2200a041,0x8200113a,0x8240,0x50a3110,0x2850a142,0x850c2081,0x2040204,0x8104592,0x142850a1,

       0x42cd1224,0x4888bc48,0x70e1c387,0xe3b3c70,0xe1c38e1c,0x38707171,0xc3870e1c,0x10791224,0x48906c41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x10003ee,0x15140080,0x21810000,0x48840,0x40851020,0x8911306,0x31fd804,0x9c522408,0x90204088,0x4045081a,0xba42890a,0x24011111,

       0x49285024,0x2041b00,0x132408,0x910844c8,0x4044821b,0x7244c913,0x24041111,0x49488822,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x28204,0x85006001,0x6a414000,0x3a004043,0xc700113a,0x8245,0x50a3a00,0x2850a142,0x850c4081,0x2040204,0x81045d2,0x142850a1,

       0x24951224,0x48852250,0x8102040,0x81054089,0x12244204,0x8108992,0x24489122,0x991224,0x4888b222,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x1000143,0xa988080,0x2147c01f,0x88840,0x83091c2c,0x1070f000,0xc000608,0xa48bc408,0x9e3c46f8,0x40460816,0xaa42f10b,0xc3811111,

       0x35102044,0x1041100,0xf22408,0x9f084488,0x40470212,0x62448912,0x6041111,0x55308846,0x8061c80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x1028704,0x8f805801,0x4be28fdf,0x220001f0,0x111a,0x60000182,0x82c5c710,0x44891224,0x489640f1,0xe3c78204,0x810e552,0x142850a1,

       0x18a51224,0x48822250,0x78f1e3c7,0x8f1f40f9,0xf3e7c204,0x8108912,0x24489122,0x7ea91224,0x4888a222,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x10007e2,0x85648080,0x20010000,0x88841,0x8f8232,0x20881000,0xc1fc610,0xbefa2408,0x90204288,0x40450816,0xa642810a,0x4041110a,

       0x36282084,0x1042080,0x1122408,0x90084488,0x40450212,0x62448912,0x184110a,0x55305082,0x8042700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x1028207,0x82004801,0x68050040,0x1c000040,0x110a,0x60000001,0x45484d10,0x7cf9f3e7,0xcf944081,0x2040204,0x8104532,0x142850a1,

       0x18a51224,0x48822248,0x89122448,0x91244081,0x2040204,0x8108912,0x24489122,0xc91224,0x48852214,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x282,

       0x89630080,0x20010c00,0x30108842,0x810222,0x20882306,0x3001800,0x408a2208,0x90202288,0x40448814,0xa642810a,0x2041110a,0x26442104,

       0x840000,0x1122408,0x90084488,0x40448212,0x62448912,0x84130a,0x36485102,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101c208,0x4f802801,

       0x8028040,0x40,0x130a,0x2,0x85e897a0,0x44891224,0x489c2081,0x2040204,0x8104532,0x142850a1,0x24cd1224,0x48823c44,0x89122448,

       0x91244081,0x2040204,0x8108912,0x24489122,0xc93264,0xc9852214,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100028f,0x109f0080,0x20010c00,

       0x303071f3,0xc7011c1c,0x4071c306,0x802010,0x3907c1ef,0x1f201e89,0xf3844f90,0xa23c80f2,0x17810e04,0x228223f4,0x840000,0xfbc3c7,

       0x8f083c88,0x40444212,0x6238f0f2,0x7039d04,0x228423e2,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1008780,0x2201800,0xf0014000,0x1f0,

       0x1d0a,0x5,0x851e140,0x83060c18,0x30671ef9,0xf3e7cf9f,0x3e7c7911,0xe3c78f1e,0x42f8e1c3,0x8702205c,0x7cf9f3e7,0xcf9b3c78,0xf1e3c204,

       0x8107111,0xc3870e1c,0x10f1d3a7,0x4e823c08,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x40,0x40000400,0x200000,0x0,0x2,0x0,0x0,0x0,0x0,0x18,

       0x0,0x4,0x44007f,0x0,0x400,0x400000,0x8010,0x0,0x6002,0x8040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x200800,0x0,0x0,0x100a,

       0x400000,0x44,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x62018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x31,0x80000800,

       0x400000,0x0,0x4,0x0,0x0,0x0,0x0,0xc,0x0,0x7,0x3c0000,0x0,0x3800,0x3800000,0x8010,0x0,0x1c001,0x881c0000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x207000,0x0,0x0,0x100a,0xc00000,0x3c,0x0,0xc00,0x0,0x0,0x0,0x0,0x0,0x0,0x1800,0x0,0x0,0x0,0x0,0x1c2070

     };


     // Definition of a 10x13 font (used in dialog boxes).

     const unsigned int font10x13[256*10*13/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80100c0,

       0x68000300,0x801,0xc00010,0x100c000,0x68100,0x100c0680,0x2,0x403000,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfc,0x0,0x0,0x0,0x0,0x0,0x4020120,

       0x58120480,0x402,0x1205008,0x2012050,0x58080,0x20120581,0x40000001,0x804812,0x2000000,0x0,0x300,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x140,0x80000,0x200402,0x800000,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x7010,0x7000000,0x8000200,0x20000,0xc0002000,0x8008,0x0,0x0,0x0,0x0,0x808,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x80000000,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x480,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x80100c0,0x68000480,0x1001,

       0xc00010,0x1018000,0x68100,0x100c0680,0x4,0x403000,0x1020000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20140,0x28081883,0x200801,

       0x2a00000,0x10,0x1c0201c0,0x70040f80,0xc0f81c07,0x0,0x70,0x3e0303c0,0x3c3c0f83,0xe03c2107,0xe08810,0x18c31070,0x3c0703c0,

       0x783e0842,0x22222208,0x83e04010,0x1008000,0x4000200,0x20001,0x2002,0x408008,0x0,0x0,0x100000,0x0,0x1008,0x2000000,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20080,0x38000880,0x8078140f,0x81c00000,0x3e000,0xc020180,0x60080001,0xe0000002,0xc00042,0x108e2010,

       0xc0300c0,0x300c0303,0xf83c3e0f,0x83e0f81c,0x701c070,0x3c0c41c0,0x701c0701,0xc0001d08,0x42108421,0x8820088,0x4020120,0x58140480,

       0x802,0x1205008,0x3014050,0xc058080,0x20120581,0x40000002,0x804814,0x2020050,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20140,

       0x281e2484,0x80200801,0x1c02000,0x10,0x22060220,0x880c0801,0x82208,0x80000001,0x20008,0x41030220,0x40220802,0x402102,0x209010,

       0x18c31088,0x22088220,0x80080842,0x22222208,0x80204010,0x1014000,0x200,0x20001,0x2000,0x8008,0x0,0x0,0x100000,0x0,0x1008,

       0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x40000500,0x80800010,0x40200000,0x41000,0x12020040,0x10000003,0xa0000006,

       0x12000c4,0x31014000,0xc0300c0,0x300c0302,0x80402008,0x2008008,0x2008020,0x220c4220,0x88220882,0x20002208,0x42108421,0x8820088,

       0x0,0x300,0x0,0x0,0x0,0x14000000,0x0,0x200200,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0xfc282504,0x80001000,

       0x82a02000,0x20,0x22020020,0x8140802,0x102208,0x80801006,0x18008,0x9c848220,0x80210802,0x802102,0x20a010,0x15429104,0x22104220,

       0x80080842,0x22221405,0x404008,0x1022000,0x703c0,0x381e0701,0xc0783c02,0xc09008,0x1d83c070,0x3c078140,0x381c0882,0x21242208,

       0x81e01008,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x201e0,0x40220500,0x80800027,0x20e02800,0x9c800,0x12020040,

       0x20000883,0xa0200002,0x120a044,0x11064010,0x12048120,0x48120484,0x80802008,0x2008008,0x2008020,0x210a4411,0x4411044,0x10884508,

       0x42108421,0x503c0b0,0x1c0701c0,0x701c0707,0x70381c07,0x1c07008,0x2008020,0x20f01c0,0x701c0701,0xc0201c08,0x82208822,0x883c088,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x50281903,0x20001000,0x80802000,0x20,0x22020040,0x30240f03,0xc0101c08,0x80801018,

       0x1fc06010,0xa48483c0,0x80210f03,0xe0803f02,0x20c010,0x15429104,0x22104220,0x70080841,0x41540805,0x804008,0x1041000,0x8220,

       0x40220881,0x882202,0x40a008,0x12422088,0x22088180,0x40100882,0x21241408,0x80201008,0x2031000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x20280,0x401c0200,0x700028,0x21205000,0x92800,0xc1fc080,0x10000883,0xa0200002,0x1205049,0x12c19010,0x12048120,0x48120484,

       0xf0803c0f,0x3c0f008,0x2008020,0x790a4411,0x4411044,0x10504908,0x42108421,0x5022088,0x2008020,0x8020080,0x88402208,0x82208808,

       0x2008020,0x1e088220,0x88220882,0x20002608,0x82208822,0x8822088,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x501c0264,

       0xa0001000,0x8001fc00,0x7000020,0x22020080,0x83e0082,0x20202207,0x80000020,0x1020,0xa4848220,0x80210802,0x9c2102,0x20c010,

       0x12425104,0x3c1043c0,0x8080841,0x41540802,0x804008,0x1000000,0x78220,0x40220f81,0x882202,0x40c008,0x12422088,0x22088100,

       0x60100881,0x41540805,0x406008,0x1849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20280,0xf0140200,0x880028,0x20e0a03f,0x709c800,

       0x201c0,0x60000881,0xa0000007,0xc0284b,0x122eb020,0x12048120,0x48120487,0x80802008,0x2008008,0x2008020,0x21094411,0x4411044,

       0x10204908,0x42108421,0x2022088,0x1e0781e0,0x781e0787,0xf8403e0f,0x83e0f808,0x2008020,0x22088220,0x88220882,0x21fc2a08,0x82208822,

       0x5022050,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20001,0xf80a0294,0x40001000,0x80002000,0x20,0x22020100,0x8040082,0x20202200,

       0x80000018,0x1fc06020,0xa48fc220,0x80210802,0x842102,0x20a010,0x12425104,0x20104240,0x8080841,0x41541402,0x1004008,0x1000000,

       0x88220,0x40220801,0x882202,0x40a008,0x12422088,0x22088100,0x18100881,0x41540805,0x801008,0x2046000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x20280,0x401c0f80,0x80880028,0x20005001,0x94800,0x20000,0x880,0xa0000000,0x5015,0x4215040,0x3f0fc3f0,0xfc3f0fc8,

       0x80802008,0x2008008,0x2008020,0x21094411,0x4411044,0x10505108,0x42108421,0x203c088,0x22088220,0x88220888,0x80402008,0x2008008,

       0x2008020,0x22088220,0x88220882,0x20002a08,0x82208822,0x5022050,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa00a0494,0x60001000,

       0x80002004,0x8020,0x22020200,0x88040882,0x20402201,0x801006,0x18000,0x9f084220,0x40220802,0x442102,0x209010,0x10423088,0x20088220,

       0x8080840,0x80882202,0x2004008,0x1000000,0x88220,0x40220881,0x882202,0x409008,0x12422088,0x22088100,0x8100880,0x80881402,

       0x1001008,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20280,0x40220200,0x80700027,0x20002801,0x92800,0x1fc000,0x980,

       0xa0000000,0xa017,0x84417840,0x21084210,0x84210848,0x80402008,0x2008008,0x2008020,0x2208c220,0x88220882,0x20882208,0x42108421,

       0x2020088,0x22088220,0x88220888,0xc8402208,0x82208808,0x2008020,0x22088220,0x88220882,0x20203208,0x82208822,0x2022020,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0xa03c0463,0x90000801,0x2004,0x8040,0x1c0703e0,0x70040701,0xc0401c06,0x801001,0x20020,

       0x400843c0,0x3c3c0f82,0x3c2107,0x1c0881e,0x10423070,0x20070210,0xf0080780,0x80882202,0x3e04004,0x1000000,0x783c0,0x381e0701,

       0x782202,0x408808,0x12422070,0x3c078100,0x700c0780,0x80882202,0x1e01008,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x201e0,

       0xf8000200,0x80080010,0x40000001,0x41000,0x0,0xe80,0xa0000000,0x21,0x8e21038,0x21084210,0x84210848,0xf83c3e0f,0x83e0f81c,

       0x701c070,0x3c08c1c0,0x701c0701,0xc0005c07,0x81e0781e,0x20200b0,0x1e0781e0,0x781e0787,0x30381c07,0x1c07008,0x2008020,0x1c0881c0,

       0x701c0701,0xc0201c07,0x81e0781e,0x203c020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x801,0x4,0x40,0x0,0x0,0x0,0x1000,

       0x0,0x3c000000,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x4004,0x1000000,0x0,0x0,0x80000,0x400000,0x0,0x20008000,0x0,0x4,0x1008,0x2000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x8008000f,0x80000000,0x3e000,0x0,0x800,0xa0000400,0x0,0x0,0x0,0x0,0x80000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x2000,0x0,0x4020040,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,

       0x402,0x8,0x40,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x7004,0x70000fc,0x0,0x0,0x700000,0x800000,0x0,0x20008000,

       0x0,0x4,0x808,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x80f00000,0x0,0x0,0x0,0x800,0xa0001800,0x0,0x0,0x0,0x0,

       0x300000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600000,0x0,0x0,0x0,0x0,0x0,0x0,0x4020040

     };


     // Definition of a 8x17 font.

     const unsigned int font8x17[8*17*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x2400,0x2400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20081834,0x1c0000,0x20081800,0x20081800,0x342008,

       0x18340000,0x200818,0x80000,0x0,0x180000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4200000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x380000,0x4000,0x2000c00,0x40100840,0x70000000,0x0,0x0,0x1c,0x10700000,0x7,0x0,

       0x1800,0x1800,0x0,0x0,0x0,0x14,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010242c,0x14140000,0x10102414,0x10102414,0x2c1010,0x242c1400,

       0x101024,0x14100038,0x0,0x240000,0x0,0x0,0x30000000,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x8100000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x80000,0x10004000,0x2001000,0x40000040,0x10000000,0x0,0x0,0x10,0x10100000,0x4,

       0x0,0x18000000,0x0,0x0,0x0,0x34002400,0x2400,0x0,0x0,0x0,0x3c,0x0,0x8000000,0x0,0x60607800,0x0,0x140000,0x0,0x0,0x0,0x0,0x0,

       0x44,0x10081834,0x240000,0x10081800,0x10081800,0x1c341008,0x18340000,0x100818,0x84000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x102812,

       0x8601c10,0x8100800,0x2,0x1c383e3e,0x67e1e7f,0x3e3c0000,0x38,0x1e087e1e,0x7c7f7f1e,0x417c1c42,0x4063611c,0x7e1c7e3e,0xfe414181,

       0x63827f10,0x40081000,0x8004000,0x2001000,0x40000040,0x10000000,0x0,0x10000000,0x10,0x10100000,0x3c000008,0x0,0x24003e00,

       0x3f007f00,0x0,0x0,0x2ce91800,0x1882,0x10101c,0xc2103c,0x143c3c00,0x3c00,0x18003c3c,0x10001f00,0x181c00,0x20200810,0x8080808,

       0x8083e1e,0x7f7f7f7f,0x7c7c7c7c,0x7c611c1c,0x1c1c1c00,0x1e414141,0x41824044,0x810242c,0x14180000,0x8102414,0x8102414,0x382c0810,

       0x242c1400,0x81024,0x14104014,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x102816,0x3e902010,0x10084910,0x4,0x22084343,0xa402102,0x41620000,

       0x44,0x33144121,0x42404021,0x41100444,0x40636122,0x43224361,0x10416381,0x22440310,0x20082800,0x4000,0x2001000,0x40000040,

       0x10000000,0x0,0x10000000,0x10,0x10100000,0x24000008,0x0,0x606100,0x68000300,0x8106c,0x34000000,0x4f0000,0x44,0x101020,0x441040,

       0x420200,0x4200,0x24000404,0x7d00,0x82200,0x20203010,0x14141414,0x14082821,0x40404040,0x10101010,0x42612222,0x22222200,0x23414141,

       0x41447e48,0x0,0x0,0x0,0x0,0x4000000,0x18,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10287f,0x49902010,0x10083e10,0x4,0x41080101,

       0x1a404002,0x41411818,0x1004004,0x21144140,0x41404040,0x41100448,0x40555141,0x41414140,0x10412281,0x14280610,0x20084400,0x1c7c1c,

       0x3e3c7c3a,0x5c703844,0x107f5c3c,0x7c3e3c3c,0x7e424281,0x66427e10,0x10100000,0x40100008,0x1010,0xa04000,0x48100610,0x100c3024,

       0x24000000,0x4f3c00,0x2c107e28,0x3820,0x42281060,0x9d1e12,0xbd00,0x24100818,0x427d00,0x82248,0x20200800,0x14141414,0x14142840,

       0x40404040,0x10101010,0x41514141,0x41414142,0x43414141,0x41284350,0x1c1c1c1c,0x1c1c6c1c,0x3c3c3c3c,0x70707070,0x3c5c3c3c,

       0x3c3c3c18,0x3e424242,0x42427c42,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x102824,0x48623010,0x10081c10,0x8,0x41080103,0x127c5e04,

       0x41411818,0xe7f3808,0x4f144140,0x41404040,0x41100450,0x40555141,0x41414160,0x1041225a,0x1c280410,0x1008c600,0x226622,0x66661066,

       0x62100848,0x10496266,0x66663242,0x10426681,0x24220260,0x100c0000,0xf8280008,0x1010,0x606000,0x48280428,0x28042014,0x48000000,

       0x494200,0x52280228,0x105420,0x3cee1058,0xa12236,0xa500,0x18101004,0x427d00,0x8226c,0x76767e10,0x14141414,0x14142840,0x40404040,

       0x10101010,0x41514141,0x41414124,0x45414141,0x41284150,0x22222222,0x22221222,0x66666666,0x10101010,0x66626666,0x66666600,

       0x66424242,0x42226622,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100024,0x381c4900,0x10086bfe,0x8,0x4908021c,0x22036304,0x3e630000,

       0x70000710,0x51227e40,0x417f7f43,0x7f100470,0x40554941,0x43417e3e,0x1041225a,0x8100810,0x10080000,0x24240,0x42421042,0x42100850,

       0x10494242,0x42422040,0x1042245a,0x18240410,0x10103900,0x407c003e,0x1818,0x1c3e10,0x4f7c087c,0x7c002010,0x48000000,0x4008,

       0x527c0410,0x105078,0x2410104c,0xa13e6c,0x7f00b900,0xfe3c3c,0x421d18,0x1c1c36,0x38383810,0x22222222,0x22144e40,0x7f7f7f7f,

       0x10101010,0xf1494141,0x41414118,0x49414141,0x4110435c,0x2020202,0x2021240,0x42424242,0x10101010,0x42424242,0x424242ff,0x4e424242,

       0x42244224,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000fe,0xe664d00,0x10080810,0x380010,0x41080c03,0x42014108,0x633d0000,0x70000710,

       0x51224140,0x41404041,0x41100448,0x40494541,0x7e414203,0x1041145a,0x14101010,0x10080000,0x3e4240,0x427e1042,0x42100870,0x10494242,

       0x4242203c,0x1042245a,0x18241810,0x10104600,0xf8f60008,0x1010,0x600320,0x48f610f6,0xf6000000,0x187eff,0x3c04,0x5ef61810,0x105020,

       0x24fe0064,0x9d006c,0x138ad00,0x100000,0x420518,0x36,0xc0c0c020,0x22222222,0x22224840,0x40404040,0x10101010,0x41454141,0x41414118,

       0x51414141,0x41107e46,0x3e3e3e3e,0x3e3e7e40,0x7e7e7e7e,0x10101010,0x42424242,0x42424200,0x5a424242,0x42244224,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x28,0x9094500,0x10080010,0x10,0x41081801,0x7f014118,0x41010000,0xe7f3800,0x513e4140,0x41404041,0x41100444,

       0x40414541,0x40414101,0x10411466,0x36103010,0x8080000,0x424240,0x42401042,0x42100848,0x10494242,0x42422002,0x10423c5a,0x18142010,

       0x10100000,0x407c0010,0x1010,0x260140,0x487c307c,0x7c000000,0x180000,0x202,0x507c2010,0x105020,0x3c10003c,0x423e36,0x1004200,

       0x100000,0x420500,0x3e6c,0x41e0440,0x3e3e3e3e,0x3e3e7840,0x40404040,0x10101010,0x41454141,0x41414124,0x61414141,0x41104042,

       0x42424242,0x42425040,0x40404040,0x10101010,0x42424242,0x42424218,0x72424242,0x42144214,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100048,

       0x49096200,0x8100010,0x18001810,0x22082043,0x2432310,0x61421818,0x1004010,0x4f634121,0x42404021,0x41104444,0x40414322,0x40234143,

       0x10411466,0x22106010,0x8080000,0x466622,0x66621066,0x42100844,0x10494266,0x66662042,0x10461824,0x24184010,0x10100000,0x24381010,

       0x34001018,0xda4320,0x68386038,0x38000000,0x0,0x4204,0x50384010,0x105420,0x4210100c,0x3c0012,0x3c00,0x0,0x460500,0x48,0xc020c44,

       0x63636363,0x63228821,0x40404040,0x10101010,0x42432222,0x22222242,0x62414141,0x41104042,0x46464646,0x46465022,0x62626262,

       0x10101010,0x66426666,0x66666618,0x66464646,0x46186618,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100048,0x3e063d00,0x8100000,0x18001820,

       0x1c3e7f3e,0x23c1e20,0x3e3c1818,0x10,0x20417e1e,0x7c7f401e,0x417c3842,0x7f41431c,0x401e40be,0x103e0866,0x41107f10,0x4080000,

       0x3a5c1c,0x3a3c103a,0x427c0842,0xe49423c,0x7c3e203c,0xe3a1824,0x66087e10,0x10100000,0x3c103010,0x245a1010,0x5a3e10,0x3f107f10,

       0x10000000,0x0,0x3c08,0x2e107e10,0x1038fc,0x101004,0x0,0x0,0xfe0000,0x7f0500,0x0,0x14041438,0x41414141,0x41418e1e,0x7f7f7f7f,

       0x7c7c7c7c,0x7c431c1c,0x1c1c1c00,0xbc3e3e3e,0x3e10405c,0x3a3a3a3a,0x3a3a6e1c,0x3c3c3c3c,0x7c7c7c7c,0x3c423c3c,0x3c3c3c00,

       0x7c3a3a3a,0x3a087c08,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x4200000,0x10000020,0x0,0x0,0x10,0x0,0x30000000,0x0,

       0x0,0x0,0x60000,0x0,0x1c,0x4380000,0x0,0x2,0x800,0x0,0x40020000,0x0,0x8000c,0x10600000,0x2010,0x48000000,0x240000,0x0,0x0,

       0x0,0x0,0x0,0x1000,0x1078,0x0,0x0,0x0,0x400500,0x0,0x1e081e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x84008,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x20000040,0x0,0x0,0x20,0x0,0x1e000000,0x0,0x0,0x0,0x20000,0x0,

       0x0,0x2000000,0x0,0x26,0x800,0x0,0x40020000,0x0,0x100000,0x10000000,0x2030,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x1000,0x0,

       0x0,0x0,0x400000,0x8000000,0x41e0400,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x104010,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe,0x0,0x1c,0x7000,0x0,0x40020000,0x0,0x300000,

       0x0,0xe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x400000,0x38000000,0x0,0x0,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x1c,0x0,0x0,0x0,0x0,0x0,0x304030,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 10x19 font.

     const unsigned int font10x19[10*19*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3600000,0x36000,0x0,0x0,0x0,0x0,0x6c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x180181c0,0xe81b0300,0x1801,0x81c06c18,0x181c06c,0xe8180,0x181c0e81,0xb0000006,0x60701b,0x1800000,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c00000,0x1c000,0x0,0x0,0x0,0x0,0x6c,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0xc030360,0xb81b0480,0xc03,0x3606c0c,0x303606c,0xb80c0,0x30360b81,0xb0000003,0xc0d81b,0x3000000,0x0,

       0x300,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x2200000,

       0x22000,0x0,0x0,0x0,0x0,0x0,0x0,0x30000,0x0,0xe0,0x38078000,0x0,0x480,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3000c080,0x480,0x3000,

       0xc0800030,0xc08000,0x300,0xc080000,0xc,0x302000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20120,0x41c01,0xe020060c,

       0x800000,0x4,0x1e0703e0,0xf8060fc1,0xe1fe1e07,0x80000000,0x78,0x307e0,0x3c7c1fe7,0xf83c408f,0x80f10440,0x18660878,0x7e0787e0,

       0x78ff9024,0xa0140a0,0x27f83840,0x700e000,0x18000400,0x8000,0x70004002,0x410078,0x0,0x0,0x0,0x0,0x1808,0xc000000,0xf000000,

       0xe000000,0x1400,0x1e0001f,0x8007f800,0x0,0x0,0x3a3b,0x61400000,0x14202,0x20000,0x38002020,0x3c1b00,0x3e00000,0xf8,0x1c0001c0,

       0x78060001,0xf800000e,0x1e00020,0x8004020,0xc0300c0,0x300c0301,0xf83c7f9f,0xe7f9fe3e,0xf83e0f8,0x7c1821e0,0x781e0781,0xe0001f10,

       0x24090240,0xa02400f8,0x18018140,0xe81b0480,0x1801,0x81406c18,0x181406c,0x190e8180,0x18140e81,0xb0000006,0x60501b,0x184006c,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20120,0x26042202,0x200c06,0x800000,0x8,0x210d0611,0x40e0803,0x10026188,0x40000000,

       0x8c,0xf030418,0xc6431004,0xc64082,0x110840,0x18660884,0x41084410,0x8c081024,0xa012110,0x40082020,0x101b000,0xc000400,0x8000,

       0x80004002,0x410008,0x0,0x0,0x100000,0x0,0x2008,0x2000000,0x18800000,0x10000000,0x2200,0x2300024,0x800,0x0,0x0,0x2e13,0x60800000,

       0x8104,0x20040,0x64001040,0x80401b07,0x80100000,0x1e000,0x22000020,0x40c0003,0xc8000002,0x3300020,0x8004020,0xc0300c0,0x300c0301,

       0x40c64010,0x4010008,0x2008020,0x43182210,0x84210842,0x10002190,0x24090240,0x9044018c,0xc030220,0xb81b0300,0xc03,0x2206c0c,

       0x302206c,0x1e0b80c0,0x30220b81,0xb0000003,0xc0881b,0x304006c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20120,0x241f2202,

       0x200802,0x4900000,0x8,0x21010408,0x20a0802,0x44090,0x20000000,0x4,0x11878408,0x80411004,0x804082,0x111040,0x1ce50986,0x40986409,

       0x81022,0x12012108,0x80102020,0x1031800,0x400,0x8000,0x80004000,0x10008,0x0,0x0,0x100000,0x0,0x2008,0x2000000,0x10000000,

       0x10000000,0x18,0x4000044,0x1000,0x30180,0xd81b0000,0x13,0xe0000000,0x88,0x40,0x400018c0,0x80400018,0x61f00000,0x61800,0x22020020,

       0x4000007,0xc8000002,0x2100020,0x8038000,0x1e0781e0,0x781e0301,0x40804010,0x4010008,0x2008020,0x41142619,0x86619866,0x18002190,

       0x24090240,0x8887e104,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20120,0x2434a202,

       0x200802,0x3e00000,0x10,0x40810008,0x21a0804,0x44090,0x20000000,0x80040004,0x20848409,0x409004,0x1004082,0x112040,0x14a50902,

       0x40902409,0x81022,0x11321208,0x80202010,0x1060c00,0x7c5e0,0x781e8783,0xf07a5f0e,0x1c10808,0xfc5f078,0x5e07a170,0x7c7e1024,

       0xa016190,0x27f82008,0x2000000,0x20000000,0x10000000,0x80200024,0x4000044,0x2000,0x18180,0xc8320000,0x12,0xa1f00037,0x7f888,

       0x1e0,0x40410880,0x80600017,0xa2100000,0x5e800,0x22020040,0x38001027,0xc8000002,0x2100020,0x8004020,0x12048120,0x48120482,

       0x41004010,0x4010008,0x2008020,0x40942409,0x2409024,0x9044390,0x24090240,0x88841918,0x1f07c1f0,0x7c1f07c3,0x70781e07,0x81e07838,

       0xe0380e0,0x1f17c1e0,0x781e0781,0xe0001f90,0x24090240,0x9025e102,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20001,0xff241c41,

       0x1001,0x1c02000,0x10,0x40810008,0x6120f85,0xe0086190,0x20c03007,0x8007800c,0x27848419,0x409004,0x1004082,0x114040,0x14a48902,

       0x40902409,0x81022,0x11321205,0x602010,0x1000000,0x86610,0x84218840,0x80866182,0x411008,0x9261884,0x61086189,0x82101022,0x12012108,

       0x40082008,0x2000000,0x20030000,0x20000000,0x80200024,0x4000044,0x3006030,0xc018100,0x4c260000,0x12,0x26080048,0x83000850,

       0x20250,0x403e0500,0x8078002c,0x12302200,0x92400,0x1c0200c0,0x4001027,0xc8000002,0x3308820,0x8004020,0x12048120,0x48120482,

       0x41004010,0x4010008,0x2008020,0x40922409,0x2409024,0x8884690,0x24090240,0x85040920,0x21886218,0x86218860,0x88842108,0x42108408,

       0x2008020,0x21186210,0x84210842,0x10302190,0x24090240,0x88461084,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x4c240182,

       0x80001001,0x6b02000,0x20,0x4c810010,0x78220846,0x10081e10,0x20c0301c,0x1fe0e018,0x4d8487e1,0x409fe7,0xf9007f82,0x11a040,

       0x13248902,0x41102418,0xe0081022,0x11320c05,0x402008,0x1000000,0x2409,0x409020,0x81024082,0x412008,0x9240902,0x40902101,0x101022,

       0x11321208,0x40102008,0x2000000,0x7e0c8000,0xfc000003,0xf0fc0018,0x43802047,0x8c8040c8,0x32008300,0x44240000,0x0,0x4000048,

       0x8c801050,0x20440,0x40221dc0,0x808c0028,0x11d0667f,0x8009c400,0x1fc180,0x4001023,0xc8300002,0x1e0ccfb,0x3ec7b020,0x12048120,

       0x48120482,0x79007f9f,0xe7f9fe08,0x2008020,0xf0922409,0x2409024,0x8504490,0x24090240,0x85040920,0x802008,0x2008020,0x89004090,

       0x24090208,0x2008020,0x40902409,0x2409024,0x8304390,0x24090240,0x88440884,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,

       0x481c0606,0xc8001001,0x802000,0x20,0x4c810020,0x4220024,0x8102108,0x60000070,0x3820,0x48884419,0x409004,0x10e4082,0x112040,

       0x13244902,0x7e1027e0,0x3c081021,0x21320c02,0x802008,0x1000000,0x7e409,0x409020,0x81024082,0x414008,0x9240902,0x40902101,

       0x80101022,0x11320c08,0x40202008,0x2038800,0x200bc000,0x20000000,0x80200003,0x80f04044,0xbc080bc,0x2f000200,0x0,0x0,0x6001048,

       0x8bc02020,0x20441,0xf8220200,0x80820028,0x1000cc00,0x80094400,0x201e0,0x78001021,0xc830000f,0x8000663c,0xf03c0c0,0x21084210,

       0x84210846,0x41004010,0x4010008,0x2008020,0x40912409,0x2409024,0x8204890,0x24090240,0x82040930,0x1f87e1f8,0x7e1f87e0,0x89004090,

       0x24090208,0x2008020,0x40902409,0x2409024,0x8004690,0x24090240,0x88440884,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,

       0x480719c4,0x48001001,0x81fc00,0x7800020,0x40810040,0x2420024,0x8104087,0xa0000070,0x3820,0x48884409,0x409004,0x1024082,0x111040,

       0x13244902,0x40102410,0x2081021,0x214a1202,0x1802008,0x1000000,0x182409,0x409fe0,0x81024082,0x41a008,0x9240902,0x40902100,

       0xf8101021,0x214a0c04,0x80c0c008,0x1847000,0x7c1ee000,0x20000000,0x8020000c,0x8c044,0x1ee181ee,0x7b800000,0x707,0xf3ff0000,

       0x3e0084f,0x9ee0c020,0x20440,0x40221fc0,0xc2002c,0x13f11000,0x87892400,0x20000,0x1020,0x48000000,0x3f011c6,0x31cc6180,0x21084210,

       0x84210844,0x41004010,0x4010008,0x2008020,0x40912409,0x2409024,0x8505090,0x24090240,0x8204191c,0x60982609,0x82609823,0xf9007f9f,

       0xe7f9fe08,0x2008020,0x40902409,0x2409024,0x9fe4c90,0x24090240,0x84840848,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xfe048224,

       0x28001001,0x2000,0x40,0x40810080,0x27f8024,0x8104080,0x2000001c,0x1fe0e020,0x488fc409,0x409004,0x1024082,0x110840,0x10242902,

       0x40102408,0x2081021,0x214a1202,0x1002004,0x1000000,0x102409,0x409000,0x81024082,0x411008,0x9240902,0x40902100,0x6101021,

       0x214a0c04,0x81002008,0x2000000,0x201dc000,0x20000000,0x80200000,0x98044,0x1dc101dc,0x77000000,0x700,0x0,0x180448,0x1dc10020,

       0x20440,0x403e0200,0x620017,0xa000cc00,0x80052800,0x20000,0x1020,0x48000000,0x6606,0x206100,0x3f0fc3f0,0xfc3f0fc7,0xc1004010,

       0x4010008,0x2008020,0x4090a409,0x2409024,0x8886090,0x24090240,0x8207e106,0x40902409,0x2409024,0x81004010,0x4010008,0x2008020,

       0x40902409,0x2409024,0x8005890,0x24090240,0x84840848,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98048224,0x30001001,0x2000,

       0x40,0x21010100,0x2020024,0x8204080,0x40000007,0x80078000,0x48884408,0x80411004,0x824082,0x110840,0x10242986,0x40086409,0x2081021,

       0xe14a2102,0x2002004,0x1000000,0x106409,0x409000,0x81024082,0x410808,0x9240902,0x40902100,0x2101021,0x214a1202,0x82002008,

       0x2000000,0x300f8000,0x20000000,0x80fc001d,0xe4088044,0xf8200f8,0x3e000000,0x300,0x0,0x80c48,0xf820020,0x20640,0x40410200,

       0x803c0018,0x60006600,0x61800,0x0,0x1020,0x48000000,0xcc0a,0x20a100,0x21084210,0x84210844,0x40804010,0x4010008,0x2008020,

       0x4110a619,0x86619866,0x19046110,0x24090240,0x82040102,0x41906419,0x6419064,0x81004010,0x4010008,0x2008020,0x40902409,0x2409024,

       0x8307090,0x24090240,0x82840828,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x90248222,0x30000802,0x200c,0xc080,0x21010301,

       0x4021042,0x10202108,0xc0c03000,0x80040020,0x4d902418,0xc6431004,0xc24082,0x6210440,0x10241884,0x40084409,0x86080840,0xc0842102,

       0x4002002,0x1000000,0x18e610,0x84218820,0x80864082,0x410408,0x9240884,0x61086101,0x6101860,0xc0842103,0x4002008,0x2000000,

       0x10850180,0x20330000,0x80200013,0x26184024,0x5040050,0x14000000,0x0,0x0,0x4180848,0x85040020,0x20350,0x40000200,0x800c0007,

       0x80002200,0x1e000,0x0,0x1860,0x48000000,0x880a,0x40a188,0x40902409,0x2409028,0x40c64010,0x4010008,0x2008020,0x43106210,0x84210842,

       0x10006108,0x42108421,0x2040102,0x6398e639,0x8e6398e4,0x88842088,0x22088208,0x2008020,0x21102210,0x84210842,0x10306118,0x66198661,

       0x83061030,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20001,0x901f01c1,0xe8000802,0xc,0xc080,0x1e07c7f8,0xf8020f81,0xe0401e07,

       0x80c03000,0x20,0x279027e0,0x3c7c1fe4,0x3c408f,0x83c1027f,0x90241878,0x4007c404,0xf8080780,0xc0844082,0x7f82002,0x1000000,

       0xfa5e0,0x781e87c0,0x807a409f,0xc0410207,0x9240878,0x5e07a100,0xf80e0fa0,0xc0846183,0x7f82008,0x2000000,0xf020100,0x40321360,

       0x80200014,0xa3e0201f,0x8207f820,0x8000000,0x0,0x0,0x3e01037,0x207f820,0x201e1,0xfc000200,0x80040000,0x0,0x0,0x1fc000,0x17b0,

       0x48000000,0x12,0xc120f0,0x40902409,0x2409028,0x783c7f9f,0xe7f9fe3e,0xf83e0f8,0x7c1061e0,0x781e0781,0xe000be07,0x81e0781e,

       0x204017c,0x3e8fa3e8,0xfa3e8fa3,0x70781f07,0xc1f07c7f,0x1fc7f1fc,0x1e1021e0,0x781e0781,0xe0007e0f,0xa3e8fa3e,0x8305e030,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0xc06,0xc,0x100,0x0,0x0,0x0,0x3000,0x0,0x20000000,0x0,0x0,0x0,0x0,0xc000,

       0x0,0x0,0x2001,0x1000000,0x0,0x0,0x20000,0x400000,0x0,0x40002000,0x0,0x1,0x2008,0x2000000,0x100,0x40240000,0x80200008,0x40000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x80040000,0x0,0x0,0x0,0x1000,0x48000000,0x1f,0x181f000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1040010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x60c,0x18,0x0,

       0x0,0x0,0x0,0x6000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x3800,0x7000000,0x0,0x0,0x840000,0x400000,0x0,0x40002000,

       0x0,0x2,0x2008,0x2000000,0x200,0x40440000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x80780000,0x0,0x0,0x0,0x1000,0x48000400,

       0x2,0x1e02000,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x2040020,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x4000,0x0,0xf000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x780000,0x3800000,0x0,0x40002000,0x0,0xe,0x1808,0xc000000,0x3,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,

       0x0,0x0,0x0,0x1000,0x1c00,0x0,0x0,0x0,0x0,0x380000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x380000,0x0,0x0,0x0,0x0,0x0,0x0,0xe0400e0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3fc,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 12x24 font.

     const unsigned int font12x24[12*24*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x19,0x80000000,0x198000,0x0,0x0,0x0,0x0,

       0x0,0x198,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc001806,0xc81980,0x60000000,0xc001806,0x1980c00,0x18060198,0xc80c,

       0x180600,0xc8198000,0xc001,0x80601980,0x18000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0xf0000,0x0,0x0,0x0,0x0,0x0,0x198,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x600300f,0x1301980,0x90000000,0x600300f,0x1980600,0x300f0198,0x13006,0x300f01,0x30198000,0x6003,

       0xf01980,0x30000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x60000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7007,0x3c0000,0x3006019,

       0x80000000,0x90000000,0x3006019,0x80000300,0x60198000,0x3,0x601980,0x0,0x3006,0x1980000,0x60000000,0x0,0x0,0xe0000000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000000,

       0x0,0x0,0x0,0x0,0x0,0xc800019,0x80000000,0x198000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x1001,0x420000,0x0,0x0,0x90000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18000c06,0xc80001,0x10000000,0x18000c06,0x1800,0xc060000,0xc818,0xc0600,0xc8000000,

       0x18000,0xc0600000,0xc000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6019,0x80660207,0x800f8060,0x300c004,0x0,0x6,

       0xe00703f,0x3f00383,0xf80f07fc,0x1f01f000,0x0,0xf8,0x607f,0x7c7e07,0xfe7fe0f8,0x6063fc1f,0x86066007,0xe7060f0,0x7f80f07f,

       0x81f8fff6,0x6606c03,0x70ee077f,0xe0786000,0xf0070000,0xc000060,0xc0,0x3e000,0x60006003,0x600fc00,0x0,0x0,0x0,0x0,0x0,0x3c0603,

       0xc0000000,0x7800000,0xf0000,0x0,0xf00001f,0x80001fe0,0x7fe000,0x0,0x0,0x0,0x168fe609,0x0,0x90e07,0x6000,0x3c000e,0x70000f8,

       0x1980001f,0x0,0x1f8,0xf00000f,0xf00180,0xfe000,0xe00e,0x1001,0x20060,0x6006006,0x600600,0x600fe07c,0x7fe7fe7f,0xe7fe3fc3,

       0xfc3fc3fc,0x7e07060f,0xf00f00,0xf00f0000,0xf360660,0x6606606e,0x76001e0,0xc00180f,0x1681981,0x10000000,0xc00180f,0x1980c00,

       0x180f0198,0x3801680c,0x180f01,0x68198000,0xc001,0x80f01980,0x18600198,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6019,

       0x8044020c,0xc01f8060,0x2004004,0x0,0xc,0x3f81f07f,0x87f80383,0xf81f87fc,0x3f83f800,0x0,0x1fc,0x780607f,0x81fe7f87,0xfe7fe1fc,

       0x6063fc1f,0x860c6007,0xe7061f8,0x7fc1f87f,0xc3fcfff6,0x6606c03,0x30c6067f,0xe0783000,0xf00d8000,0x6000060,0xc0,0x7e000,0x60006003,

       0x600fc00,0x0,0x0,0xc00,0x0,0x0,0x7c0603,0xe0000000,0xfc00000,0x1f0000,0x0,0x900003f,0xc0003fe0,0x7fe000,0x0,0x0,0x0,0x1302660f,

       0x0,0xf0606,0x6004,0x7e0006,0x60601f8,0x19800001,0x80000000,0x1f8,0x19800010,0x81080300,0x3f2000,0x2011,0x1001,0x1c0060,0x6006006,

       0x600600,0x601fe1fe,0x7fe7fe7f,0xe7fe3fc3,0xfc3fc3fc,0x7f87061f,0x81f81f81,0xf81f8000,0x3fa60660,0x66066066,0x66003f0,0x6003009,

       0x1301981,0x10000000,0x6003009,0x1980600,0x30090198,0x1f013006,0x300901,0x30198000,0x6003,0x901980,0x30600198,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6019,0x80cc0f8c,0xc0180060,0x6006044,0x40000000,0xc,0x3181b041,0xc41c0783,0x388018,

       0x71c71800,0x0,0x106,0x18c0f061,0xc38261c6,0x600384,0x60606001,0x86186007,0xe78630c,0x60e30c60,0xe7040606,0x630cc03,0x39c30c00,

       0xc0603000,0x3018c000,0x3000060,0xc0,0x60000,0x60000000,0x6000c00,0x0,0x0,0xc00,0x0,0x0,0x600600,0x60000000,0x18400000,0x180000,

       0x0,0x19800070,0x40003600,0xc000,0x0,0x0,0x0,0x25a06,0x0,0x6030c,0x4,0xe20007,0xe060180,0xf000,0x80000000,0xf0000,0x10800000,

       0x80080600,0x7f2000,0x2020,0x80001001,0x20000,0xf00f00f,0xf00f00,0x601b0382,0x60060060,0x6000600,0x60060060,0x61c78630,0xc30c30c3,

       0xc30c000,0x30e60660,0x66066063,0xc600738,0x3006019,0x80000000,0xe0000000,0x3006019,0x80000300,0x60198000,0x3e000003,0x601980,

       0x0,0x3006,0x1980000,0x60600000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6019,0x80cc1fcc,0xc0180060,0x6006035,0x80000000,

       0x18,0x71c03000,0xc00c0583,0x300018,0x60c60c00,0x0,0x6,0x3060f060,0xc30060c6,0x600300,0x60606001,0x86306007,0x9e78670e,0x60670e60,

       0x66000606,0x630c606,0x19830c01,0xc0601800,0x30306000,0x60,0xc0,0x60000,0x60000000,0x6000c00,0x0,0x0,0xc00,0x0,0x0,0x600600,

       0x60000000,0x18000000,0x300000,0x0,0x78060,0x6600,0x1c000,0x300c,0x39819c0,0x0,0x25a00,0x0,0x30c,0x4,0xc00003,0xc060180,0x30c1f,

       0x80000000,0x30c000,0x10800001,0x80700000,0x7f2000,0x2020,0x80001001,0x20060,0xf00f00f,0xf00f00,0xf01b0300,0x60060060,0x6000600,

       0x60060060,0x60c78670,0xe70e70e7,0xe70e000,0x70c60660,0x66066063,0xc7f8618,0x0,0x0,0x0,0x0,0x0,0x0,0x7000000,0x0,0x0,0x0,

       0x0,0x600000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6019,0x87ff3a4c,0xc0180060,0x400600e,0x600000,0x18,0x60c03000,

       0xc00c0d83,0x700018,0x60c60c00,0x20,0x400006,0x3060f060,0xc6006066,0x600600,0x60606001,0x86606006,0x966c6606,0x60660660,0x66000606,

       0x630c666,0xf019801,0x80601800,0x30603000,0x1f06f,0xf01ec0,0xf03fe1ec,0x6703e01f,0x61c0c06,0xdc6701f0,0x6f01ec0c,0xe1f87fc6,

       0xc60cc03,0x71c60c7f,0xc0600600,0x60000000,0x30000000,0x300000,0x40040,0x88060,0x6600,0x18000,0x300c,0x1981980,0x0,0x2421f,

       0x80003ce0,0x7fc198,0x601f,0xc02021,0x980600c0,0x40230,0x80000000,0x402000,0x19806003,0x80006,0xc7f2000,0x2020,0x80001001,

       0x420060,0xf00f00f,0xf00f00,0xf01b0600,0x60060060,0x6000600,0x60060060,0x6066c660,0x66066066,0x6606208,0x60e60660,0x66066061,

       0x987fc670,0x1f01f01f,0x1f01f01,0xf039c0f0,0xf00f00f,0xf03e03,0xe03e03e0,0x1f06701f,0x1f01f01,0xf01f0060,0x1e660c60,0xc60c60c6,

       0xc6f060c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x7ff3207,0x8c0c0000,0xc00300e,0x600000,0x30,0x60c03000,

       0xc01c0983,0xf0600030,0x31860c06,0x6001e0,0x78000e,0x23e1f861,0xc6006066,0x600600,0x60606001,0x86c06006,0x966c6606,0x60660660,

       0xe7000606,0x630c666,0xf01f803,0x600c00,0x30000000,0x3f87f,0x83f83fc3,0xf83fe3fc,0x7f83e01f,0x6380c07,0xfe7f83f8,0x7f83fc0d,

       0xf3fc7fc6,0xc71cc03,0x3183187f,0xc0600600,0x60000000,0xff806000,0x300000,0x40040,0x88070,0x6600,0x60030060,0x6001818,0x1883180,

       0x0,0x2423f,0xc0007ff0,0x607fc1f8,0x603f,0x80c01fc1,0xf80601e0,0x5f220,0x80420000,0x5f2000,0xf006006,0x80006,0xc7f2000,0x2020,

       0x82107c07,0xc03c0060,0x1f81f81f,0x81f81f80,0xf03b0600,0x60060060,0x6000600,0x60060060,0x6066c660,0x66066066,0x660671c,0x61660660,

       0x66066061,0xf860e6c0,0x3f83f83f,0x83f83f83,0xf87fe3f8,0x3f83f83f,0x83f83e03,0xe03e03e0,0x3f87f83f,0x83f83f83,0xf83f8060,

       0x3fc60c60,0xc60c60c3,0x187f8318,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x883200,0x300c0000,0xc003035,0x80600000,

       0x30,0x66c03001,0xc0f81983,0xf86f0030,0x1f071c06,0x600787,0xfe1e001c,0x6261987f,0x86006067,0xfe7fc600,0x7fe06001,0x87c06006,

       0xf6646606,0x60e6067f,0xc3e00606,0x61986f6,0x600f007,0x600c00,0x30000000,0x21c71,0x830831c3,0x1c06031c,0x71c06003,0x6700c06,

       0x6671c318,0x71831c0f,0x16040c06,0xc318606,0x1b031803,0x80600600,0x60000000,0x30009000,0x300000,0x40040,0x7003e,0x67e0,0x90070090,

       0x9001818,0x8c3100,0x0,0x60,0x4000e730,0x900380f0,0x6034,0x80c018c7,0xfe060338,0xb0121,0x80c60000,0x909000,0x6008,0x1080006,

       0xc3f2000,0x2011,0x3180060,0x60060e0,0x19819819,0x81981981,0x9833c600,0x7fe7fe7f,0xe7fe0600,0x60060060,0x60664660,0x66066066,

       0x66063b8,0x62660660,0x66066060,0xf06066c0,0x21c21c21,0xc21c21c2,0x1c466308,0x31c31c31,0xc31c0600,0x60060060,0x31871c31,0x83183183,

       0x18318000,0x71860c60,0xc60c60c3,0x18718318,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x1981a00,0xe03e0000,0xc003044,

       0x40600000,0x60,0x66c03001,0x80f03182,0x1c7f8030,0x3f83fc06,0x601e07,0xfe078038,0x6661987f,0x86006067,0xfe7fc61e,0x7fe06001,

       0x87e06006,0x66666606,0x7fc6067f,0x81f80606,0x61986f6,0x6006006,0x600600,0x30000000,0xc60,0xc60060c6,0xc06060c,0x60c06003,

       0x6e00c06,0x6660c60c,0x60c60c0e,0x6000c06,0xc318666,0x1f031803,0x600600,0x603c2000,0x30016800,0x1fe0000,0x1f81f8,0x1c1f,0x804067e1,

       0x68060168,0x16800810,0xc42300,0x0,0x60,0x20c331,0x68030060,0x6064,0x3fc1040,0xf006031c,0xa011e,0x818c7fe0,0x909000,0x7fe1f,

       0x80f00006,0xc0f2060,0xf80e,0x18c0780,0x780781c0,0x19819819,0x81981981,0x9833c600,0x7fe7fe7f,0xe7fe0600,0x60060060,0xfc666660,

       0x66066066,0x66061f0,0x66660660,0x66066060,0x606066e0,0xc00c00,0xc00c00c0,0xc066600,0x60c60c60,0xc60c0600,0x60060060,0x60c60c60,

       0xc60c60c6,0xc60c000,0x61c60c60,0xc60c60c3,0x1860c318,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x1980f81,0x80373000,

       0xc003004,0x7fe0001,0xf0000060,0x60c03003,0x183180,0xc71c060,0x3181ec00,0x7000,0xe070,0x66619860,0xc6006066,0x60061e,0x60606001,

       0x87606006,0x66626606,0x7f860661,0xc01c0606,0x6198696,0xf00600e,0x600600,0x30000000,0x1fc60,0xc60060c7,0xfc06060c,0x60c06003,

       0x7c00c06,0x6660c60c,0x60c60c0c,0x7f00c06,0xc3b8666,0xe01b007,0x3c00600,0x3c7fe000,0xff03ec00,0x1fe0000,0x40040,0xe001,0xc0806603,

       0xec0e03ec,0x3ec00010,0x0,0x60000000,0x7f,0x10c3f3,0xec070060,0x6064,0x3fc1040,0x6000030c,0xa0100,0x3187fe1,0xf09f1000,0x7fe00,

       0x6,0xc012060,0x0,0xc63c03,0xc03c0380,0x19819819,0x81981981,0x98330600,0x60060060,0x6000600,0x60060060,0xfc662660,0x66066066,

       0x66060e0,0x6c660660,0x66066060,0x6060e630,0x1fc1fc1f,0xc1fc1fc1,0xfc3fe600,0x7fc7fc7f,0xc7fc0600,0x60060060,0x60c60c60,0xc60c60c6,

       0xc60c7fe,0x62c60c60,0xc60c60c1,0xb060c1b0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0xffe02c6,0x3c633000,0xc003004,

       0x7fe0001,0xf00000c0,0x60c03006,0xc6180,0xc60c060,0x60c00c00,0x7000,0xe060,0x66639c60,0x66006066,0x600606,0x60606001,0x86306006,

       0x66636606,0x60060660,0xc0060606,0x61f8696,0xf00600c,0x600300,0x30000000,0x3fc60,0xc60060c7,0xfc06060c,0x60c06003,0x7c00c06,

       0x6660c60c,0x60c60c0c,0x1f80c06,0xc1b0666,0xe01b00e,0x3c00600,0x3c43c000,0x3007de00,0x600000,0x40040,0x30000,0x61006607,0xde0c07de,

       0x7de00000,0x0,0xf07fefff,0x1f,0x8008c3f7,0xde0e0060,0x6064,0xc01047,0xfe00018c,0xb013f,0x86300061,0xf0911000,0x6000,0x6,

       0xc012060,0x3f,0x8063c0cc,0x3cc0c700,0x39c39c39,0xc39c39c1,0x98630600,0x60060060,0x6000600,0x60060060,0x60663660,0x66066066,

       0x66061f0,0x78660660,0x66066060,0x607fc618,0x3fc3fc3f,0xc3fc3fc3,0xfc7fe600,0x7fc7fc7f,0xc7fc0600,0x60060060,0x60c60c60,0xc60c60c6,

       0xc60c7fe,0x64c60c60,0xc60c60c1,0xb060c1b0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0xffe0260,0x6661b000,0xc003000,

       0x600000,0xc0,0x60c0300c,0xc7fe0,0xc60c060,0x60c01c00,0x1e07,0xfe078060,0x6663fc60,0x66006066,0x600606,0x60606001,0x86386006,

       0x6636606,0x60060660,0xe0060606,0x60f039c,0x1b806018,0x600300,0x30000000,0x70c60,0xc60060c6,0x6060c,0x60c06003,0x7600c06,

       0x6660c60c,0x60c60c0c,0x1c0c06,0xc1b03fc,0xe01f01c,0xe00600,0x70000000,0x3007fc00,0x600000,0x40040,0x0,0x62006607,0xfc1807fc,

       0x7fc00000,0x0,0xf0000000,0x1,0xc004c307,0xfc1c0060,0x6064,0xc018c0,0x600000d8,0x5f200,0x3180060,0x50a000,0x6000,0x6,0xc012000,

       0x0,0xc601c0,0x4201c600,0x3fc3fc3f,0xc3fc3fc3,0xfc7f0600,0x60060060,0x6000600,0x60060060,0x60663660,0x66066066,0x66063b8,

       0x70660660,0x66066060,0x607f860c,0x70c70c70,0xc70c70c7,0xcc60600,0x60060060,0x6000600,0x60060060,0x60c60c60,0xc60c60c6,0xc60c000,

       0x68c60c60,0xc60c60c1,0xf060c1f0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3300260,0x6661e000,0xc003000,0x600000,

       0x180,0x71c03018,0xc7fe0,0xc60c0c0,0x60c01800,0x787,0xfe1e0060,0x6663fc60,0x630060c6,0x600306,0x60606001,0x86186006,0x661e70e,

       0x60070c60,0x60060606,0x60f039c,0x19806038,0x600180,0x30000000,0x60c60,0xc60060c6,0x6060c,0x60c06003,0x6700c06,0x6660c60c,

       0x60c60c0c,0xc0c06,0xc1b039c,0x1f00e018,0x600600,0x60000000,0x1803f800,0x600000,0x40040,0x39e00,0x63006603,0xf83803f8,0x3f800000,

       0x0,0x60000000,0x0,0xc00cc303,0xf8180060,0x6064,0xc01fc0,0x60060070,0x40200,0x18c0060,0x402000,0x6000,0x6,0xc012000,0x0,0x18c0140,

       0x2014600,0x3fc3fc3f,0xc3fc3fc3,0xfc7f0300,0x60060060,0x6000600,0x60060060,0x60c61e70,0xe70e70e7,0xe70e71c,0x60e60660,0x66066060,

       0x6060060c,0x60c60c60,0xc60c60c6,0xcc60600,0x60060060,0x6000600,0x60060060,0x60c60c60,0xc60c60c6,0xc60c000,0x70c60c60,0xc60c60c0,

       0xe060c0e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33022e0,0x6670c000,0xc003000,0x600600,0x60180,0x31803030,

       0x41c0184,0x1831c0c0,0x71c23806,0x6001e0,0x780000,0x62630c60,0xe38261c6,0x600386,0x60606043,0x860c6006,0x661e30c,0x60030c60,

       0x740e0607,0xe0f039c,0x31c06030,0x600180,0x30000000,0x61c71,0x830831c3,0x406031c,0x60c06003,0x6300c06,0x6660c318,0x71831c0c,

       0x41c0c07,0x1c0e039c,0x1b00e030,0x600600,0x60000000,0x1c41b00e,0x601cc0,0x401f8,0x45240,0xe1803601,0xb03001b0,0x1b000000,

       0x0,0x0,0x41,0xc008e711,0xb0300060,0x6034,0x80c02020,0x60060030,0x30c00,0xc60000,0x30c000,0x0,0x7,0x1c012000,0x0,0x3180240,

       0x6024608,0x30c30c30,0xc30c30c3,0xc630382,0x60060060,0x6000600,0x60060060,0x61c61e30,0xc30c30c3,0xc30c208,0x70c70e70,0xe70e70e0,

       0x6060068c,0x61c61c61,0xc61c61c6,0x1cc62308,0x30430430,0x43040600,0x60060060,0x31860c31,0x83183183,0x18318060,0x31c71c71,

       0xc71c71c0,0xe07180e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x2203fc0,0x663f6000,0x6006000,0x600600,0x60300,

       0x3f81fe7f,0xc7f80187,0xf83f80c0,0x3f83f006,0x600020,0x400060,0x33e6067f,0xc1fe7f87,0xfe6001fe,0x6063fc7f,0x60e7fe6,0x660e3f8,

       0x6001f860,0x37fc0603,0xfc06030c,0x30c0607f,0xe06000c0,0x30000000,0x7fc7f,0x83f83fc3,0xfc0603fc,0x60c7fe03,0x61807c6,0x6660c3f8,

       0x7f83fc0c,0x7f80fc3,0xfc0e039c,0x3180607f,0xc0600600,0x60000000,0xfc0e00c,0x601986,0x66040040,0x4527f,0xc0803fe0,0xe07fe0e0,

       0xe000000,0x0,0x0,0x7f,0x80107ff0,0xe07fc060,0x603f,0x83fe0000,0x60060018,0xf000,0x420000,0xf0000,0x7fe00,0x7,0xfe012000,

       0x0,0x2100640,0xc0643f8,0x60660660,0x66066067,0xec3e1fe,0x7fe7fe7f,0xe7fe3fc3,0xfc3fc3fc,0x7f860e3f,0x83f83f83,0xf83f8000,

       0x5fc3fc3f,0xc3fc3fc0,0x606006fc,0x7fc7fc7f,0xc7fc7fc7,0xfcffe3f8,0x3fc3fc3f,0xc3fc7fe7,0xfe7fe7fe,0x3f860c3f,0x83f83f83,

       0xf83f8060,0x7f83fc3f,0xc3fc3fc0,0x607f8060,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x2201f80,0x3c1e7000,0x6006000,

       0x600,0x60300,0xe01fe7f,0xc3f00183,0xe01f0180,0x1f01e006,0x600000,0x60,0x3006067f,0x807c7e07,0xfe6000f8,0x6063fc3e,0x6067fe6,

       0x660e0f0,0x6000f060,0x3bf80601,0xf806030c,0x60e0607f,0xe06000c0,0x30000000,0x1ec6f,0xf01ec0,0xf80601ec,0x60c7fe03,0x61c03c6,

       0x6660c1f0,0x6f01ec0c,0x3f007c1,0xcc0e030c,0x71c0c07f,0xc0600600,0x60000000,0x7804018,0xe01186,0x66040040,0x39e3f,0x80401fe0,

       0x407fe040,0x4000000,0x0,0x0,0x3f,0x203ce0,0x407fc060,0x601f,0x3fe0000,0x60060018,0x0,0x0,0x0,0x7fe00,0x6,0xe6012000,0x0,

       0x7e0,0x1807e1f0,0x60660660,0x66066066,0x6c3e07c,0x7fe7fe7f,0xe7fe3fc3,0xfc3fc3fc,0x7e060e0f,0xf00f00,0xf00f0000,0x8f01f81f,

       0x81f81f80,0x60600670,0x1ec1ec1e,0xc1ec1ec1,0xec79c0f0,0xf80f80f,0x80f87fe7,0xfe7fe7fe,0x1f060c1f,0x1f01f01,0xf01f0000,0x4f01cc1c,

       0xc1cc1cc0,0xc06f00c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x6006000,0x600,0x600,0x0,0x0,0x0,0x0,

       0x600000,0x0,0x18000000,0x0,0x0,0x0,0x0,0x0,0x1800,0x0,0x0,0x0,0x600060,0x30000000,0x0,0x0,0xc,0x3,0x0,0x0,0x60000c00,0x0,

       0x0,0xc000,0x600600,0x60000000,0x18,0xc03100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x601f8,0x0,0x0,0x0,0x0,0x6,

       0x12000,0x2000000,0x40,0x20004000,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0xc06000c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x2004000,0xc00,0x0,0x0,0x0,0x0,0x0,0xc00000,

       0x0,0x1c000000,0x0,0x0,0x0,0x0,0x0,0xc00,0x0,0x0,0x0,0x780000,0xf0000000,0x0,0x0,0x21c,0x3,0x0,0x0,0x60000c00,0x0,0x0,0xc000,

       0x7c0603,0xe0000000,0x10,0xc02300,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x601f0,0x0,0x0,0x0,0x0,0x6,0x12000,0x1000000,

       0x40,0x7e004000,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc06000c0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x300c000,0xc00,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x7800000,0x0,

       0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x780000,0xf0000000,0x0,0x0,0x3f8,0x3e,0x0,0x0,0x60000c00,0x0,0x0,0x38000,0x3c0603,0xc0000000,

       0x10,0xfc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x60000,0x0,0x0,0x0,0x0,0x6,0x0,0x1000000,0x0,0x0,0x0,0x0,

       0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x80600380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc,0x0,

       0x0,0x1f0,0x3c,0x0,0x0,0x60000c00,0x0,0x0,0x38000,0x600,0x0,0x0,0xf000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x6,0x0,0xe000000,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x3,0x80600380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 16x32 font.

     const unsigned int font16x32[16*32*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc300000,0x0,0xc300000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70000e0,0x3c00730,0xe7001c0,0x0,0x70000e0,0x3c00e70,0x70000e0,0x3c00e70,0x730,0x70000e0,0x3c00730,

       0xe700000,0x700,0xe003c0,0xe7000e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x6600000,0x0,0x6600000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x18001c0,0x6600ff0,0xe7003e0,0x0,0x18001c0,0x6600e70,0x18001c0,0x6600e70,0xff0,0x18001c0,0x6600ff0,0xe700000,0x180,

       0x1c00660,0xe7001c0,0x0,0x0,0x0,0x380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,

       0x0,0x3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c00380,

       0xc300ce0,0xe700630,0x0,0x1c00380,0xc300e70,0x1c00380,0xc300e70,0xce0,0x1c00380,0xc300ce0,0xe700000,0x1c0,0x3800c30,0xe700380,

       0x0,0x0,0x0,0x7c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0xe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1800000,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0xc300000,0x0,0xc300000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x700000,0x0,0x0,0x0,0x7c007c00,0x3e000000,

       0x0,0x0,0x630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe000070,0x1800000,0xc60,0x0,0xe000070,0x1800000,0xe000070,

       0x1800000,0x0,0xe000070,0x1800000,0x0,0xe00,0x700180,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x800000,0x0,0x600600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x3f0,0xfc0,0x0,0x7000000,0x38000000,0x1c0000,0xfc0000,0x380001c0,0xe01c00,0x7f800000,0x0,0x0,0x0,0x0,0x0,0x0,0x7c,

       0x1801f00,0x0,0x0,0x1c,0x0,0x0,0x3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7300000,0x6600000,0x0,0x6600000,0x0,0x0,0x0,0x0,0xe700000,

       0x0,0x0,0x0,0x0,0x0,0xe00000,0x0,0x0,0x0,0xc000c00,0x43800000,0x0,0x0,0x630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0xf80,0x70000e0,0x3c00730,0xe700c60,0x0,0x70000e0,0x3c00e70,0x70000e0,0x3c00e70,0xe000730,0x70000e0,0x3c00730,0xe700000,0x700,

       0xe003c0,0xe7000e0,0x38000e70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x6300000,0x803c00,0x7c00180,

       0xc00300,0x1000000,0x0,0x1c,0x3c007c0,0xfc007e0,0xe01ff8,0x3f03ffc,0x7e007c0,0x0,0x0,0x7c0,0x1c0,0x7f8003f0,0x7f007ff8,0x7ff803f0,

       0x70381ffc,0xff0700e,0x7000783c,0x783807c0,0x7fc007c0,0x7fc00fc0,0x7fff7038,0x700ee007,0x780f780f,0x7ffc03f0,0x70000fc0,0x3c00000,

       0x3000000,0x38000000,0x1c0000,0x1fc0000,0x380001c0,0xe01c00,0x7f800000,0x0,0x0,0x0,0x0,0x0,0x0,0xfc,0x1801f80,0x0,0x1f80000,

       0x7e,0x0,0x0,0x2400000,0xfc00000,0x7ff0000,0x7ffc0000,0x0,0x0,0x0,0x0,0xf30fb0c,0x2400000,0x0,0x240780f,0x1c0,0xfc,0x780f,

       0x18003f0,0xe700000,0x7c00000,0x0,0xff0,0x3c00000,0x78007c0,0xc00000,0xff80000,0xf80,0x7c00000,0xc000c00,0x18001c0,0x1c001c0,

       0x1c001c0,0x1c003e0,0x7fe03f0,0x7ff87ff8,0x7ff87ff8,0x1ffc1ffc,0x1ffc1ffc,0x7f007838,0x7c007c0,0x7c007c0,0x7c00000,0x7c67038,

       0x70387038,0x7038780f,0x70001fe0,0x30000c0,0x2400f30,0xe700c60,0x0,0x30000c0,0x2400e70,0x30000c0,0x2400e70,0xf700f30,0x30000c0,

       0x2400f30,0xe700000,0x300,0xc00240,0xe7000c0,0x38000e70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,

       0x630018c,0x807e00,0xfe00180,0xc00300,0x1000000,0x0,0x38,0xff01fc0,0x3ff01ff0,0x1e01ff8,0x7f83ffc,0x1ff80ff0,0x0,0x0,0xff0,

       0x1f003e0,0x7fe00ff8,0x7fc07ff8,0x7ff80ff8,0x70381ffc,0xff0701c,0x7000783c,0x78381ff0,0x7fe01ff0,0x7fe01ff0,0x7fff7038,0x781ee007,

       0x3c1e380e,0x7ffc0380,0x380001c0,0x3c00000,0x1800000,0x38000000,0x1c0000,0x3c00000,0x380001c0,0xe01c00,0x3800000,0x0,0x0,

       0x0,0x7000000,0x0,0x0,0x1e0,0x18003c0,0x0,0x3fc0000,0x70,0x0,0x0,0x6600000,0x1ff00000,0x1fff0000,0x7ffc0000,0x0,0x0,0x0,0x0,

       0xcf0239c,0x3c00000,0x0,0x3c0380e,0x1c0,0x2001fe,0x380e,0x18007f8,0xe700000,0x8600000,0x0,0xff0,0x7e00000,0x8c00870,0x1800000,

       0x1ff80000,0x180,0xc600000,0xc000c00,0x38001c0,0x3e003e0,0x3e003e0,0x3e001c0,0x7fe0ff8,0x7ff87ff8,0x7ff87ff8,0x1ffc1ffc,0x1ffc1ffc,

       0x7fc07838,0x1ff01ff0,0x1ff01ff0,0x1ff00000,0x1fec7038,0x70387038,0x7038380e,0x70003ce0,0x1800180,0x6600cf0,0xe7007c0,0x0,

       0x1800180,0x6600e70,0x1800180,0x6600e70,0x7c00cf0,0x1800180,0x6600cf0,0xe700000,0x180,0x1800660,0xe700180,0x38000e70,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x630030c,0x3f0e700,0x1e200180,0x1800180,0x21100000,0x0,

       0x38,0x1e7819c0,0x38781038,0x1e01c00,0xf080038,0x1c381c38,0x0,0x0,0x1878,0x7fc03e0,0x70e01e18,0x70e07000,0x70001e18,0x703801c0,

       0x707038,0x70007c7c,0x7c381c70,0x70701c70,0x70703830,0x1c07038,0x381ce007,0x1c1c3c1e,0x3c0380,0x380001c0,0x7e00000,0xc00000,

       0x38000000,0x1c0000,0x3800000,0x38000000,0x1c00,0x3800000,0x0,0x0,0x0,0x7000000,0x0,0x0,0x1c0,0x18001c0,0x0,0x70c0000,0xe0,

       0x0,0x0,0xc300000,0x38300000,0x3c700000,0x3c0000,0x0,0x0,0x0,0x0,0xce022f4,0x1800000,0x0,0x1803c1e,0x1c0,0x2003c2,0x3c1e,

       0x1800e08,0x7e0,0x300000,0x0,0x7e00000,0xe700000,0x600030,0x3000000,0x3f980000,0x180,0x18200000,0xc000c00,0x1e0001c0,0x3e003e0,

       0x3e003e0,0x3e003e0,0xfe01e18,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x70e07c38,0x1c701c70,0x1c701c70,0x1c700000,0x3c787038,

       0x70387038,0x70383c1e,0x70003870,0xc00300,0xc300ce0,0x380,0x0,0xc00300,0xc300000,0xc00300,0xc300000,0xfc00ce0,0xc00300,0xc300ce0,

       0x0,0xc0,0x3000c30,0x300,0x38000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x630031c,0xff8c300,

       0x1c000180,0x1800180,0x39380000,0x0,0x70,0x1c3801c0,0x203c001c,0x3e01c00,0x1c000038,0x381c3838,0x0,0x0,0x1038,0xe0e03e0,0x70703c08,

       0x70707000,0x70003808,0x703801c0,0x707070,0x70007c7c,0x7c383838,0x70383838,0x70387010,0x1c07038,0x381c700e,0x1e3c1c1c,0x780380,

       0x1c0001c0,0xe700000,0x0,0x38000000,0x1c0000,0x3800000,0x38000000,0x1c00,0x3800000,0x0,0x0,0x0,0x7000000,0x0,0x0,0x1c0,0x18001c0,

       0x0,0xe000000,0xe0,0x0,0x1000100,0x3800,0x70100000,0x38700000,0x780000,0x1c0,0x7801ce0,0xe380000,0x0,0x2264,0x0,0x0,0x1c1c,

       0x0,0x200780,0x1c1c,0x1800c00,0x1818,0x7f00000,0x0,0x18180000,0xc300000,0x600070,0x0,0x7f980000,0x180,0x18300000,0xc000c00,

       0x3000000,0x3e003e0,0x3e003e0,0x3e003e0,0xee03c08,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x70707c38,0x38383838,0x38383838,

       0x38380000,0x38387038,0x70387038,0x70381c1c,0x7fc03870,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbc00000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x38000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x6300318,0xe88c300,0x1c000180,0x38001c0,

       0xfe00180,0x0,0x70,0x1c3801c0,0x1c001c,0x6e01c00,0x1c000078,0x381c3818,0x0,0x40000,0x40000038,0x1c0607e0,0x70703800,0x70707000,

       0x70003800,0x703801c0,0x7070e0,0x70007c7c,0x7c383838,0x70383838,0x70387000,0x1c07038,0x381c700e,0xf780e38,0x700380,0x1c0001c0,

       0x1c380000,0x0,0x38000000,0x1c0000,0x3800000,0x38000000,0x1c00,0x3800000,0x0,0x0,0x0,0x7000000,0x0,0x0,0x1c0,0x18001c0,0x0,

       0xe000000,0xe0,0x0,0x1000100,0x4400,0x70000000,0x38700000,0x700000,0xe0,0x7001c70,0xe380000,0x0,0x2264,0x0,0x0,0xe38,0x0,

       0x200700,0xe38,0x1800c00,0x300c,0xc300000,0x0,0x300c0000,0xc300180,0x6003c0,0x0,0x7f980000,0x180,0x18300000,0xc000c00,0x1800000,

       0x7e007e0,0x7e007e0,0x7e003e0,0xee03800,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x70707c38,0x38383838,0x38383838,0x38380000,

       0x38387038,0x70387038,0x70380e38,0x7ff039f0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e00000,0x0,0x0,0x0,0x40000,0x0,0x0,0x38000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x6300318,0x1c80e700,0x1c000180,0x38001c0,0x3800180,

       0x0,0xe0,0x381c01c0,0x1c001c,0x6e01c00,0x38000070,0x381c381c,0x0,0x3c0000,0x78000078,0x38030770,0x70707800,0x70387000,0x70007000,

       0x703801c0,0x7071c0,0x7000745c,0x7638701c,0x7038701c,0x70387000,0x1c07038,0x1c38718e,0x7700f78,0xf00380,0xe0001c0,0x381c0000,

       0x7e0,0x39e003e0,0x79c03f0,0x3ffc079c,0x39e01fc0,0xfe01c1e,0x3807778,0x39e007e0,0x39e0079c,0x73c07e0,0x7ff83838,0x701ce007,

       0x783c701c,0x1ffc01c0,0x18001c0,0x0,0x1c000100,0xe0,0x0,0x1000100,0x4200,0x70000000,0x70700100,0xf00100,0x10000e0,0x7000c70,

       0xc700000,0x0,0x2204,0x7e00000,0x1e380100,0x1ffc0f78,0x0,0xf80700,0xf78,0x1800e00,0x63e6,0x18300000,0x0,0x6fe60000,0xe700180,

       0xc00060,0x3838,0x7f980000,0x180,0x18300000,0xc000c00,0x18001c0,0x7700770,0x7700770,0x77007f0,0xee07800,0x70007000,0x70007000,

       0x1c001c0,0x1c001c0,0x70387638,0x701c701c,0x701c701c,0x701c1008,0x707c7038,0x70387038,0x70380f78,0x707039c0,0x7e007e0,0x7e007e0,

       0x7e007e0,0x1f3c03e0,0x3f003f0,0x3f003f0,0x1fc01fc0,0x1fc01fc0,0x7f039e0,0x7e007e0,0x7e007e0,0x7e00380,0x7ce3838,0x38383838,

       0x3838701c,0x39e0701c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x6307fff,0x1c807e0c,0xe000180,

       0x30000c0,0x3800180,0x0,0xe0,0x381c01c0,0x1c001c,0xce01fe0,0x38000070,0x381c381c,0x3800380,0xfc0000,0x7e0000f0,0x30030770,

       0x70707000,0x70387000,0x70007000,0x703801c0,0x707380,0x700076dc,0x7638701c,0x7038701c,0x70387800,0x1c07038,0x1c3873ce,0x7f00770,

       0xe00380,0xe0001c0,0x700e0000,0x1ff8,0x3ff00ff0,0xffc0ff8,0x3ffc0ffc,0x3bf01fc0,0xfe01c3c,0x3807f78,0x3bf00ff0,0x3ff00ffc,

       0x77e0ff0,0x7ff83838,0x3838e007,0x3c783838,0x1ffc01c0,0x18001c0,0x0,0x7ff00380,0x1e0,0x0,0x1000100,0x4200,0x78000000,0x70700380,

       0xe00380,0x3800060,0xe000e30,0x1c600000,0x0,0x2204,0xff00000,0x7f7c0380,0x1ffc0770,0x1c0,0x3fc0700,0x18040770,0x1800780,0x4e12,

       0x18300104,0x0,0x4c320000,0x7e00180,0x1c00030,0x3838,0x7f980000,0x180,0x18302080,0xc000c00,0x18001c0,0x7700770,0x7700770,

       0x7700770,0x1ee07000,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x70387638,0x701c701c,0x701c701c,0x701c381c,0x705c7038,0x70387038,

       0x70380770,0x70383b80,0x1ff81ff8,0x1ff81ff8,0x1ff81ff8,0x3fbe0ff0,0xff80ff8,0xff80ff8,0x1fc01fc0,0x1fc01fc0,0xff83bf0,0xff00ff0,

       0xff00ff0,0xff00380,0xffc3838,0x38383838,0x38383838,0x3ff03838,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x1c0,0x7fff,0x1c803c38,0xf000000,0x70000e0,0xfe00180,0x0,0x1c0,0x381c01c0,0x3c0078,0xce01ff0,0x39e000f0,0x1c38381c,0x3800380,

       0x3e07ffc,0xf8001f0,0x307b0770,0x70e07000,0x70387000,0x70007000,0x703801c0,0x707700,0x700076dc,0x7638701c,0x7038701c,0x70387e00,

       0x1c07038,0x1c3873ce,0x3e007f0,0x1e00380,0x70001c0,0x0,0x1038,0x3c381e18,0x1c7c1e3c,0x3801e3c,0x3c7801c0,0xe01c78,0x380739c,

       0x3c781c38,0x3c381c3c,0x7c21e10,0x7003838,0x3838700e,0x1ef03838,0x3c01c0,0x18001c0,0x0,0x7fe007c0,0x1c0,0x0,0x1000100,0x6400,

       0x7e000000,0x707007c0,0x1e007c0,0x7c00070,0xe000638,0x18600000,0x0,0x0,0x1e100000,0x73ce07c0,0x3c07f0,0x1c0,0x7240700,0x1ddc3ffe,

       0x1800de0,0x8c01,0x1870030c,0x0,0x8c310000,0x3c00180,0x3800030,0x3838,0x7f980000,0x180,0x183030c0,0xc000c00,0x430001c0,0x7700770,

       0x7700770,0x7700770,0x1ce07000,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x70387638,0x701c701c,0x701c701c,0x701c1c38,0x70dc7038,

       0x70387038,0x703807f0,0x70383b80,0x10381038,0x10381038,0x10381038,0x21e71e18,0x1e3c1e3c,0x1e3c1e3c,0x1c001c0,0x1c001c0,0x1e383c78,

       0x1c381c38,0x1c381c38,0x1c380380,0x1c383838,0x38383838,0x38383838,0x3c383838,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x1c0,0x630,0x1e8000e0,0x1f000000,0x70000e0,0x39380180,0x0,0x1c0,0x3b9c01c0,0x3c07f0,0x18e01078,0x3bf800e0,

       0x7e0383c,0x3800380,0x1f807ffc,0x3f001c0,0x61ff0e38,0x7fc07000,0x70387ff0,0x7ff07000,0x7ff801c0,0x707f00,0x7000729c,0x7338701c,

       0x7070701c,0x70703fc0,0x1c07038,0x1e7873ce,0x1c003e0,0x3c00380,0x70001c0,0x0,0x1c,0x3c381c00,0x1c3c1c1c,0x3801c3c,0x383801c0,

       0xe01cf0,0x380739c,0x38381c38,0x3c381c3c,0x7801c00,0x7003838,0x3838700e,0xfe03c78,0x7801c0,0x18001c0,0x0,0x1c000c20,0xff8,

       0x0,0x1ff01ff0,0x3818,0x3fc00100,0x707e0c20,0x3c00c20,0xc200030,0xc000618,0x18c00000,0x0,0x0,0x1c000080,0xe1ce0c20,0x7803e0,

       0x1c0,0xe200700,0xff83ffe,0x1801878,0x9801,0x1cf0071c,0x7ffc0000,0x8c310000,0x7ffe,0x7000030,0x3838,0x3f980380,0x180,0xc6038e0,

       0x7f9c7f9c,0x3e1c01c0,0xe380e38,0xe380e38,0xe380f78,0x1cfc7000,0x7ff07ff0,0x7ff07ff0,0x1c001c0,0x1c001c0,0xfe387338,0x701c701c,

       0x701c701c,0x701c0e70,0x719c7038,0x70387038,0x703803e0,0x70383b80,0x1c001c,0x1c001c,0x1c001c,0xe71c00,0x1c1c1c1c,0x1c1c1c1c,

       0x1c001c0,0x1c001c0,0x1c383838,0x1c381c38,0x1c381c38,0x1c380000,0x3c383838,0x38383838,0x38383c78,0x3c383c78,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x630,0xf800380,0x3f830000,0x70000e0,0x31080180,0x0,0x380,0x3b9c01c0,

       0x7807e0,0x38e00038,0x3c3800e0,0xff01c3c,0x3800380,0x7c000000,0x7c03c0,0x61870e38,0x7fc07000,0x70387ff0,0x7ff070fc,0x7ff801c0,

       0x707f80,0x7000739c,0x7338701c,0x7ff0701c,0x7fe00ff0,0x1c07038,0xe7073ce,0x1c003e0,0x3800380,0x38001c0,0x0,0x1c,0x381c3800,

       0x381c380e,0x380381c,0x383801c0,0xe01de0,0x380739c,0x3838381c,0x381c381c,0x7001e00,0x7003838,0x1c70718e,0x7e01c70,0xf00380,

       0x18001e0,0x1e000000,0x1c001bb0,0xff8,0x0,0x1000100,0xe0,0xff00300,0x707e1bb0,0x3801bb0,0x1bb00010,0x8000308,0x30c00000,0x0,

       0x0,0x1e0000c0,0xe1ce1bb0,0xf003e0,0x1c0,0x1c203ff8,0x63003e0,0x180181c,0x9801,0xfb00e38,0x7ffc0000,0x8fc10000,0x7ffe,0xe000860,

       0x3838,0x1f980380,0x180,0x7c01c70,0x1f001f0,0x1f003c0,0xe380e38,0xe380e38,0xe380e38,0x1cfc7000,0x7ff07ff0,0x7ff07ff0,0x1c001c0,

       0x1c001c0,0xfe387338,0x701c701c,0x701c701c,0x701c07e0,0x731c7038,0x70387038,0x703803e0,0x70383980,0x1c001c,0x1c001c,0x1c001c,

       0xe73800,0x380e380e,0x380e380e,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c0000,0x387c3838,0x38383838,0x38381c70,

       0x381c1c70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0xc30,0x7f00e00,0x33c30000,0x70000e0,0x1007ffe,

       0x0,0x380,0x3b9c01c0,0xf00078,0x30e0001c,0x3c1c01c0,0x1c381fdc,0x0,0x70000000,0x1c0380,0x63030e38,0x70707000,0x70387000,0x700070fc,

       0x703801c0,0x707b80,0x7000739c,0x7338701c,0x7fc0701c,0x7fc001f0,0x1c07038,0xe703e5c,0x3e001c0,0x7800380,0x38001c0,0x0,0x7fc,

       0x381c3800,0x381c380e,0x380381c,0x383801c0,0xe01fe0,0x380739c,0x3838381c,0x381c381c,0x7001fc0,0x7003838,0x1c70718e,0x7c01c70,

       0xe01f00,0x180007c,0x7f8c0000,0x7fc03fb8,0x1c0,0x0,0x1000100,0x700,0x1f00600,0x70703fb8,0x7803fb8,0x3fb80000,0x8000000,0x180,

       0x0,0x0,0x1fc00060,0xe1ce3fb8,0xe001c0,0x1c0,0x1c203ff8,0xc1801c0,0x180c,0x9801,0x1c70,0xc0000,0x8cc10000,0x180,0xfe007c0,

       0x3838,0x7980380,0xff0,0xe38,0x3e003e00,0x3e000380,0xe380e38,0xe380e38,0xe380e38,0x38e07000,0x70007000,0x70007000,0x1c001c0,

       0x1c001c0,0x70387338,0x701c701c,0x701c701c,0x701c03c0,0x731c7038,0x70387038,0x703801c0,0x703838e0,0x7fc07fc,0x7fc07fc,0x7fc07fc,

       0xe73800,0x380e380e,0x380e380e,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c7ffc,0x38dc3838,0x38383838,0x38381c70,

       0x381c1c70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0xc60,0xf83878,0x71e30000,0x70000e0,0x1007ffe,

       0x7f0,0x380,0x381c01c0,0x1e0003c,0x60e0001c,0x381c01c0,0x381c079c,0x0,0x7c000000,0x7c0380,0x63031c1c,0x70307000,0x70387000,

       0x7000701c,0x703801c0,0x7071c0,0x7000739c,0x71b8701c,0x7000701c,0x71e00078,0x1c07038,0xe703e7c,0x7e001c0,0xf000380,0x38001c0,

       0x0,0x1ffc,0x381c3800,0x381c3ffe,0x380381c,0x383801c0,0xe01fc0,0x380739c,0x3838381c,0x381c381c,0x7000ff0,0x7003838,0x1ef03bdc,

       0x3800ee0,0x1e01f00,0x180007c,0x61fc0000,0x7fc07f3c,0x1c0,0x0,0x1000100,0x1800,0x780c00,0x70707f3c,0xf007f3c,0x7f3c0000,0x0,

       0x3c0,0x3ffcffff,0x0,0xff00030,0xe1fe7f3c,0x1e001c0,0x1c0,0x1c200700,0xc183ffe,0xe0c,0x9801,0x1ff038e0,0xc07f0,0x8c610000,

       0x180,0x0,0x3838,0x1980380,0x0,0x1ff0071c,0xe000e000,0xe0000f80,0x1c1c1c1c,0x1c1c1c1c,0x1c1c1e38,0x38e07000,0x70007000,0x70007000,

       0x1c001c0,0x1c001c0,0x703871b8,0x701c701c,0x701c701c,0x701c03c0,0x761c7038,0x70387038,0x703801c0,0x70703870,0x1ffc1ffc,0x1ffc1ffc,

       0x1ffc1ffc,0xfff3800,0x3ffe3ffe,0x3ffe3ffe,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c7ffc,0x389c3838,0x38383838,

       0x38380ee0,0x381c0ee0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0xfffc,0xbc60fc,0x70e30000,0x70000e0,

       0x180,0x7f0,0x700,0x381c01c0,0x3e0001c,0x7ffc001c,0x381c03c0,0x381c001c,0x0,0x1f807ffc,0x3f00380,0x63031ffc,0x70387000,0x70387000,

       0x7000701c,0x703801c0,0x7071e0,0x7000701c,0x71b8701c,0x7000701c,0x70f00038,0x1c07038,0x7e03e7c,0x77001c0,0xe000380,0x1c001c0,

       0x0,0x3c1c,0x381c3800,0x381c3ffe,0x380381c,0x383801c0,0xe01fe0,0x380739c,0x3838381c,0x381c381c,0x70003f8,0x7003838,0xee03bdc,

       0x3c00ee0,0x3c00380,0x18000e0,0xf00000,0x1c007e7c,0x3c0,0x0,0x1000100,0x0,0x381800,0x70707e7c,0xe007e7c,0x7e7c0000,0x0,0x7c0,

       0x0,0x0,0x3f80018,0xe1fe7e7c,0x3c001c0,0x1c0,0x1c200700,0xc183ffe,0xf0c,0x8c01,0x38e0,0xc07f0,0x8c710000,0x180,0x0,0x3838,

       0x1980000,0x0,0x71c,0x7000f0,0x700f00,0x1ffc1ffc,0x1ffc1ffc,0x1ffc1ffc,0x3fe07000,0x70007000,0x70007000,0x1c001c0,0x1c001c0,

       0x703871b8,0x701c701c,0x701c701c,0x701c07e0,0x7c1c7038,0x70387038,0x703801c0,0x7ff03838,0x3c1c3c1c,0x3c1c3c1c,0x3c1c3c1c,

       0x3fff3800,0x3ffe3ffe,0x3ffe3ffe,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c0000,0x391c3838,0x38383838,0x38380ee0,

       0x381c0ee0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffc,0x9c01ce,0x70f60000,0x70000e0,0x180,

       0x0,0x700,0x381c01c0,0x780001c,0x7ffc001c,0x381c0380,0x381c003c,0x0,0x3e07ffc,0xf800380,0x63031ffc,0x70387000,0x70387000,

       0x7000701c,0x703801c0,0x7070f0,0x7000701c,0x71b8701c,0x7000701c,0x70700038,0x1c07038,0x7e03e7c,0xf7801c0,0x1e000380,0x1c001c0,

       0x0,0x381c,0x381c3800,0x381c3800,0x380381c,0x383801c0,0xe01fe0,0x380739c,0x3838381c,0x381c381c,0x7000078,0x7003838,0xee03a5c,

       0x7c00fe0,0x78001c0,0x18001c0,0x0,0x1c003ef8,0x380,0x0,0x1000100,0x810,0x383000,0x70703ef8,0x1e003ef8,0x3ef80000,0x0,0x7c0,

       0x0,0x0,0x78000c,0xe1c03ef8,0x78001c0,0x1c0,0x1c200700,0x63001c0,0x18003f8,0x4e12,0x1c70,0xc0000,0x4c320000,0x180,0x0,0x3838,

       0x1980000,0x0,0xe38,0x700118,0x701e00,0x1ffc1ffc,0x1ffc1ffc,0x1ffc1ffc,0x7fe07000,0x70007000,0x70007000,0x1c001c0,0x1c001c0,

       0x703871b8,0x701c701c,0x701c701c,0x701c0e70,0x7c1c7038,0x70387038,0x703801c0,0x7fc0381c,0x381c381c,0x381c381c,0x381c381c,

       0x78e03800,0x38003800,0x38003800,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c0000,0x3b1c3838,0x38383838,0x38380fe0,

       0x381c0fe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1860,0x9c0186,0x707e0000,0x30000c0,0x180,

       0x0,0xe00,0x183801c0,0xf00001c,0xe0001c,0x181c0380,0x381c0038,0x0,0xfc0000,0x7e000000,0x61873c1e,0x70383800,0x70707000,0x7000381c,

       0x703801c0,0x707070,0x7000701c,0x70f83838,0x70003838,0x70780038,0x1c07038,0x7e03c3c,0xe3801c0,0x1c000380,0xe001c0,0x0,0x381c,

       0x381c3800,0x381c3800,0x380381c,0x383801c0,0xe01ef0,0x380739c,0x3838381c,0x381c381c,0x7000038,0x7003838,0xfe03e7c,0xfe007c0,

       0x70001c0,0x18001c0,0x0,0xe001ff0,0x380,0x0,0x1000100,0x162c,0x381800,0x30701ff0,0x1c001ff0,0x1ff00000,0x0,0x3c0,0x0,0x0,

       0x380018,0xe1c01ff0,0x70001c0,0x1c0,0x1c200700,0xff801c0,0x18000f0,0x63e6,0xe38,0x0,0x6c3e0000,0x0,0x0,0x3838,0x1980000,0x0,

       0x1c70,0xf0000c,0xf01c00,0x3c1e3c1e,0x3c1e3c1e,0x3c1e3c1c,0x70e03800,0x70007000,0x70007000,0x1c001c0,0x1c001c0,0x707070f8,

       0x38383838,0x38383838,0x38381c38,0x38387038,0x70387038,0x703801c0,0x7000381c,0x381c381c,0x381c381c,0x381c381c,0x70e03800,

       0x38003800,0x38003800,0x1c001c0,0x1c001c0,0x381c3838,0x381c381c,0x381c381c,0x381c0380,0x3e1c3838,0x38383838,0x383807c0,0x381c07c0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18c0,0x9c0186,0x783c0000,0x38001c0,0x180,0x3800000,

       0x3800e00,0x1c3801c0,0x1e00003c,0xe00038,0x1c1c0780,0x381c0038,0x3800380,0x3c0000,0x78000000,0x61ff380e,0x70383808,0x70707000,

       0x7000381c,0x703801c0,0x40707078,0x7000701c,0x70f83838,0x70003838,0x70384038,0x1c07038,0x7e03c3c,0x1e3c01c0,0x3c000380,0xe001c0,

       0x0,0x383c,0x3c381c00,0x1c3c1c00,0x3801c3c,0x383801c0,0xe01c78,0x380739c,0x38381c38,0x3c381c3c,0x7000038,0x7003878,0x7c01e78,

       0x1ef007c0,0xf0001c0,0x18001c0,0x0,0xe000ee0,0x7800380,0xe380000,0x1001ff0,0x2242,0x40380c00,0x38700ee0,0x3c000ee0,0xee00000,

       0x0,0x0,0x0,0x0,0x380030,0xe1c00ee0,0xf0001c0,0x1c0,0xe200700,0xdd801c0,0x1800038,0x300c,0x71c,0x0,0x300c0000,0x0,0x0,0x3838,

       0x1980000,0x0,0x38e0,0xb0000c,0xb01c08,0x380e380e,0x380e380e,0x380e380e,0x70e03808,0x70007000,0x70007000,0x1c001c0,0x1c001c0,

       0x707070f8,0x38383838,0x38383838,0x3838381c,0x38387038,0x70387038,0x703801c0,0x7000381c,0x383c383c,0x383c383c,0x383c383c,

       0x70e01c00,0x1c001c00,0x1c001c00,0x1c001c0,0x1c001c0,0x1c383838,0x1c381c38,0x1c381c38,0x1c380380,0x1c383878,0x38783878,0x387807c0,

       0x3c3807c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x18c0,0x10b801ce,0x3c3e0000,0x38001c0,0x180,

       0x3800000,0x3801c00,0x1e7801c0,0x3c002078,0xe02078,0x1c380700,0x1c3810f0,0x3800380,0x40000,0x40000380,0x307b380e,0x70701e18,

       0x70e07000,0x70001c1c,0x703801c0,0x60e0703c,0x7000701c,0x70f83c78,0x70003c70,0x703c70f0,0x1c03870,0x3c01c3c,0x3c1c01c0,0x78000380,

       0x7001c0,0x0,0x3c7c,0x3c381e18,0x1c7c1e0c,0x3801c3c,0x383801c0,0xe01c38,0x3c0739c,0x38381c38,0x3c381c3c,0x7001078,0x7803c78,

       0x7c01c38,0x1c780380,0x1e0001c0,0x18001c0,0x0,0x70c06c0,0x7000380,0xe300000,0x1000100,0x2142,0x70f00600,0x3c7006c0,0x780006c0,

       0x6c00000,0x0,0x0,0x0,0x0,0x10780060,0x73e206c0,0x1e0001c0,0x1c0,0x7240700,0x180c01c0,0x1800018,0x1818,0x30c,0x0,0x18180000,

       0x0,0x0,0x3c78,0x1980000,0x0,0x30c0,0x130000c,0x1301c18,0x380e380e,0x380e380e,0x380e380e,0x70e01e18,0x70007000,0x70007000,

       0x1c001c0,0x1c001c0,0x70e070f8,0x3c783c78,0x3c783c78,0x3c781008,0x7c783870,0x38703870,0x387001c0,0x70003a3c,0x3c7c3c7c,0x3c7c3c7c,

       0x3c7c3c7c,0x79f11e18,0x1e0c1e0c,0x1e0c1e0c,0x1c001c0,0x1c001c0,0x1c783838,0x1c381c38,0x1c381c38,0x1c380380,0x1c383c78,0x3c783c78,

       0x3c780380,0x3c380380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x38c0,0x1ff800fc,0x1fee0000,

       0x1800180,0x180,0x3800000,0x3801c00,0xff01ffc,0x3ffc3ff0,0xe03ff0,0xff00700,0x1ff81fe0,0x3800380,0x0,0x380,0x3000780f,0x7ff00ff8,

       0x7fc07ff8,0x70000ffc,0x70381ffc,0x7fe0701c,0x7ff8701c,0x70781ff0,0x70001ff0,0x701c7ff0,0x1c01fe0,0x3c01c38,0x380e01c0,0x7ffc0380,

       0x7001c0,0x0,0x1fdc,0x3ff00ff0,0xffc0ffc,0x3800fdc,0x38383ffe,0xe01c3c,0x1fc739c,0x38380ff0,0x3ff00ffc,0x7001ff0,0x3f81fb8,

       0x7c01c38,0x3c3c0380,0x1ffc01c0,0x18001c0,0x0,0x3fc0380,0x7000380,0xc70718c,0x1000100,0x2244,0x7ff00200,0x1fff0380,0x7ffc0380,

       0x3800000,0x0,0x0,0x0,0x0,0x1ff000c0,0x7f7e0380,0x1ffc01c0,0x1c0,0x3fc3ffe,0x1c0,0x1800018,0x7e0,0x104,0x0,0x7e00000,0x7ffe,

       0x0,0x3fde,0x1980000,0x0,0x2080,0x3300018,0x3300ff0,0x780f780f,0x780f780f,0x780f780e,0xf0fe0ff8,0x7ff87ff8,0x7ff87ff8,0x1ffc1ffc,

       0x1ffc1ffc,0x7fc07078,0x1ff01ff0,0x1ff01ff0,0x1ff00000,0x7ff01fe0,0x1fe01fe0,0x1fe001c0,0x70003bf8,0x1fdc1fdc,0x1fdc1fdc,

       0x1fdc1fdc,0x3fbf0ff0,0xffc0ffc,0xffc0ffc,0x3ffe3ffe,0x3ffe3ffe,0xff03838,0xff00ff0,0xff00ff0,0xff00000,0x3ff01fb8,0x1fb81fb8,

       0x1fb80380,0x3ff00380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x31c0,0x7e00078,0x7cf0000,0x1800180,

       0x0,0x3800000,0x3803800,0x3c01ffc,0x3ffc0fe0,0xe01fc0,0x3e00e00,0x7e00f80,0x3800380,0x0,0x380,0x18007007,0x7fc003f0,0x7f007ff8,

       0x700003f0,0x70381ffc,0x3f80701e,0x7ff8701c,0x707807c0,0x700007c0,0x701e1fc0,0x1c00fc0,0x3c01818,0x780f01c0,0x7ffc0380,0x3801c0,

       0x0,0xf9c,0x39e003e0,0x79c03f0,0x380079c,0x38383ffe,0xe01c1e,0x7c739c,0x383807e0,0x39e0079c,0x7000fc0,0x1f80f38,0x3801c38,

       0x781e0380,0x1ffc01c0,0x18001c0,0x0,0x1f80100,0xe000700,0x1c60718c,0x1000100,0x1e3c,0x1fc00100,0x7ff0100,0x7ffc0100,0x1000000,

       0x0,0x0,0x0,0x0,0xfc00080,0x3e3c0100,0x1ffc01c0,0x1c0,0xf83ffe,0x1c0,0x1800838,0x0,0x0,0x0,0x0,0x7ffe,0x0,0x3b9e,0x1980000,

       0x0,0x0,0x2300038,0x23003e0,0x70077007,0x70077007,0x70077007,0xe0fe03f0,0x7ff87ff8,0x7ff87ff8,0x1ffc1ffc,0x1ffc1ffc,0x7f007078,

       0x7c007c0,0x7c007c0,0x7c00000,0xc7c00fc0,0xfc00fc0,0xfc001c0,0x700039f0,0xf9c0f9c,0xf9c0f9c,0xf9c0f9c,0x1f1e03e0,0x3f003f0,

       0x3f003f0,0x3ffe3ffe,0x3ffe3ffe,0x7e03838,0x7e007e0,0x7e007e0,0x7e00000,0x63e00f38,0xf380f38,0xf380380,0x39e00380,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0xc00300,0x0,0x3000000,0x3800,0x0,0x0,0x0,0x0,

       0x0,0x300,0x0,0x0,0x1c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0,0x0,0x0,0x0,0x0,0x380,0x3801c0,0x0,0x0,0x0,0x0,0x1c,0x0,0xe00000,

       0x0,0x0,0x3800001c,0x0,0x0,0x0,0x700,0x1c0,0x18001c0,0x0,0x0,0xe000700,0x18600000,0x1000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x1800ff0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x1980000,0x1800000,0x0,0x6300070,0x6300000,0x0,

       0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,

       0x0,0x700,0x38000700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0xc00300,0x0,0x7000000,

       0x7000,0x0,0x0,0x0,0x0,0x0,0x700,0x0,0x0,0xf040000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78,0x0,0x0,0x0,0x0,0x3f0,0x1c0fc0,0x0,0x0,

       0x0,0x0,0x1c,0x0,0xe00000,0x0,0x0,0x3800001c,0x0,0x0,0x0,0x700,0x1e0,0x18003c0,0x0,0x0,0xc000700,0x18c00000,0x1000000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x18007e0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x1980000,0xc00000,

       0x0,0x7f800e0,0x7f80000,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x700,0x38000700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,

       0x0,0x600600,0x0,0x6000000,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x7fc0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,

       0x3f0,0xfc0,0x0,0x0,0x0,0x0,0x838,0x0,0x1e00000,0x0,0x0,0x3800001c,0x0,0x0,0x0,0xf00,0xfc,0x1801f80,0x0,0x0,0x8008e00,0x30c00000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x1800000,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x1980000,0xc00000,

       0x0,0x3001c0,0x300000,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0xf00,0x38000f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfc0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0xff0,0x0,0x1fc00000,0x0,0x0,0x3800001c,0x0,0x0,0x0,0x3e00,0x7c,0x1801f00,0x0,0x0,0x800fe00,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x1800000,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x0,0x7c00000,0x0,0x3001fc,0x300000,

       0x0,0x0,0x0,0x3e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x3e00,0x38003e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff8,0x0,0x0,0x0,0x7e0,0x0,0x1f000000,

       0x0,0x0,0x3800001c,0x0,0x0,0x0,0x3c00,0x0,0x1800000,0x0,0x0,0x7800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x0,0x7800000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00,0x38003c00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1800000,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 19x38 font.

     const unsigned int font19x38[19*38*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c380000,0x0,0x1c380,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800007,0x3c003,0x86000000,

       0x1e00000,0x3,0x80000700,0x3c00000,0x380000,0x70003c00,0x0,0xe1800e,0x1c00,0xf000e18,0x0,0x0,0x700000e0,0x780000,0x7000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe700000,0x0,0xe700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0000e,0x7e003,0xe60071c0,0x7f80000,0x1,0xc0000e00,0x7e0038e,0x1c0000,

       0xe0007e00,0x38e00000,0xf98007,0x3800,0x1f800f98,0x1c70000,0x0,0x380001c0,0xfc0071,0xc000e000,0x0,0x0,0x0,0x0,0x3e00000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x7e00000,0x0,0x7e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0001c,0xe7006,0x7c0071c0,0xe180000,0x0,0xe0001c00,0xe70038e,0xe0001,0xc000e700,0x38e00000,

       0x19f0003,0x80007000,0x39c019f0,0x1c70000,0x0,0x1c000380,0x1ce0071,0xc001c000,0x0,0x0,0x0,0x0,0x7f00000,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,

       0x0,0x3c00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x700038,0x1c3806,0x3c0071c0,0xc0c0000,0x0,0x70003800,0x1c38038e,0x70003,0x8001c380,0x38e00000,0x18f0001,0xc000e000,

       0x70e018f0,0x1c70000,0x0,0xe000700,0x3870071,0xc0038000,0x0,0x0,0x0,0x0,0xe380000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0xe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60000000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c38,0x0,0x1,0xc3800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c00000,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0xc0c0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe000003,0x80018000,0x0,0xc180000,

       0xe,0x380,0x1800000,0xe00000,0x38001800,0x0,0x38,0xe00,0x6000000,0x0,0x1,0xc0000070,0x300000,0x3800,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7000000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78c00,0xc30,

       0x0,0x0,0xc3000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800000,0x0,0x0,0x0,0xe0,0x1c000f,0xc0000000,0x0,0x0,

       0x0,0xc0c0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7000007,0x3c003,0xc6000000,0xc180000,0x7,0x700,

       0x3c00000,0x700000,0x70003c00,0x0,0xf1801c,0x1c00,0xf000f18,0x0,0x0,0xe00000e0,0x780000,0x7000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x1c007000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe0000,0xfe000,0x0,0x3800000,0x700000,0x38,

       0x7,0xe000001c,0x1c00,0x1c00700,0x7fc0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf800e,0x3e0000,0x0,0x0,0x0,0x1e00000,0x0,0x1,

       0xf8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7cc00,0x660,0x0,0x0,0x66000000,0x0,0x0,0x0,0x0,0x7,0x1c000000,0x0,0x0,0x0,0x3fe00000,

       0x0,0x0,0x7000000,0x0,0x0,0x0,0x3e0,0x7c001f,0xe0000000,0x0,0x0,0x0,0xe1c0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x1f80,0x380000e,0x7e007,0xe60071c0,0xc180000,0x3,0x80000e00,0x7e0038e,0x380000,0xe0007e00,0x38e00f00,0x1f9800e,

       0x3800,0x1f801f98,0x1c70000,0x0,0x700001c0,0xfc0071,0xc000e007,0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c7000,0x61c00600,0x1e00007e,0x70000,0x18003000,0x1800000,0x0,0x0,0x1c01f0,0x7e003f,0xc003f800,

       0x1e03ffc,0x7f01ff,0xfc03f000,0x7e000000,0x0,0x0,0xfc0,0x1e,0x7fe000,0x7e03fe00,0x3fff07ff,0xe007e038,0x383ffe0,0xff81c01,

       0xe1c000f8,0xf8f00e0,0xfc01ffc,0x3f00ff,0xc000fe07,0xfffc7007,0x1c007700,0x73c01ef,0x78ffff,0xfe0380,0xfe000,0x38000000,0x1800000,

       0x700000,0x38,0x1f,0xe000001c,0x1c00,0x1c00700,0x7fc0000,0x0,0x0,0x0,0x0,0x1c000000,0x0,0x0,0x0,0x3f800e,0x3f8000,0x0,0xfc0000,

       0x0,0x7f00000,0x0,0x1,0x98000000,0x7f00000,0x3ffe00,0xffff0,0x0,0x0,0x0,0x0,0x0,0xcf81f,0xee3807e0,0x0,0x0,0x7e03c01e,0x1c,

       0x0,0x1f800000,0xf0078038,0xfc007,0x1c000000,0xfe00000,0x0,0x0,0x3fe000f0,0xf,0xc001f800,0x6000000,0xffc000,0x0,0x1c0007e0,

       0x360,0x6c0010,0x70000700,0xf0001e,0x3c000,0x78000f00,0x7f800ff,0xf007e01f,0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83fc0,

       0x7807007,0xe000fc00,0x1f8003f0,0x7e0000,0x1f867,0x70e00e,0x1c01c380,0x38f00787,0x3fe0,0x180000c,0x66006,0x7c0071c0,0xe380000,

       0x1,0x80000c00,0x660038e,0x180000,0xc0006600,0x38e0078e,0x19f0006,0x3000,0x198019f0,0x1c70000,0x0,0x30000180,0xcc0071,0xc000c007,

       0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c7000,0x61800600,0x7f8001ff,0x70000,

       0x38003800,0x1800000,0x0,0x0,0x3807fc,0x1fe00ff,0xf00ffe00,0x3e03ffc,0xff81ff,0xfc07fc01,0xff800000,0x0,0x0,0x3fe0,0xfe001e,

       0x7ff801,0xff83ff80,0x3fff07ff,0xe01ff838,0x383ffe0,0xff81c03,0xc1c000f8,0xf8f80e0,0x3ff01fff,0xffc0ff,0xf003ff87,0xfffc7007,

       0x1e00f700,0x71c03c7,0x70ffff,0xfe01c0,0xfe000,0x7c000000,0xc00000,0x700000,0x38,0x3f,0xe000001c,0x1c00,0x1c00700,0x7fc0000,

       0x0,0x0,0x0,0x0,0x1c000000,0x0,0x0,0x0,0x3f800e,0x3f8000,0x0,0x3fe0000,0x0,0xff00000,0x0,0x3,0xc000000,0x1ffc0000,0xfffe00,

       0xffff0,0x0,0x0,0x0,0x0,0x0,0xc781f,0xee3803c0,0x0,0x0,0x3c01c01c,0x1c,0xc000,0x7fc00000,0x70070038,0x3fe007,0x1c000000,0x1ff80000,

       0x0,0x0,0x3fe003fc,0x1f,0xe003fc00,0xc000000,0x3ffc000,0x0,0x7c000ff0,0x60,0xc0000,0x30000700,0xf0001e,0x3c000,0x78000f00,

       0x3f000ff,0xf01ff81f,0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83ff8,0x7c0701f,0xf803ff00,0x7fe00ffc,0x1ff8000,0x7fe67,

       0x70e00e,0x1c01c380,0x38700707,0x7ff0,0xc00018,0xc3006,0x3c0071c0,0x7f00000,0x0,0xc0001800,0xc30038e,0xc0001,0x8000c300,0x38e003fc,

       0x18f0003,0x6000,0x30c018f0,0x1c70000,0x0,0x18000300,0x1860071,0xc0018007,0x38e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c7000,0xe1801fc0,0x618001ff,0x70000,0x30001800,0x21840000,0x0,0x0,0x380ffe,0x1fe00ff,

       0xfc0fff00,0x3e03ffc,0x1ff81ff,0xfc0ffe03,0xffc00000,0x0,0x0,0x7ff0,0x3ff803f,0x7ffc03,0xffc3ffc0,0x3fff07ff,0xe03ffc38,0x383ffe0,

       0xff81c07,0x81c000f8,0xf8f80e0,0x7ff81fff,0x81ffe0ff,0xf80fff87,0xfffc7007,0xe00e700,0x70e0387,0x80f0ffff,0xe001c0,0xe000,

       0xfe000000,0xe00000,0x700000,0x38,0x3c,0x1c,0x1c00,0x1c00700,0x1c0000,0x0,0x0,0x0,0x0,0x1c000000,0x0,0x0,0x0,0x78000e,0x3c000,

       0x0,0x7ff0000,0x0,0xf100000,0x0,0x7,0xe000000,0x7ffc0000,0x1fffe00,0xffff0,0x0,0x0,0x0,0x0,0x0,0x3,0xf780180,0x0,0x0,0x1801e03c,

       0x1c,0xc000,0xffc00000,0x780f0038,0x786000,0x7f00,0x18380000,0x0,0xfe00,0x30c,0x10,0x70020e00,0x1c000000,0x7f8c000,0x0,0x6c001c38,

       0x60,0xc0000,0x70000700,0x1f8003f,0x7e000,0xfc001f80,0x3f000ff,0xf03ffc1f,0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83ffc,

       0x7c0703f,0xfc07ff80,0xfff01ffe,0x3ffc000,0xffec7,0x70e00e,0x1c01c380,0x38780f07,0xf070,0xe00038,0x1c3800,0x0,0x3e00000,0x0,

       0xe0003800,0x1c380000,0xe0003,0x8001c380,0x3e0,0x3,0x8000e000,0x70e00000,0x0,0x0,0x1c000700,0x3870000,0x38007,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c7000,0xe3807ff0,0xc0c003c1,0x70000,0x70001c00,

       0x718e0000,0x0,0x0,0x700f1e,0x1ce00c0,0x3c0c0f80,0x7e03800,0x3e08000,0x381e0f03,0xc1e00000,0x0,0x0,0x7078,0x783c03f,0x701e07,

       0xc1c383e0,0x38000700,0x7c1c38,0x3801c00,0x381c0f,0x1c000fc,0x1f8f80e0,0x78781c07,0x81e1e0e0,0x780f0180,0xe007007,0xe00e380,

       0xe0f0783,0x80e0000e,0xe000e0,0xe001,0xef000000,0x0,0x700000,0x38,0x38,0x1c,0x0,0x700,0x1c0000,0x0,0x0,0x0,0x0,0x1c000000,

       0x0,0x0,0x0,0x70000e,0x1c000,0x0,0xf830000,0x0,0x1e000000,0x0,0x0,0x10000,0x780c0000,0x3e38000,0xe0,0x0,0x0,0x0,0x0,0x0,0x3,

       0xd580000,0x0,0x0,0xe038,0x1c,0xc000,0xf0400000,0x380e0038,0x702000,0x1ffc0,0xc0000,0x0,0x3ff80,0x606,0x0,0x30000600,0x0,

       0x7f8c000,0x0,0xc001818,0x60,0xc0003,0xe0000700,0x1f8003f,0x7e000,0xfc001f80,0x73801ee,0x7c1c1c,0x38000,0x70000e00,0xe0001,

       0xc0003800,0x700383e,0x7c0703c,0x3c078780,0xf0f01e1e,0x3c3c000,0xf0f87,0x70e00e,0x1c01c380,0x38380e07,0xe038,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0xff0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x1c,0x1c7000,0xc380fff0,0xc0c00380,0x70000,0x70001c00,0x3dbc0070,0x0,0x0,0x701e0f,0xe0000,0x1e000380,

       0x6e03800,0x7800000,0x781c0707,0x80e00000,0x0,0x0,0x4038,0xe00c03f,0x700e07,0x4380f0,0x38000700,0x700438,0x3801c00,0x381c0e,

       0x1c000ec,0x1b8fc0e0,0xf03c1c03,0xc3c0f0e0,0x3c1e0000,0xe007007,0xe00e380,0xe070703,0xc1e0001e,0xe000e0,0xe001,0xc7000000,

       0x0,0x700000,0x38,0x38,0x1c,0x0,0x700,0x1c0000,0x0,0x0,0x0,0x0,0x1c000000,0x0,0x0,0x0,0x70000e,0x1c000,0x0,0xe010000,0x0,

       0x1c000000,0x10,0x20000,0x6c000,0xf0000000,0x3838000,0x1e0,0x0,0xf000f,0xf1e00,0x78f00000,0x0,0x3,0xdd80000,0x0,0x0,0xf078,

       0x0,0xc001,0xe0000000,0x1c1c0038,0x700000,0x3c1e0,0xc0000,0x0,0x783c0,0x606,0x0,0x30000e00,0x0,0xff8c000,0x0,0xc00300c,0x60,

       0xc0003,0xe0000000,0x1f8003f,0x7e000,0xfc001f80,0x73801ce,0x70041c,0x38000,0x70000e00,0xe0001,0xc0003800,0x700380f,0x7e07078,

       0x1e0f03c1,0xe0783c0f,0x781e000,0x1c0787,0x70e00e,0x1c01c380,0x383c1e07,0xff00e038,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x878,

       0x0,0x0,0x0,0x7,0x80000080,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,

       0x1c7000,0xc301e630,0xc0c00380,0x70000,0xe0000e00,0xff00070,0x0,0x0,0xe01c07,0xe0000,0xe000380,0xce03800,0x7000000,0x701c0707,

       0x600000,0x0,0x4000010,0x38,0x1c00e07f,0x80700e0e,0x38070,0x38000700,0xe00038,0x3801c00,0x381c1c,0x1c000ec,0x1b8ec0e0,0xe01c1c01,

       0xc38070e0,0x1c1c0000,0xe007007,0x701c380,0xe078e01,0xc1c0003c,0xe00070,0xe003,0x83800000,0x7f,0x71f000,0x3e003e38,0x3f007ff,

       0xe01f1c1c,0x7801fc00,0x3fc00701,0xe01c0077,0x8f071e00,0xf801c7c,0x7c700e,0x3e01fc03,0xfff8380e,0xe007700,0x73c0787,0x387ffc,

       0x70000e,0x1c000,0x0,0xe000000,0x0,0x1c000000,0x10,0x20000,0xc2000,0xe0000000,0x3838000,0x3c0,0x0,0xf000f,0x78e00,0x70e00000,

       0x0,0x3,0xc980fe0,0x1f0,0xf8000007,0xffc07070,0x0,0x3f801,0xc0000000,0x1e3c0038,0x700000,0x70070,0x7fc0000,0x0,0xe00e0,0x606,

       0x1c0000,0x70007c00,0x380e,0xff8c000,0x0,0xc00300c,0x60,0xc0000,0x70000000,0x3fc007f,0x800ff001,0xfe003fc0,0x73801ce,0xe0001c,

       0x38000,0x70000e00,0xe0001,0xc0003800,0x7003807,0x7607070,0xe0e01c1,0xc0383807,0x700e000,0x1c0387,0x70e00e,0x1c01c380,0x381c1c07,

       0xffc0e0f8,0x3f8007f,0xfe001,0xfc003f80,0x7f007e3,0xe003e001,0xf8003f00,0x7e000fc,0xfe001f,0xc003f800,0x7f00003c,0x38f0007,

       0xc000f800,0x1f0003e0,0x7c0007,0x8003f0c3,0x80e0701c,0xe0381c0,0x70700387,0x1f01c00e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c701f,0xfff1c600,0xc0c00380,0x70000,0xe0000e00,0x3c00070,0x0,0x0,0xe03c07,

       0x800e0000,0xe000380,0x1ce03800,0x7000000,0x701c0707,0x7003c0,0x780000,0x3c00001e,0x38,0x18006073,0x80700e0e,0x38070,0x38000700,

       0xe00038,0x3801c00,0x381c38,0x1c000ee,0x3b8ee0e1,0xe01e1c01,0xc78078e0,0x1c1c0000,0xe007007,0x701c387,0xe03de00,0xe3800038,

       0xe00070,0xe007,0x1c00000,0x1ff,0xc077f801,0xff807fb8,0xff807ff,0xe03fdc1d,0xfc01fc00,0x3fc00703,0xc01c007f,0xdf877f00,0x3fe01dfe,

       0xff700e,0xff07ff03,0xfff8380e,0x700f700,0x71e0f03,0x80707ffc,0x70000e,0x1c000,0x0,0x1c000008,0x0,0x1c000000,0x10,0x20000,

       0x82000,0xe0000000,0x7038000,0x80000380,0x2000040,0x7000e,0x38700,0xf1e00000,0x0,0x3,0xc183ff8,0x3fd,0xfc008007,0xffc038e0,

       0x0,0xffc01,0xc0008008,0xe380038,0x380000,0xe3e38,0x1ffc0040,0x80000000,0x1cfc70,0x606,0x1c0000,0xe0007c00,0x380e,0xff8c000,

       0x0,0xc00300c,0x8100060,0xc0000,0x30000700,0x39c0073,0x800e7001,0xce0039c0,0x73801ce,0xe0001c,0x38000,0x70000e00,0xe0001,

       0xc0003800,0x7003807,0x77070f0,0xf1e01e3,0xc03c7807,0x8f00f080,0x83c0787,0x70e00e,0x1c01c380,0x380e3807,0xffe0e1c0,0xffe01ff,

       0xc03ff807,0xff00ffe0,0x1ffc0ff7,0xf01ff807,0xfc00ff80,0x1ff003fe,0xfe001f,0xc003f800,0x7f0003fc,0x3bf801f,0xf003fe00,0x7fc00ff8,

       0x1ff0007,0x8007fd83,0x80e0701c,0xe0381c0,0x70380707,0x7f80e01c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x1c,0x1c701f,0xfff1c600,0x618081c0,0x70000,0xe0000e00,0x3c00070,0x0,0x0,0xe03803,0x800e0000,0xe000380,0x18e03800,

       0xf000000,0xf01c0707,0x7003c0,0x780000,0xfc00001f,0x80000078,0x301e6073,0x80700e1c,0x38038,0x38000700,0x1c00038,0x3801c00,

       0x381c70,0x1c000e6,0x338ee0e1,0xc00e1c01,0xc70038e0,0x1c1c0000,0xe007007,0x701c387,0xe01dc00,0xf7800078,0xe00070,0xe00e,0xe00000,

       0x3ff,0xe07ffc03,0xffc0fff8,0x1ffc07ff,0xe07ffc1d,0xfe01fc00,0x3fc00707,0x801c007f,0xdf877f80,0x7ff01fff,0x1fff00e,0xff07ff03,

       0xfff8380e,0x700e380,0xe0e0e03,0x80707ffc,0x70000e,0x1c000,0x0,0x7ffc001c,0x0,0x1c000000,0x10,0x20000,0x82000,0xe0000000,

       0x7038001,0xc0000780,0x70000e0,0x3800e,0x38700,0xe1c00000,0x0,0x3,0xc183ff8,0x7ff,0xfc01c007,0xffc03de0,0x0,0x1ffc01,0xc001c01c,

       0xf780038,0x3c0000,0xcff18,0x380c00c1,0x80000000,0x18fe30,0x30c,0x1c0001,0xc0000e00,0x380e,0xff8c000,0x0,0xc00300c,0xc180060,

       0xc0000,0x30000700,0x39c0073,0x800e7001,0xce0039c0,0xe1c038e,0x1c0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x7003803,0x877070e0,

       0x71c00e3,0x801c7003,0x8e0071c0,0x1c380fc7,0x70e00e,0x1c01c380,0x380f7807,0x1e0e380,0x1fff03ff,0xe07ffc0f,0xff81fff0,0x3ffe0fff,

       0xf03ffc0f,0xfe01ffc0,0x3ff807ff,0xfe001f,0xc003f800,0x7f0007fe,0x3bfc03f,0xf807ff00,0xffe01ffc,0x3ff8007,0x800fff83,0x80e0701c,

       0xe0381c0,0x70380707,0xffc0e01c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1c701f,

       0xfff1c600,0x7f8381e0,0x70000,0xc0000600,0xff00070,0x0,0x0,0x1c03803,0x800e0000,0xe000f00,0x38e03fe0,0xe000000,0xe00e0e07,

       0x7003c0,0x780007,0xf0ffff87,0xf00000f0,0x307fe0f3,0xc0703c1c,0x38038,0x38000700,0x1c00038,0x3801c00,0x381ce0,0x1c000e6,0x338e70e1,

       0xc00e1c01,0xc70038e0,0x3c1e0000,0xe007007,0x783c38f,0x8e01fc00,0x770000f0,0xe00038,0xe01c,0x700000,0x381,0xe07c1e07,0xc0c1e0f8,

       0x3c1e0038,0xf07c1f,0xe001c00,0x1c0070f,0x1c0079,0xf3c7c380,0xf0781f07,0x83c1f00f,0xc10f0300,0x1c00380e,0x700e380,0xe0f1e03,

       0xc0f00078,0x70000e,0x1c000,0x0,0xfff8003e,0x0,0x3c000000,0x10,0x20000,0xc6000,0xf0000000,0x7038003,0xe0000f00,0xf8001f0,

       0x3801c,0x18300,0xe1800000,0x0,0x3,0xc187818,0x70f,0x9e03e000,0x7801dc0,0x1c,0x3cc401,0xc000efb8,0x7f7f0038,0x3f0000,0x1ce11c,

       0x300c01c3,0x80000000,0x38c638,0x3fc,0x1c0003,0x80000600,0x380e,0xff8c000,0x0,0xc00300c,0xe1c0060,0xc0010,0x70000700,0x79e00f3,

       0xc01e7803,0xcf0079e0,0xe1c038e,0x1c0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x7003803,0x873870e0,0x71c00e3,0x801c7003,

       0x8e0070e0,0x38381dc7,0x70e00e,0x1c01c380,0x38077007,0xf0e700,0x1c0f0381,0xe0703c0e,0x781c0f0,0x381e083e,0x787c0c1e,0xf03c1e0,

       0x783c0f07,0x800e0001,0xc0003800,0x7000fff,0x3e1c078,0x3c0f0781,0xe0f03c1e,0x783c000,0x1e0f03,0x80e0701c,0xe0381c0,0x70380f07,

       0xc1e0e03c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x1,0x8701c600,0x1e0f01e0,0x1,

       0xc0000700,0x3dbc0070,0x0,0x0,0x1c03803,0x800e0000,0x1e01fe00,0x70e03ff8,0xe3e0001,0xe007fc07,0x80f003c0,0x78001f,0xc0ffff81,

       0xfc0001e0,0x30e1e0e1,0xc07ff81c,0x38038,0x3ffe07ff,0xc1c0003f,0xff801c00,0x381de0,0x1c000e7,0x738e70e1,0xc00e1c03,0xc70038e0,

       0x780f8000,0xe007007,0x383838d,0x8e00f800,0x7f0000e0,0xe00038,0xe000,0x0,0x200,0xf0780e07,0x8041c078,0x380e0038,0xe03c1e,

       0xf001c00,0x1c0071e,0x1c0070,0xe1c783c0,0xe0381e03,0x8380f00f,0xe0000,0x1c00380e,0x381c380,0xe07bc01,0xc0e00078,0x70000e,

       0x1c000,0x0,0x1c000061,0x0,0x38000000,0x10,0x20000,0x7c000,0x7c000000,0x703fc06,0x10000e00,0x18400308,0x1801c,0x1c381,0xc3800000,

       0x0,0x0,0x7000,0xe0f,0xe061000,0x7801fc0,0x1c,0x38c001,0xc0007ff0,0x7fff0038,0x77c000,0x19c00c,0x301c0387,0x0,0x30c618,0xf0,

       0x1c0007,0x600,0x380e,0x7f8c007,0x80000000,0xc001818,0x70e03fc,0x387f871f,0xe0e00700,0x70e00e1,0xc01c3803,0x870070e0,0xe1c038f,

       0xe1c0001f,0xff03ffe0,0x7ffc0fff,0x800e0001,0xc0003800,0x7003803,0x873870e0,0x71c00e3,0x801c7003,0x8e007070,0x703839c7,0x70e00e,

       0x1c01c380,0x3807f007,0x70e700,0x10078200,0xf0401e08,0x3c10078,0x200f001c,0x3878041c,0x70380e0,0x701c0e03,0x800e0001,0xc0003800,

       0x7001e0f,0x3c1e070,0x1c0e0381,0xc070380e,0x701c000,0x1c0f03,0x80e0701c,0xe0381c0,0x701c0e07,0x80e07038,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x3,0x8600e600,0x7803f0,0x1,0xc0000700,0x718e0070,0x0,0x0,0x38038c3,

       0x800e0000,0x3c01f800,0x60e03ffc,0xeff8001,0xc001f003,0xc1f003c0,0x7800fe,0xffff80,0x3f8003c0,0x60c0e0e1,0xc07fe01c,0x38038,

       0x3ffe07ff,0xc1c07e3f,0xff801c00,0x381fe0,0x1c000e3,0x638e30e1,0xc00e1c07,0x870038ff,0xf00ff800,0xe007007,0x38381cd,0x9c007000,

       0x3e0001e0,0xe0001c,0xe000,0x0,0x0,0x70780f0f,0x3c078,0x70070038,0x1e03c1c,0x7001c00,0x1c0073c,0x1c0070,0xe1c701c1,0xe03c1e03,

       0xc780f00f,0xe0000,0x1c00380e,0x381c387,0xe03f801,0xc0e000f0,0x70000e,0x1c007,0xe0100000,0x1c0000cd,0x80000003,0xffc00000,

       0x3ff,0x807ff000,0xe0,0x7fc00060,0x703fc0c,0xd8001e00,0x3360066c,0x1c018,0xc181,0x83000000,0x0,0x0,0x7000,0x300e07,0xe0cd800,

       0xf000f80,0x1c,0x78c00f,0xff0038e0,0x3e00038,0xe1e000,0x19800c,0x383c070e,0x7fffc00,0x30fc18,0x0,0xffff80e,0x20e00,0x380e,

       0x7f8c007,0x80000000,0xc001c38,0x38703ff,0xf87fff0f,0xcfe00f00,0x70e00e1,0xc01c3803,0x870070e0,0x1e1e078f,0xe1c0001f,0xff03ffe0,

       0x7ffc0fff,0x800e0001,0xc0003800,0x700ff83,0x871870e0,0x71c00e3,0x801c7003,0x8e007038,0xe03871c7,0x70e00e,0x1c01c380,0x3803e007,

       0x70e700,0x38000,0x70000e00,0x1c00038,0x7001c,0x38f00038,0x3870070,0xe00e1c01,0xc00e0001,0xc0003800,0x7001c07,0x380e0f0,0x1e1e03c3,

       0xc078780f,0xf01e000,0x3c0f03,0x80e0701c,0xe0381c0,0x701c0e07,0x80f07038,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x3,0x8600ff00,0x1e00778,0x38000001,0xc0000700,0x21843fff,0xe0000000,0x0,0x38039e3,0x800e0000,

       0x7c01fe00,0xe0e0203e,0xeffc001,0xc00ffe03,0xff700000,0x7f0,0x0,0x7f00380,0x618060e1,0xc07ffc1c,0x38038,0x3ffe07ff,0xc1c07e3f,

       0xff801c00,0x381ff0,0x1c000e3,0x638e38e1,0xc00e1fff,0x870038ff,0xc003fe00,0xe007007,0x38381cd,0x9c00f800,0x3e0003c0,0xe0001c,

       0xe000,0x0,0x0,0x7070070e,0x38038,0x70070038,0x1c01c1c,0x7001c00,0x1c00778,0x1c0070,0xe1c701c1,0xc01c1c01,0xc700700e,0xfc000,

       0x1c00380e,0x381c3c7,0x1e01f001,0xe1e001e0,0xf0000e,0x1e01f,0xf8300000,0x1c00019c,0xc0000003,0xffc00000,0x10,0x20000,0x700,

       0x1ff000c0,0x703fc19,0xcc003c00,0x67300ce6,0xc038,0xc181,0x83000000,0x0,0x0,0x7e00,0x180e07,0xe19cc00,0x1e000f80,0x1c,0x70c00f,

       0xff007070,0x3e00038,0xe0f000,0x19800c,0x1fec0e1c,0x7fffc00,0x30f818,0x0,0xffff81f,0xf003fc00,0x380e,0x3f8c007,0x80000000,

       0x7f800ff0,0x1c3803f,0xe007fc00,0xff800e00,0x70e00e1,0xc01c3803,0x870070e0,0x1c0e070f,0xe1c0001f,0xff03ffe0,0x7ffc0fff,0x800e0001,

       0xc0003800,0x700ff83,0x871c70e0,0x71c00e3,0x801c7003,0x8e00701d,0xc038e1c7,0x70e00e,0x1c01c380,0x3803e007,0x70e3c0,0x38000,

       0x70000e00,0x1c00038,0x7001c,0x38e00038,0x3870070,0xe00e1c01,0xc00e0001,0xc0003800,0x7003c07,0x8380e0e0,0xe1c01c3,0x80387007,

       0xe00e1ff,0xfe381b83,0x80e0701c,0xe0381c0,0x701e1e07,0x707878,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x1c,0x3,0xe007fe0,0x7800e3c,0x38000001,0xc0000700,0x1803fff,0xe0000000,0x0,0x70039c3,0x800e0000,0xf8000f80,

       0xc0e0000e,0xf83c003,0xc01e0f01,0xff700000,0x7c0,0x0,0x1f00780,0x618061c0,0xe0701e1c,0x38038,0x38000700,0x1c07e38,0x3801c00,

       0x381e78,0x1c000e3,0xe38e18e1,0xc00e1fff,0x70038ff,0xe0007f80,0xe007007,0x1c701dd,0x9c00f800,0x1c000780,0xe0000e,0xe000,0x0,

       0x7f,0xf070070e,0x38038,0x7fff0038,0x1c01c1c,0x7001c00,0x1c007f8,0x1c0070,0xe1c701c1,0xc01c1c01,0xc700700e,0x7fc00,0x1c00380e,

       0x1c381c7,0x1c01f000,0xe1c001c0,0xfe0000e,0xfe1f,0xfff00000,0x7ff003fc,0xe0000003,0xffc00000,0x10,0x20000,0x3800,0x3fc0180,

       0x703803f,0xce007800,0xff381fe7,0x30,0x0,0xc0,0x0,0x0,0x3fe0,0xc0e07,0xfe3fce00,0x1c000700,0x1c,0x70c00f,0xff006030,0x1c00000,

       0xe07800,0x19800c,0xfcc1c38,0x7fffc00,0x30d818,0x0,0xffff81f,0xf001f800,0x380e,0xf8c007,0x80000000,0x7f8007e0,0xe1c3fe,0x7fc00f,

       0xf8001e00,0xe0701c0,0xe0381c07,0x380e070,0x1c0e070e,0x1c0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x700ff83,0x870c70e0,

       0x71c00e3,0x801c7003,0x8e00700f,0x8038c1c7,0x70e00e,0x1c01c380,0x3801c007,0xf0e3e0,0x3ff807f,0xf00ffe01,0xffc03ff8,0x7ff03ff,

       0xf8e0003f,0xff87fff0,0xfffe1fff,0xc00e0001,0xc0003800,0x7003803,0x8380e0e0,0xe1c01c3,0x80387007,0xe00e1ff,0xfe383383,0x80e0701c,

       0xe0381c0,0x700e1c07,0x703870,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x3,0xc000ff0,

       0x3c1e1c1c,0x38000001,0xc0000700,0x1803fff,0xe0000007,0xf8000000,0x7003803,0x800e0001,0xf0000381,0xc0e00007,0xf01e003,0x801c0700,

       0x7c700000,0x7c0,0x0,0x1f00700,0x618061c0,0xe0700e1c,0x38038,0x38000700,0x1c00e38,0x3801c00,0x381e38,0x1c000e1,0xc38e1ce1,

       0xc00e1ffc,0x70038e0,0xf0000780,0xe007007,0x1c701dd,0xdc01fc00,0x1c000780,0xe0000e,0xe000,0x0,0x1ff,0xf070070e,0x38038,0x7fff0038,

       0x1c01c1c,0x7001c00,0x1c007f8,0x1c0070,0xe1c701c1,0xc01c1c01,0xc700700e,0x3ff00,0x1c00380e,0x1c381cd,0x9c00e000,0xe1c003c0,

       0xf80000e,0x3e18,0x3ff00000,0xffe007fd,0xf0000000,0x38000000,0x10,0x20000,0x1c000,0x3c0300,0x703807f,0xdf007801,0xff7c3fef,

       0x80000000,0x0,0x3e0,0x7ffe7ff,0xff000000,0x1ff8,0x60e07,0xfe7fdf00,0x3c000700,0x1c,0x70c001,0xc0006030,0x7fff0000,0xf03800,

       0x19800c,0x1c38,0x1c07,0xf830cc18,0x0,0x1c0000,0x0,0x380e,0x18c007,0x80000000,0x0,0xe1cfe0,0x1fc003f,0x80003c00,0xe0701c0,

       0xe0381c07,0x380e070,0x1c0e070e,0x1c0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x7003803,0x870e70e0,0x71c00e3,0x801c7003,

       0x8e007007,0x3981c7,0x70e00e,0x1c01c380,0x3801c007,0x1e0e0f8,0xfff81ff,0xf03ffe07,0xffc0fff8,0x1fff07ff,0xf8e0003f,0xff87fff0,

       0xfffe1fff,0xc00e0001,0xc0003800,0x7003803,0x8380e0e0,0xe1c01c3,0x80387007,0xe00e1ff,0xfe386383,0x80e0701c,0xe0381c0,0x700e1c07,

       0x703870,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x7f,0xffc00678,0x707f9c1e,0x38000001,

       0xc0000700,0x70,0x7,0xf8000000,0xe003803,0x800e0003,0xe00001c3,0x80e00007,0xe00e007,0x80380380,0x700000,0x7f0,0x0,0x7f00700,

       0x618061ff,0xe070071c,0x38038,0x38000700,0x1c00e38,0x3801c00,0x381c3c,0x1c000e1,0xc38e1ce1,0xc00e1c00,0x70038e0,0x700003c0,

       0xe007007,0x1c701d8,0xdc03dc00,0x1c000f00,0xe00007,0xe000,0x0,0x3ff,0xf070070e,0x38038,0x7fff0038,0x1c01c1c,0x7001c00,0x1c007fc,

       0x1c0070,0xe1c701c1,0xc01c1c01,0xc700700e,0x3f00,0x1c00380e,0x1c381cd,0x9c01f000,0x73800780,0xfe0000e,0xfe10,0x7c00000,0x1c000ffb,

       0xf8000000,0x38000000,0x10,0x20000,0x20000,0x1e0700,0x70380ff,0xbf80f003,0xfefe7fdf,0xc0000000,0x0,0x3f0,0x7ffe7ff,0xff000000,

       0x1f8,0x30e07,0xfeffbf80,0x78000700,0x1c,0x70c001,0xc0006030,0x7fff0000,0x783800,0x1ce11c,0xe1c,0x1c07,0xf838ce38,0x0,0x1c0000,

       0x0,0x380e,0x18c000,0x0,0x0,0x1c38c00,0x1800030,0x7800,0xfff01ff,0xe03ffc07,0xff80fff0,0x3fff0ffe,0x1c0001c,0x38000,0x70000e00,

       0xe0001,0xc0003800,0x7003803,0x870e70e0,0x71c00e3,0x801c7003,0x8e00700f,0x803b81c7,0x70e00e,0x1c01c380,0x3801c007,0xffe0e03c,

       0x1fff83ff,0xf07ffe0f,0xffc1fff8,0x3fff0fff,0xf8e0003f,0xff87fff0,0xfffe1fff,0xc00e0001,0xc0003800,0x7003803,0x8380e0e0,0xe1c01c3,

       0x80387007,0xe00e000,0x38c383,0x80e0701c,0xe0381c0,0x70073807,0x701ce0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0xffc0063c,0x40619c0f,0x30000001,0xc0000700,0x70,0x7,0xf8000000,0xe003803,0x800e0007,0xc00001c3,

       0xfffc0007,0xe00e007,0x380380,0xf00000,0xfe,0xffff80,0x3f800700,0x618063ff,0xf070071c,0x38038,0x38000700,0x1c00e38,0x3801c00,

       0x381c1e,0x1c000e0,0x38e0ee1,0xc00e1c00,0x70038e0,0x380001c0,0xe007007,0x1ef01d8,0xdc038e00,0x1c001e00,0xe00007,0xe000,0x0,

       0x7c0,0x7070070e,0x38038,0x70000038,0x1c01c1c,0x7001c00,0x1c0079e,0x1c0070,0xe1c701c1,0xc01c1c01,0xc700700e,0x780,0x1c00380e,

       0xe701cd,0x9c01f000,0x73800f00,0xe0000e,0xe000,0x0,0x1c0007f7,0xf0000000,0x70000000,0x10,0x20000,0x0,0xe0e00,0x703807f,0x7f01e001,

       0xfdfc3fbf,0x80000000,0x0,0x7f0,0x0,0x0,0x3c,0x18e07,0x7f7f00,0xf0000700,0x1c,0x70c001,0xc0007070,0x1c00000,0x3e7000,0xcff18,

       0x3ffc070e,0x1c07,0xf818c630,0x0,0x1c0000,0x0,0x380e,0x18c000,0x0,0x3ffc,0x3870000,0xe000fc00,0x380f000,0x1fff83ff,0xf07ffe0f,

       0xffc1fff8,0x3fff0ffe,0x1c0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x7003803,0x870770e0,0x71c00e3,0x801c7003,0x8e00701d,

       0xc03f01c7,0x70e00e,0x1c01c380,0x3801c007,0xffc0e01c,0x3e0387c0,0x70f80e1f,0x1c3e038,0x7c071e1c,0xe00038,0x70000,0xe0001c00,

       0xe0001,0xc0003800,0x7003803,0x8380e0e0,0xe1c01c3,0x80387007,0xe00e000,0x398383,0x80e0701c,0xe0381c0,0x70073807,0x701ce0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0xffc0061c,0xc0dc07,0xf0000001,0xc0000700,

       0x70,0x0,0x0,0x1c003c07,0x800e000f,0x1c3,0xfffc0007,0xe00e007,0x380380,0xe00000,0x1f,0xc0ffff81,0xfc000700,0x618063ff,0xf070070e,

       0x38070,0x38000700,0xe00e38,0x3801c00,0x381c0e,0x1c000e0,0x38e0ee1,0xe01e1c00,0x78078e0,0x380001c0,0xe007007,0xee01f8,0xfc078f00,

       0x1c001c00,0xe00003,0x8000e000,0x0,0x700,0x7070070e,0x38038,0x70000038,0x1c01c1c,0x7001c00,0x1c0070e,0x1c0070,0xe1c701c1,

       0xc01c1c01,0xc700700e,0x380,0x1c00380e,0xe700ed,0xb803f800,0x77800f00,0x70000e,0x1c000,0x0,0xe0003f7,0xe0000000,0x70000000,

       0x10,0x20000,0x1c0e0,0xe1c00,0x703803f,0x7e01c000,0xfdf81fbf,0x0,0x0,0x3f0,0x0,0x0,0x1c,0x1ce07,0x3f7e00,0xf0000700,0x1c,

       0x70c001,0xc00038e0,0x1c00038,0xf7000,0xe3e38,0x3ffc0387,0x1c00,0x1cc770,0x0,0x1c0000,0x0,0x380e,0x18c000,0x0,0x3ffc,0x70e0001,

       0xe001fe00,0x780e000,0x1fff83ff,0xf07ffe0f,0xffc1fff8,0x3fff0ffe,0xe0001c,0x38000,0x70000e00,0xe0001,0xc0003800,0x7003807,

       0x70770f0,0xf1e01e3,0xc03c7807,0x8f00f038,0xe03e03c7,0x70e00e,0x1c01c380,0x3801c007,0xff00e00e,0x38038700,0x70e00e1c,0x1c38038,

       0x70071c1c,0xe00038,0x70000,0xe0001c00,0xe0001,0xc0003800,0x7003803,0x8380e0e0,0xe1c01c3,0x80387007,0xe00e000,0x3b0383,0x80e0701c,

       0xe0381c0,0x70077807,0x701de0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x1c00061c,

       0xc0de03,0xe0000001,0xc0000700,0x70,0x0,0x0,0x1c001c07,0xe001e,0x1c3,0xfffc0007,0x600e00e,0x380380,0xe00000,0x7,0xf0ffff87,

       0xf0000000,0x60c0e380,0x7070070e,0x38070,0x38000700,0xe00e38,0x3801c00,0x381c0f,0x1c000e0,0x38e06e0,0xe01c1c00,0x38070e0,

       0x1c0001c0,0xe007007,0xee00f8,0xf80f0700,0x1c003c00,0xe00003,0x8000e000,0x0,0x700,0x70780f0f,0x3c078,0x70000038,0x1e03c1c,

       0x7001c00,0x1c0070f,0x1c0070,0xe1c701c1,0xe03c1e03,0xc780f00e,0x380,0x1c00380e,0xe700f8,0xf807bc00,0x3f001e00,0x70000e,0x1c000,

       0x0,0xe0001ff,0xc0000000,0x70000000,0x10,0x20000,0x33110,0xe0e00,0x383801f,0xfc03c000,0x7ff00ffe,0x0,0x0,0x3e0,0x0,0x0,0x1c,

       0x38e07,0x1ffc01,0xe0000700,0x1c,0x78c001,0xc0007ff0,0x1c00038,0x7c000,0x70070,0x1c3,0x80001c00,0xe00e0,0x0,0x1c0000,0x0,

       0x380e,0x18c000,0x0,0x0,0xe1c0001,0xe0010700,0x780e000,0x1c038380,0x70700e0e,0x1c1c038,0x78070e0e,0xe0001c,0x38000,0x70000e00,

       0xe0001,0xc0003800,0x7003807,0x7037070,0xe0e01c1,0xc0383807,0x700e070,0x701c0387,0x70e00e,0x1c01c380,0x3801c007,0xe00e,0x38038700,

       0x70e00e1c,0x1c38038,0x70071c1c,0xf00038,0x70000,0xe0001c00,0xe0001,0xc0003800,0x7003c07,0x8380e0f0,0x1e1e03c3,0xc078780f,

       0xf01e007,0x803e0783,0x80e0701c,0xe0381c0,0x7003f007,0x80f00fc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x6,0x1800061c,0xc0de01,0xc0000000,0xc0000e00,0x70,0xf0000,0x3c00,0x38001c0f,0xe003c,0x3c0,0xe0000e,0x701e00e,

       0x3c0780,0x1e003c0,0x780000,0xfc00001f,0x80000000,0x60e1e780,0x78700f07,0x4380f0,0x38000700,0xf00e38,0x3801c00,0xc0781c07,

       0x81c000e0,0x38e07e0,0xe03c1c00,0x380f0e0,0x1e0003c0,0xe00780f,0xee00f0,0x780e0780,0x1c007800,0xe00001,0xc000e000,0x0,0x700,

       0xf0780e07,0x8041c078,0x38020038,0xe03c1c,0x7001c00,0x1c00707,0x801c0070,0xe1c701c0,0xe0381e03,0x8380f00e,0x80380,0x1c003c1e,

       0x7e00f8,0xf80f1e00,0x3f003c00,0x70000e,0x1c000,0x0,0xf0100f7,0x80078000,0x700078f0,0x10,0x7ff000,0x61208,0x1e0700,0x383800f,

       0x78078000,0x3de007bc,0x0,0x0,0x0,0x0,0x0,0x401c,0x70e0f,0xf7803,0xc0000700,0x1c,0x38c001,0xc000efb8,0x1c00038,0x1e000,0x3c1e0,

       0xc1,0x80000000,0x783c0,0x0,0x0,0x0,0x3c1e,0x18c000,0x0,0x0,0xc180003,0x60000300,0xd80e010,0x3c03c780,0x78f00f1e,0x1e3c03c,

       0x70039c0e,0x70041c,0x38000,0x70000e00,0xe0001,0xc0003800,0x700380f,0x703f070,0x1e0e03c1,0xc078380f,0x701e0e0,0x381c0787,

       0x80f0f01e,0x1e03c3c0,0x7801c007,0xe00e,0x38078700,0xf0e01e1c,0x3c38078,0x700f1c1c,0x78041c,0x1038020,0x70040e00,0x800e0001,

       0xc0003800,0x7001c07,0x380e070,0x1c0e0381,0xc070380e,0x701c007,0x801e0703,0xc1e0783c,0xf0781e0,0xf003f007,0x80e00fc0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0xe,0x1801867c,0xc0cf83,0xe0000000,0xe0000e00,

       0x70,0xf0000,0x3c00,0x38000f1e,0xe0070,0x180780,0xe0603e,0x783c01e,0x1e0f01,0x7c003c0,0x780000,0x3c00001e,0x700,0x307fe700,

       0x38701e07,0xc1c383e0,0x38000700,0x7c1e38,0x3801c00,0xe0f01c03,0x81c000e0,0x38e03e0,0x78781c00,0x1e1e0e0,0xe180780,0xe003c1e,

       0x7c00f0,0x781e03c0,0x1c007000,0xe00001,0xc000e000,0x0,0x783,0xf07c1e07,0xc0c1e0f8,0x3e0e0038,0xf07c1c,0x7001c00,0x1c00703,

       0xc01e0070,0xe1c701c0,0xf0781f07,0x83c1f00e,0xe0f80,0x1e003c3e,0x7e00f8,0xf80e0e00,0x3f003800,0x70000e,0x1c000,0x0,0x7830077,

       0xf0000,0x700078f0,0x10,0x20000,0x41208,0xc03c0380,0x3c38007,0x70070000,0x1dc003b8,0x0,0x0,0x0,0x0,0x0,0x707c,0x6070f,0x86077003,

       0x80000700,0x1c,0x3ec401,0xc001c01c,0x1c00038,0xf000,0x1ffc0,0x40,0x80000000,0x3ff80,0x0,0x0,0x0,0x3e3e,0x18c000,0x0,0x0,

       0x8100006,0x60000300,0x1980f070,0x3801c700,0x38e0071c,0xe3801c,0x70039c0e,0x7c1c1c,0x38000,0x70000e00,0xe0001,0xc0003800,

       0x700383e,0x701f03c,0x3c078780,0xf0f01e1e,0x3c3c1c0,0x1c3f0f03,0xc1e0783c,0xf0781e0,0xf001c007,0xe81e,0x3c1f8783,0xf0f07e1e,

       0xfc3c1f8,0x783f1e3e,0x187c0c1f,0x703e0e0,0x7c1c0f83,0x800e0001,0xc0003800,0x7001e0f,0x380e078,0x3c0f0781,0xe0f03c1e,0x783c007,

       0x801e0f03,0xc3e0787c,0xf0f81e1,0xf003f007,0xc1e00fc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x1c,0xe,0x3801fff8,0x6187ff,0xe0000000,0xe0000e00,0x70,0xf0000,0x3c00,0x38000ffe,0x1fff0ff,0xfe1fff80,0xe07ffc,0x3ffc01c,

       0x1fff01,0xff8003c0,0x780000,0x4000010,0x700,0x301e6700,0x387ffe03,0xffc3ffc0,0x3fff0700,0x3ffe38,0x383ffe0,0xfff01c03,0xc1fff8e0,

       0x38e03e0,0x7ff81c00,0x1ffe0e0,0xf1fff80,0xe003ffe,0x7c00f0,0x781c01c0,0x1c00ffff,0xe00001,0xc000e000,0x0,0x3ff,0x707ffc03,

       0xffc0fff8,0x1ffe0038,0x7ffc1c,0x707fff0,0x1c00701,0xc00ff070,0xe1c701c0,0x7ff01fff,0x1fff00e,0xfff00,0xff81fee,0x7e00f0,

       0x781e0f00,0x1e007ffc,0x70000e,0x1c000,0x0,0x3ff003e,0xf0000,0xe00070e0,0x60830010,0x20000,0x41208,0xfffc01c0,0x1fffe03,0xe00ffff0,

       0xf8001f0,0x0,0x0,0x0,0x0,0x0,0x7ff8,0xc07fd,0xfe03e007,0xffc00700,0x1c,0x1ffc1f,0xffc08008,0x1c00038,0x7000,0x7f00,0x0,0x0,

       0xfe00,0x0,0xffff800,0x0,0x3ff7,0x8018c000,0x0,0x0,0x6,0x60000700,0x19807ff0,0x3801c700,0x38e0071c,0xe3801c,0x70039c0f,0xf03ffc1f,

       0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83ffc,0x701f03f,0xfc07ff80,0xfff01ffe,0x3ffc080,0x83fff03,0xffe07ffc,0xfff81ff,

       0xf001c007,0xeffc,0x1ffb83ff,0x707fee0f,0xfdc1ffb8,0x3ff70ff7,0xf83ffc0f,0xff01ffe0,0x3ffc07ff,0x83fff87f,0xff0fffe1,0xfffc0ffe,

       0x380e03f,0xf807ff00,0xffe01ffc,0x3ff8007,0x803ffe01,0xfee03fdc,0x7fb80ff,0x7001e007,0xffc00780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0xc,0x3801fff0,0x7f83fe,0x70000000,0xe0000e00,0x0,0xf0000,0x3c00,0x700007fc,

       0x1fff0ff,0xfe1ffe00,0xe07ff8,0x1ff801c,0xffe01,0xff0003c0,0x780000,0x0,0x700,0x38000f00,0x3c7ffc01,0xff83ff80,0x3fff0700,

       0x1ffc38,0x383ffe0,0x7fe01c01,0xe1fff8e0,0x38e03e0,0x3ff01c00,0xffc0e0,0x71fff00,0xe001ffc,0x7c00f0,0x783c01e0,0x1c00ffff,

       0xe00000,0xe000e000,0x0,0x1ff,0x7077f801,0xff807fb8,0xffc0038,0x3fdc1c,0x707fff0,0x1c00701,0xe007f070,0xe1c701c0,0x3fe01dfe,

       0xff700e,0x7fe00,0xff80fee,0x3c0070,0x703c0780,0x1e007ffc,0x70000e,0x1c000,0x0,0x1fe001c,0xe0000,0xe000e1c0,0x71c78010,0x20000,

       0x21318,0xfff800c0,0xfffe01,0xc00ffff0,0x70000e0,0x0,0x0,0x0,0x0,0x0,0x3ff0,0x1803fd,0xfe01c007,0xffc00700,0x1c,0xffc1f,0xffc00000,

       0x1c00038,0x7000,0x0,0x0,0x0,0x0,0x0,0xffff800,0x0,0x3ff7,0x8018c000,0x0,0x0,0xc,0x60000e00,0x31803fe0,0x7801ef00,0x3de007bc,

       0xf7801e,0xf003fc0f,0xf01ff81f,0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83ff8,0x701f01f,0xf803ff00,0x7fe00ffc,0x1ff8000,

       0x67fe01,0xffc03ff8,0x7ff00ff,0xe001c007,0xeff8,0xffb81ff,0x703fee07,0xfdc0ffb8,0x1ff70ff7,0xf81ff807,0xfe00ffc0,0x1ff803ff,

       0x3fff87f,0xff0fffe1,0xfffc07fc,0x380e01f,0xf003fe00,0x7fc00ff8,0x1ff0000,0x37fc00,0xfee01fdc,0x3fb807f,0x7001e007,0x7f800780,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0xc,0x30007fc0,0x1e00f8,0x78000000,0x70001c00,

       0x0,0xe0000,0x3c00,0x700001f0,0x1fff0ff,0xfe07f800,0xe01fe0,0x7e0038,0x3f800,0xfc0003c0,0x700000,0x0,0x700,0x18000e00,0x1c7ff000,

       0x7e03fe00,0x3fff0700,0x7f038,0x383ffe0,0x1f801c00,0xf1fff8e0,0x38e01e0,0xfc01c00,0x3f80e0,0x787fc00,0xe0007f0,0x7c00f0,0x387800f0,

       0x1c00ffff,0xe00000,0xe000e000,0x0,0xfc,0x7071f000,0x3f003e38,0x3f00038,0x1f1c1c,0x707fff0,0x1c00700,0xf003f070,0xe1c701c0,

       0x1f801c7c,0x7c700e,0x1f800,0x3f8078e,0x3c0070,0x707803c0,0x1c007ffc,0x70000e,0x1c000,0x0,0x7c0008,0x1e0000,0xe000e1c0,0x71c30010,

       0x20000,0x1e1f0,0x3fe00020,0x3ffe00,0x800ffff0,0x2000040,0x0,0x0,0x0,0x0,0x0,0xfc0,0x3001f0,0x78008007,0xffc00700,0x1c,0x3f81f,

       0xffc00000,0x1c00038,0x407000,0x0,0x0,0x0,0x0,0x0,0xffff800,0x0,0x39c7,0x18c000,0x0,0x0,0x18,0x60001c00,0x61801f80,0x7000ee00,

       0x1dc003b8,0x77000e,0xe001f80f,0xf007e01f,0xff83fff0,0x7ffe0fff,0xc1fff03f,0xfe07ffc0,0xfff83fc0,0x700f007,0xe000fc00,0x1f8003f0,

       0x7e0000,0xe1f800,0x7f000fe0,0x1fc003f,0x8001c007,0xe7f0,0x7e380fc,0x701f8e03,0xf1c07e38,0xfc703c1,0xe003f001,0xf8003f00,

       0x7e000fc,0x3fff87f,0xff0fffe1,0xfffc03f8,0x380e00f,0xc001f800,0x3f0007e0,0xfc0000,0x61f800,0x78e00f1c,0x1e3803c,0x7001c007,

       0x1f000700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x70001c00,0x0,

       0x1c0000,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0xe00000,0x0,0x0,0xc000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,

       0x0,0x0,0x0,0x0,0xe00000,0x7000e000,0x0,0x0,0x0,0x0,0x0,0x1c00,0x0,0x1c00000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x0,0x1c000000,

       0x70000e,0x1c000,0x0,0x0,0x1c0000,0xe000c180,0x10,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,

       0x0,0x38,0x70e000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x18c000,0x2000,0x0,0x1f,0xf8003800,0x7fe00000,0x0,0x0,0x0,0x0,0x4000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,

       0x0,0x0,0x1c007,0x700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x30001800,

       0x0,0x1c0000,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0xe00000,0x0,0x0,0xe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e000,

       0x0,0x0,0x0,0x0,0x0,0xe00000,0x7000e000,0x0,0x0,0x0,0x0,0x0,0x1c00,0x0,0x1c00000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x0,0x1c000000,

       0x70000e,0x1c000,0x0,0x0,0x1c0001,0xe001c380,0x10,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,

       0x0,0x38,0x7fe000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x18c000,0x3000,0x0,0x1f,0xf8007000,0x7fe00000,0x0,0x0,0x0,0x0,0x6000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x1c007,0x700,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x38003800,

       0x0,0x380000,0x1,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x1c00000,0x0,0x0,0x3c18000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf000,

       0x0,0x0,0x0,0x0,0x0,0xfe0000,0x380fe000,0x0,0x0,0x0,0x0,0x0,0x3800,0x0,0x1c00000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x0,0x38000000,

       0x78000e,0x3c000,0x0,0x0,0x180001,0xc0018300,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,

       0x38,0x1f8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x18c000,0x1800,0x0,0x0,0x6000e000,0x1800000,0x0,0x0,0x0,0x0,0x3000,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x38007,0xe00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x18003000,

       0x0,0x300000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1800000,0x0,0x0,0x1ff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,

       0x0,0x0,0x0,0xfe0000,0xfe000,0x0,0x0,0x0,0x0,0x0,0x607800,0x0,0x3c00000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x0,0x78000000,

       0x3f800e,0x3f8000,0x0,0x0,0x300043,0xc0018200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,

       0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x0,0x11800,0x0,0x0,0x6001ff00,0x1800000,0x0,0x0,0x0,0x0,0x23000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x23000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78007,

       0x1e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x1c007000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe0000,

       0xfe000,0x0,0x0,0x0,0x0,0x0,0x7ff000,0x0,0x7f800000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x3,0xf8000000,0x3f800e,0x3f8000,0x0,

       0x0,0x10007f,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x38,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x3800,0x0,0x1f800,0x0,0x0,0x6001ff00,0x1800000,0x0,0x0,0x0,0x0,0x3f000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8007,0xfe00,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fff8,0x0,0x0,0x0,0x0,0x7fe000,0x0,

       0x7f000000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x3,0xf0000000,0xf800e,0x3e0000,0x0,0x0,0x7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800,0x0,0x1f000,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x3e000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x3f0007,0xfc00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x7fff8,0x0,0x0,0x0,0x0,0x1fc000,0x0,0x7e000000,0x0,0x0,0x1c00,0x7000,0x0,0x0,0x0,0x3,0xc0000000,0xe,0x0,

       0x0,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x3800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0007,0xf000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 29x57 font.

     const unsigned int font29x57[29*57*256/32] = {

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x781e00,0x0,0x0,0x7,0x81e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c0000,0xf8000,0x7e00000,0x0,0x7,

       0xc0000000,0x0,0x7c00,0xf80,0x7e000,0x0,0x7c00000,0xf80000,0x7e000000,0x0,0x0,0x1f00,0x3e0,0x1f800,0x0,0x0,0x0,0x3,0xe0000000,

       0x7c00003f,0x0,0xf8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x3c3c00,0x0,0x0,0x3,0xc3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e1f00,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e0000,

       0x1f0000,0x7e00000,0xf838001f,0xf80001f,0xf0000000,0x0,0x3e00,0x1f00,0x7e000,0x3e1f000,0x3e00000,0x1f00000,0x7e00003e,0x1f000000,

       0x3e0,0xe0000f80,0x7c0,0x1f800,0x3e0e00,0x7c3e000,0x0,0x1,0xf0000000,0xf800003f,0x1f0f,0x800001f0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e7800,0x0,0x0,

       0x1,0xe7800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0000,0x1e0000,0xff00001,0xfe38001f,0xf80003f,

       0xf8000000,0x0,0x1e00,0x1e00,0xff000,0x3e1f000,0x1e00000,0x1e00000,0xff00003e,0x1f000000,0x7f8,0xe0000780,0x780,0x3fc00,0x7f8e00,

       0x7c3e000,0x0,0x0,0xf0000000,0xf000007f,0x80001f0f,0x800001e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xef000,0x0,0x0,0x0,0xef000000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000,0x3c0000,0x1e780003,0xfff8001f,0xf80003c,0x78000000,0x0,0xf00,0x3c00,0x1e7800,

       0x3e1f000,0xf00000,0x3c00001,0xe780003e,0x1f000000,0xfff,0xe00003c0,0xf00,0x79e00,0xfffe00,0x7c3e000,0x0,0x0,0x78000001,0xe00000f3,

       0xc0001f0f,0x800003c0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e000,0x0,0x0,0x0,0x7e000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x78000,0x780000,0x3c3c0003,0x8ff0001f,0xf800078,0x3c000000,0x0,0x780,0x7800,0x3c3c00,0x3e1f000,0x780000,0x7800003,0xc3c0003e,

       0x1f000000,0xe3f,0xc00001e0,0x1e00,0xf0f00,0xe3fc00,0x7c3e000,0x0,0x0,0x3c000003,0xc00001e1,0xe0001f0f,0x80000780,0x0,0x0,

       0x0,0x0,0x0,0x0,0x1f,0xf0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x7e000,0x0,0x0,0x0,0x7e000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfc00,0x7e000,0xfe000,0x0,0x3c000,0xf00000,0x781e0003,

       0x83e0001f,0xf800070,0x1c000000,0x0,0x3c0,0xf000,0x781e00,0x3e1f000,0x3c0000,0xf000007,0x81e0003e,0x1f000000,0xe0f,0x800000f0,

       0x3c00,0x1e0780,0xe0f800,0x7c3e000,0x0,0x0,0x1e000007,0x800003c0,0xf0001f0f,0x80000f00,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0xf8000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3fc00,0x1fe000,0x3ff800,0x0,0x0,0x0,0x0,0x0,0x70,0x1c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x78000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x78,0xf000000,0x0,0x0,0x780f0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x3fc00,0x1fe000,0x3ffc00,0x0,0x0,0x0,0x0,0x0,0x70,0x1c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f00000,0x3e000,0x3e00000,0x0,0x78,0x3c000000,0x0,0x1f000,0x3e0,

       0x3e000,0x0,0x1f000000,0x3e0000,0x3e000000,0x0,0x0,0x7c00,0xf8,0xf800,0x0,0x0,0x0,0xf,0x80000000,0x1f00001f,0x0,0x3e,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf80000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0xf80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x781c0000,0x38,0xe000000,0x0,0x0,0x380e0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf80,0x0,0x0,0x0,0x0,0x0,0x0,0x39c00,0x1ce000,0x303e00,

       0x0,0x0,0x0,0x0,0x0,0x78,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,

       0x0,0x0,0xf80000,0x7c000,0x3e00000,0xf0380000,0x70,0x1c000000,0x0,0xf800,0x7c0,0x3e000,0x0,0xf800000,0x7c0000,0x3e000000,

       0x0,0x3c0,0xe0003e00,0x1f0,0xf800,0x3c0e00,0x0,0x0,0x7,0xc0000000,0x3e00001f,0x0,0x7c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0xff,0x0,

       0xf8,0xf8000,0x1c000,0x0,0x0,0x0,0x0,0x1f,0xc0000000,0x1ff8,0xff00,0x0,0x0,0x3fe000,0x0,0x1fc00001,0xfe000000,0x0,0x0,0x0,

       0x0,0x7f800,0x0,0x0,0x0,0xff00000,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xf8000000,0xfe,0x0,0x7f80,0x0,0x0,0x0,0x0,0x0,

       0x0,0x3f,0xf0000000,0x7fe0,0x0,0x0,0x780000,0x1,0xe0000000,0x0,0x780000,0x3,0xfe000000,0x78000,0x3c00,0xf000,0x7800003,0xffe00000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfc0000f0,0x3f000,0x0,0x0,0x3fc00,0x0,0x0,0x1fc000,0x0,0x0,0x0,0x1fc0,

       0x0,0xff000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe1c0000,0x1c,0x1c000000,0x0,0x0,0x1c1c0,0x0,0x0,0x0,0x0,0x1fe0000,

       0x0,0x0,0x1ff,0x1f0f8,0x0,0xff000,0x0,0x0,0x0,0x3f,0xff00000f,0x80000000,0xfe0,0x3f80,0xf00,0x0,0x0,0x0,0x1,0xf8000003,0xe0000000,

       0x1c00,0xe000,0xe00,0x0,0x0,0x0,0x0,0x0,0x3c,0x78000000,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f0,0x3f80,0x1fc00,0xfe000,

       0x7f0000,0x0,0x1fc07000,0x0,0x0,0x0,0x0,0x0,0x3f800,0x780000,0x78000,0x7f00001,0xfc38001f,0xf800070,0x1c000000,0x0,0x7800,

       0x780,0x7f000,0x3e1f000,0x7800000,0x780000,0x7f00003e,0x1f0003f0,0x7f0,0xe0001e00,0x1e0,0x1fc00,0x7f0e00,0x7c3e000,0x0,0x3,

       0xc0000000,0x3c00003f,0x80001f0f,0x80000078,0x1e0000,0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,0x1e078000,0x30000000,0x3ff,0xc00001e0,0xf0,

       0x78000,0x1c000,0x0,0x0,0x0,0x0,0x1e0007f,0xf000007e,0x1ffff,0x7ffe0,0x1f80,0x3ffff80,0xfff803,0xfffff800,0xfff80007,0xff800000,

       0x0,0x0,0x0,0x0,0x1ffe00,0x0,0xfe0003,0xfff80000,0x3ffe01ff,0xe00003ff,0xffe01fff,0xff0003ff,0xe01e0007,0x803ffff0,0xfff80,

       0x3c000fc0,0x7800001f,0x8003f07e,0x1e000f,0xfe0007ff,0xf00003ff,0x8007ffe0,0x1fff8,0x7fffffe,0xf0003c1,0xe000079e,0xf1f,0x1f3e0,

       0x1f01ff,0xfff8003f,0xf003c000,0x7fe0,0x3f00,0x0,0x3c0000,0x1,0xe0000000,0x0,0x780000,0xf,0xfe000000,0x78000,0x3c00,0xf000,

       0x7800003,0xffe00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0xfc0000f0,0x3fe00,0x0,0x0,0xfff00,0x0,0x0,0x3fe000,

       0x0,0x0,0x0,0x1dc0,0x0,0x3fff00,0x0,0x3ffff80,0x1f,0xffff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff1c07ff,0x3c0f001e,0x3c000000,

       0x0,0x0,0x1e3c0,0xf80007c,0x0,0x780000,0x0,0xfff8000,0x3e00,0x1f00000,0x7ff,0xc001f0f8,0x0,0x3ffc00,0x0,0x0,0x0,0x3f,0xff00003f,

       0xe0000000,0x3ff8,0xffe0,0x1e00,0x0,0xfffc00,0x0,0x7,0xf800000f,0xf8000000,0x1c00,0xe000,0xe00,0xf000,0x1fc000,0xfe0000,0x7f00000,

       0x3f800001,0xfc00003f,0xf80000ff,0xffc003ff,0xe007ffff,0xc03ffffe,0x1fffff0,0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01ffc,

       0xfc00,0x3c001ffc,0xffe0,0x7ff00,0x3ff800,0x1ffc000,0x0,0x7ff8f0f0,0x3c0780,0x1e03c00,0xf01e000,0x783e0001,0xf01e0000,0xffe00,

       0x3c0000,0xf0000,0x7700001,0xfe38001f,0xf800070,0x1c000000,0x0,0x3c00,0xf00,0x77000,0x3e1f000,0x3c00000,0xf00000,0x7700003e,

       0x1f0000f8,0xc0007f8,0xe0000f00,0x3c0,0x1dc00,0x7f8e00,0x7c3e000,0x0,0x1,0xe0000000,0x7800003b,0x80001f0f,0x800000f0,0x1e0000,

       0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x780000,0x3c1e0000,0x1e070000,0x300001f0,0x7ff,0xc00001e0,0x1e0,0x7c000,0x1c000,0x0,0x0,0x0,0x0,0x3c000ff,0xf80007fe,

       0x3ffff,0x801ffff8,0x1f80,0x3ffff80,0x3fff803,0xfffff801,0xfffc000f,0xffc00000,0x0,0x0,0x0,0x0,0x7fff80,0x0,0xfe0003,0xffff0000,

       0xffff01ff,0xfc0003ff,0xffe01fff,0xff000fff,0xf01e0007,0x803ffff0,0xfff80,0x3c001f80,0x7800001f,0xc007f07e,0x1e001f,0xff0007ff,

       0xfc0007ff,0xc007fffc,0x3fffc,0x7fffffe,0xf0003c1,0xf0000f9e,0xf0f,0x8003e1e0,0x1e01ff,0xfff8003f,0xf001e000,0x7fe0,0x3f00,

       0x0,0x1e0000,0x1,0xe0000000,0x0,0x780000,0x1f,0xfe000000,0x78000,0x3c00,0xf000,0x7800003,0xffe00000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xfc0000f0,0x3ff00,0x0,0x0,0x1fff80,0x0,0x0,0xffe000,0x0,0x0,0x0,0x3de0,0x0,0x7fff80,0x0,0xfffff80,

       0x1f,0xffff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe7bc07ff,0x3e1f000f,0x78000000,0x0,0x0,0xf780,0x7800078,0x0,0x780000,0x180000,

       0x1fff8000,0x1e00,0x1e0003c,0xfff,0xc001f0f8,0x0,0x7ffe00,0x0,0x0,0x0,0x3f,0xff00007f,0xf0000000,0x3ffc,0xfff0,0x3c00,0x0,

       0x7fffc00,0x0,0x7,0xf800003f,0xfe000000,0x1c00,0xe000,0xe00,0xf000,0x1fc000,0xfe0000,0x7f00000,0x3f800001,0xfc00001f,0xe00001ff,

       0xffc00fff,0xf007ffff,0xc03ffffe,0x1fffff0,0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01fff,0xc000fc00,0x3c003ffe,0x1fff0,

       0xfff80,0x7ffc00,0x3ffe000,0x0,0xfffce0f0,0x3c0780,0x1e03c00,0xf01e000,0x781e0001,0xe01e0000,0x3fff00,0x1e0000,0x1e0000,0xf780003,

       0xcf78001f,0xf800078,0x3c000000,0x0,0x1e00,0x1e00,0xf7800,0x3e1f000,0x1e00000,0x1e00000,0xf780003e,0x1f0000fc,0x7c000f3d,

       0xe0000780,0x780,0x3de00,0xf3de00,0x7c3e000,0x0,0x0,0xf0000000,0xf000007b,0xc0001f0f,0x800001e0,0x1e0000,0x3e1f00,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,

       0x3c1e0000,0x1e0f0000,0x300007fc,0xfff,0xc00001e0,0x1e0,0x3c000,0x1c000,0x0,0x0,0x0,0x0,0x3c001ff,0xfc001ffe,0x3ffff,0xc01ffffc,

       0x3f80,0x3ffff80,0x7fff803,0xfffff803,0xfffe001f,0xffe00000,0x0,0x0,0x0,0x0,0xffff80,0x7f800,0xfe0003,0xffff8001,0xffff01ff,

       0xff0003ff,0xffe01fff,0xff001fff,0xf01e0007,0x803ffff0,0xfff80,0x3c003f00,0x7800001f,0xc007f07f,0x1e003f,0xff8007ff,0xff000fff,

       0xe007ffff,0x7fffc,0x7fffffe,0xf0003c0,0xf0000f1e,0xf07,0x8003c1f0,0x3e01ff,0xfff8003f,0xf001e000,0x7fe0,0x7f80,0x0,0xe0000,

       0x1,0xe0000000,0x0,0x780000,0x1f,0xfe000000,0x78000,0x3c00,0xf000,0x7800003,0xffe00000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,

       0x0,0x0,0x0,0x0,0xf,0xfc0000f0,0x3ff00,0x0,0x0,0x3fff80,0x0,0x0,0xffe000,0x0,0x0,0x0,0x78f0,0x0,0xffff80,0x0,0x3fffff80,0x1f,

       0xffff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xc7f80070,0x3e1f0007,0x70000000,0x0,0x0,0x7700,0x7c000f8,0x0,0x780000,0x180000,

       0x3fff8000,0x1f00,0x3e0003c,0x1f03,0xc001f0f8,0x0,0x703f00,0x0,0x0,0x0,0x3f,0xff0000f0,0xf8000000,0x303e,0xc0f8,0x7800,0x0,

       0xffffc00,0x0,0x7,0x3800003e,0x3e000000,0x1c00,0xe000,0x3c00,0xf000,0x1fc000,0xfe0000,0x7f00000,0x3f800001,0xfc00000f,0xe00001ff,

       0xffc01fff,0xf007ffff,0xc03ffffe,0x1fffff0,0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01fff,0xf000fe00,0x3c007fff,0x3fff8,

       0x1fffc0,0xfffe00,0x7fff000,0x1,0xffffc0f0,0x3c0780,0x1e03c00,0xf01e000,0x781f0003,0xe01e0000,0x3fff80,0xe0000,0x3c0000,0x1e3c0003,

       0x8ff0001f,0xf80003c,0x78000000,0x0,0xe00,0x3c00,0x1e3c00,0x3e1f000,0xe00000,0x3c00001,0xe3c0003e,0x1f00007f,0xf8000e3f,0xc0000380,

       0xf00,0x78f00,0xe3fc00,0x7c3e000,0x0,0x0,0x70000001,0xe00000f1,0xe0001f0f,0x800003c0,0x1e0000,0x3e1f00,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,0x3c0f0000,

       0x30000ffe,0xf80,0xc00001e0,0x3c0,0x1e000,0x101c040,0x0,0x0,0x0,0x0,0x78003f0,0x7e001ffe,0x3f807,0xe01f00fe,0x3f80,0x3ffff80,

       0x7e01803,0xfffff007,0xe03f003f,0x3f00000,0x0,0x0,0x0,0x0,0xfc0fc0,0x3ffe00,0xfe0003,0xffffc003,0xf81f01ff,0xff8003ff,0xffe01fff,

       0xff003f01,0xf01e0007,0x803ffff0,0xfff80,0x3c007e00,0x7800001f,0xc007f07f,0x1e007e,0xfc007ff,0xff801f83,0xf007ffff,0x800fc07c,

       0x7fffffe,0xf0003c0,0xf0000f0f,0x1e07,0xc007c0f8,0x7c01ff,0xfff8003c,0xf000,0x1e0,0xffc0,0x0,0xf0000,0x1,0xe0000000,0x0,0x780000,

       0x3e,0x0,0x78000,0x3c00,0xf000,0x7800000,0x1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,0x0,0x0,0x0,0x0,0x1f,0x800000f0,0x1f80,

       0x0,0x0,0x7e0780,0x0,0x0,0x1f82000,0x0,0x0,0x0,0x7070,0x0,0x1f80f80,0x0,0x7fffff80,0x1f,0xffff8000,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x1,0xc3f80070,0x3f3f0007,0xf0000000,0x0,0x0,0x7f00,0x3e001f0,0x0,0x780000,0x180000,0x7f018000,0xf80,0x7c0003c,0x3e00,

       0x4001f0f8,0xfe00,0x400f00,0x0,0x0,0x0,0x7f000000,0xe0,0x38000000,0x1e,0x38,0x7800,0x0,0x1ffe1c00,0x0,0x0,0x38000078,0xf000000,

       0x1c00,0xe000,0x7f800,0xf000,0x1fc000,0xfe0000,0x7f00000,0x3f800001,0xfc00001f,0xf00001ff,0xffc03f81,0xf007ffff,0xc03ffffe,

       0x1fffff0,0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01fff,0xf800fe00,0x3c00fc1f,0x8007e0fc,0x3f07e0,0x1f83f00,0xfc1f800,

       0x3,0xf07fc0f0,0x3c0780,0x1e03c00,0xf01e000,0x780f8007,0xc01e0000,0x7e0fc0,0xf0000,0x3c0000,0x1c1c0003,0x87f0001f,0xf80003f,

       0xf8000000,0x0,0xf00,0x3c00,0x1c1c00,0x3e1f000,0xf00000,0x3c00001,0xc1c0003e,0x1f00003f,0xc0000e1f,0xc00003c0,0xf00,0x70700,

       0xe1fc00,0x7c3e000,0x0,0x0,0x78000001,0xe00000e0,0xe0001f0f,0x800003c0,0x1e0000,0x3e1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,0x3c0f0001,0xff801e0f,

       0x1f00,0x1e0,0x3c0,0x1e000,0x3c1c1e0,0x0,0x0,0x0,0x0,0x78007c0,0x1f001f9e,0x3c001,0xf010003e,0x7780,0x3c00000,0xf800000,0xf007,

       0xc01f007c,0x1f80000,0x0,0x0,0x0,0x0,0xe003e0,0x7fff00,0x1ef0003,0xc007e007,0xc00301e0,0x1fc003c0,0x1e00,0x7c00,0x301e0007,

       0x80007800,0x780,0x3c00fc00,0x7800001f,0xe00ff07f,0x1e00f8,0x3e00780,0x1fc03e00,0xf807801f,0xc01f001c,0xf000,0xf0003c0,0xf0000f0f,

       0x1e03,0xc00f8078,0x780000,0xf0003c,0xf000,0x1e0,0x1f3e0,0x0,0x78000,0x1,0xe0000000,0x0,0x780000,0x3c,0x0,0x78000,0x0,0x0,

       0x7800000,0x1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,0x0,0x0,0x0,0x0,0x1f,0xf0,0xf80,0x0,0x0,0xf80180,0x0,0x0,0x1e00000,

       0x0,0x0,0x0,0xe038,0x0,0x3e00380,0x0,0xfe0f0000,0x0,0xf0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xc0f00070,0x3b370003,0xe0000000,

       0x0,0x0,0x3e00,0x1e001e0,0x0,0x780000,0x180000,0x7c000000,0x780,0x780003c,0x3c00,0x0,0x7ffc0,0x780,0x0,0x0,0x3,0xffe00000,

       0x1c0,0x3c000000,0xe,0x38,0xf000,0x0,0x3ffe1c00,0x0,0x0,0x38000078,0xf000000,0x1c00,0xe000,0x7f000,0xf000,0x3de000,0x1ef0000,

       0xf780000,0x7bc00003,0xde00001e,0xf00003e7,0x80007c00,0x30078000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,

       0xe0001e03,0xfc00fe00,0x3c01f007,0xc00f803e,0x7c01f0,0x3e00f80,0x1f007c00,0x7,0xc01f80f0,0x3c0780,0x1e03c00,0xf01e000,0x78078007,

       0x801e0000,0x7803c0,0x78000,0x780000,0x380e0003,0x81e00000,0x1f,0xf0000000,0x0,0x780,0x7800,0x380e00,0x0,0x780000,0x7800003,

       0x80e00000,0x1ff,0x80000e07,0x800001e0,0x1e00,0xe0380,0xe07800,0x0,0x0,0x0,0x3c000003,0xc00001c0,0x70000000,0x780,0x1e0000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x780000,0x3c1e0000,0x3c0e0007,0xfff01c07,0x1e00,0x1e0,0x780,0xf000,0x3e1c3e0,0x0,0x0,0x0,0x0,0xf0007c0,0x1f00181e,0x20000,

       0xf000001f,0xf780,0x3c00000,0x1f000000,0x1f00f,0x800f8078,0xf80000,0x0,0x0,0x0,0x0,0x8003e0,0x1fc0f80,0x1ef0003,0xc001e007,

       0x800101e0,0x7e003c0,0x1e00,0x7800,0x101e0007,0x80007800,0x780,0x3c00f800,0x7800001e,0xe00ef07f,0x801e00f0,0x1e00780,0x7c03c00,

       0x78078007,0xc01e0004,0xf000,0xf0003c0,0x78001e0f,0x1e03,0xe00f807c,0xf80000,0x1f0003c,0x7800,0x1e0,0x3e1f0,0x0,0x3c000,0x1,

       0xe0000000,0x0,0x780000,0x3c,0x0,0x78000,0x0,0x0,0x7800000,0x1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,0x0,0x0,0x0,0x0,

       0x1e,0xf0,0x780,0x0,0x0,0x1f00080,0x0,0x0,0x3c00000,0x0,0x0,0x0,0x1e03c,0x0,0x3c00080,0x0,0xf80f0000,0x0,0x1f0000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x3bf70003,0xe0000000,0x0,0x0,0x3e00,0x1f003e0,0x0,0x780000,0x180000,0x78000000,0x7c0,0xf80003c,

       0x3c00,0x0,0x1f01f0,0x780,0x0,0x0,0xf,0x80f80000,0x1c0,0x1c000000,0xe,0x38,0x1e000,0x0,0x7ffe1c00,0x0,0x0,0x380000f0,0x7800000,

       0x1c00,0xe000,0x7fc00,0xf000,0x3de000,0x1ef0000,0xf780000,0x7bc00003,0xde00001e,0xf00003c7,0x80007800,0x10078000,0x3c0000,

       0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x7e00ff00,0x3c01e003,0xc00f001e,0x7800f0,0x3c00780,0x1e003c00,

       0x7,0x800f00f0,0x3c0780,0x1e03c00,0xf01e000,0x7807c00f,0x801e0000,0xf803c0,0x3c000,0xf00000,0x780f0000,0x0,0x7,0xc0000000,

       0x0,0x3c0,0xf000,0x780f00,0x0,0x3c0000,0xf000007,0x80f00000,0x7ff,0xc0000000,0xf0,0x3c00,0x1e03c0,0x0,0x0,0x0,0x0,0x1e000007,

       0x800003c0,0x78000000,0xf00,0x1e0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,0x3c1e001f,0xfff03803,0x80001e00,0x1e0,0x780,0xf000,0xf9cf80,

       0x0,0x0,0x0,0x0,0xf000780,0xf00001e,0x0,0xf800000f,0xe780,0x3c00000,0x1e000000,0x1e00f,0x78078,0x7c0000,0x0,0x0,0x0,0x0,0x1e0,

       0x3f003c0,0x1ef0003,0xc000f00f,0x800001e0,0x1f003c0,0x1e00,0xf000,0x1e0007,0x80007800,0x780,0x3c01f000,0x7800001e,0xe00ef07f,

       0x801e01f0,0x1e00780,0x3c07c00,0x78078003,0xc03e0000,0xf000,0xf0003c0,0x78001e0f,0x1e01,0xf01f003c,0xf00000,0x3e0003c,0x7800,

       0x1e0,0x7c0f8,0x0,0x0,0x1,0xe0000000,0x0,0x780000,0x3c,0x0,0x78000,0x0,0x0,0x7800000,0x1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,

       0x0,0x0,0x0,0x0,0x0,0x1e,0xf0,0x780,0x0,0x0,0x1e00000,0x0,0x0,0x3c00000,0x0,0x8,0x40,0x0,0x7e0000,0x7c00000,0x1,0xf00f0000,

       0x0,0x3e0000,0x0,0x3f,0xfc0,0xfc3f0,0xfc3f0,0x0,0x0,0x0,0x70,0x39e70000,0x0,0x0,0x0,0x0,0xf003c0,0x0,0x0,0x180000,0xf8000000,

       0x3c0,0xf00003c,0x3c00,0x0,0x3c0078,0x7ff80,0x0,0x0,0x1e,0x3c0000,0x1c0,0x1c000000,0xe,0xf0,0x0,0x0,0x7ffe1c00,0x0,0x0,0x380000f0,

       0x7800000,0x1c00,0xe000,0x3c00,0x0,0x3de000,0x1ef0000,0xf780000,0x7bc00003,0xde00001e,0xf00003c7,0x8000f800,0x78000,0x3c0000,

       0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x1f00ff00,0x3c03e003,0xc01f001e,0xf800f0,0x7c00780,0x3e003c00,

       0xf,0x800f80f0,0x3c0780,0x1e03c00,0xf01e000,0x7803c00f,0x1fffc0,0xf001e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x307,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,0x781e003f,0xfff03803,

       0x80001e00,0x1e0,0xf80,0xf000,0x3dde00,0x0,0x0,0x0,0x0,0xf000f00,0x780001e,0x0,0x7800000f,0x1e780,0x3c00000,0x3e000000,0x3e00f,

       0x780f0,0x7c0000,0x0,0x0,0x0,0x0,0x1e0,0x7c001e0,0x3ef8003,0xc000f00f,0x1e0,0xf003c0,0x1e00,0xf000,0x1e0007,0x80007800,0x780,

       0x3c03e000,0x7800001e,0xf01ef07b,0xc01e01e0,0xf00780,0x3e07800,0x3c078003,0xe03c0000,0xf000,0xf0003c0,0x78001e0f,0x1e00,0xf01e003e,

       0x1f00000,0x3c0003c,0x7800,0x1e0,0x78078,0x0,0x0,0x1,0xe0000000,0x0,0x780000,0x3c,0x0,0x78000,0x0,0x0,0x7800000,0x1e00000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x3c000,0x0,0x0,0x0,0x0,0x0,0x1e,0xf0,0x780,0x0,0x0,0x1e00000,0x0,0x0,0x3c00000,0x0,0x18,0xc0,0x0,

       0xe70000,0x7800000,0x1,0xe00f0000,0x0,0x3c0000,0x0,0x3f,0xfc0,0xfc1f0,0x1f83f0,0x0,0x0,0x0,0x70,0x39e70000,0x0,0x0,0x0,0x0,

       0xf807c0,0x0,0x0,0x180000,0xf0000000,0x3e0,0x1f00003c,0x3e00,0x0,0x70001c,0x3fff80,0x0,0x0,0x38,0xe0000,0x1c0,0x1c000078,

       0x1c,0x1fe0,0x0,0x0,0xfffe1c00,0x0,0x0,0x380000f0,0x7800000,0x1c00,0xe000,0xe00,0x0,0x7df000,0x3ef8000,0x1f7c0000,0xfbe00007,

       0xdf00003c,0x780003c7,0x8000f000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0xf00f780,

       0x3c03c001,0xe01e000f,0xf00078,0x78003c0,0x3c001e00,0xf,0xf80f0,0x3c0780,0x1e03c00,0xf01e000,0x7803e01f,0x1ffff8,0xf001e0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x0,0x0,0x1e0000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x780000,0x3c1e0000,0x781e003e,0x30703803,0x80001e00,0x1e0,0xf00,0x7800,0xff800,0x1e0000,0x0,0x0,0x0,0x1e000f00,0x780001e,

       0x0,0x7800000f,0x3c780,0x3c00000,0x3c000000,0x3c00f,0x780f0,0x3c0000,0x0,0x0,0x2000000,0x800000,0x1e0,0x78000e0,0x3c78003,

       0xc000f01e,0x1e0,0xf803c0,0x1e00,0x1e000,0x1e0007,0x80007800,0x780,0x3c07c000,0x7800001e,0x701cf07b,0xc01e01e0,0xf00780,0x1e07800,

       0x3c078001,0xe03c0000,0xf000,0xf0003c0,0x7c003e0f,0x1e00,0xf83e001e,0x1e00000,0x7c0003c,0x3c00,0x1e0,0xf807c,0x0,0x0,0x1fe0001,

       0xe1fc0000,0x7f00003,0xf8780007,0xf000003c,0x7f0,0x783f0,0x0,0x0,0x7800000,0x1e00000,0x3e0f8000,0xfc00007,0xf8000007,0xf00001fc,

       0xf,0xc0003fc0,0x3c000,0x0,0x0,0x0,0x0,0x0,0x1e,0xf0,0x780,0x0,0x0,0x3c00000,0x0,0x0,0x3c00000,0x0,0x18,0xc0,0x0,0x1818000,

       0x7800000,0x1,0xe00f0000,0x0,0x7c0000,0x0,0x1f,0x80001f80,0x7c1f8,0x1f83e0,0x0,0x0,0x0,0x70,0x38c70007,0xf8000000,0x7f03,

       0xf0000000,0x0,0x780780,0x0,0x0,0xfe0000,0xf0000000,0x1e0,0x1e00003c,0x3f00,0x0,0xe07f0e,0x7fff80,0x0,0x0,0x70,0x70000,0x1c0,

       0x1c000078,0x3c,0x1fc0,0x0,0x0,0xfffe1c00,0x0,0x0,0x380000f0,0x7800000,0x1c00,0xe000,0xe00,0x0,0x78f000,0x3c78000,0x1e3c0000,

       0xf1e00007,0x8f00003c,0x78000787,0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,

       0xf80f780,0x3c03c001,0xe01e000f,0xf00078,0x78003c0,0x3c001e00,0xf,0x1f80f0,0x3c0780,0x1e03c00,0xf01e000,0x7801e01e,0x1ffffc,

       0xf007e0,0x3fc000,0x1fe0000,0xff00000,0x7f800003,0xfc00001f,0xe0000fc0,0xfc00007f,0xfe0,0x7f00,0x3f800,0x1fc000,0x0,0x0,0x0,

       0x1,0xf000001f,0x80000ff0,0x7f80,0x3fc00,0x1fe000,0xff0000,0x1f80000,0x1fc1e000,0x0,0x0,0x0,0x0,0x1e1fc0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e0000,

       0x781c007c,0x30003803,0x80001f00,0x1e0,0xf00,0x7800,0x7f000,0x1e0000,0x0,0x0,0x0,0x1e000f00,0x780001e,0x0,0x7800000f,0x3c780,

       0x3c00000,0x3c000000,0x3c00f,0x780f0,0x3c0000,0x0,0x0,0x1e000000,0xf00000,0x3e0,0xf0000e0,0x3c78003,0xc000f01e,0x1e0,0x7803c0,

       0x1e00,0x1e000,0x1e0007,0x80007800,0x780,0x3c0f8000,0x7800001e,0x701cf079,0xe01e01e0,0xf00780,0x1e07800,0x3c078001,0xe03c0000,

       0xf000,0xf0003c0,0x3c003c0f,0x3e00,0x787c001f,0x3e00000,0xf80003c,0x3c00,0x1e0,0x1f003e,0x0,0x0,0x1fffc001,0xe7ff0000,0x3ffe000f,

       0xfe78003f,0xfc001fff,0xfe001ffc,0xf0078ffc,0x1ffc00,0x7ff000,0x7800f80,0x1e0000f,0x7f1fc01e,0x3ff0001f,0xfe00079f,0xfc0007ff,

       0x3c003c7f,0xf001fff8,0x1fffff0,0x3c003c0,0xf0000f1e,0xf1f,0x7c1f0,0x1f00ff,0xffe0001e,0xf0,0x780,0x0,0x0,0x3c00000,0x100000,

       0x0,0x7800000,0x0,0x18,0xc0,0x0,0x1818000,0x7800000,0x1,0xe00f0000,0x1000000,0xf80000,0x40000002,0xf,0x80001f00,0x7e0f8,0x1f07c0,

       0x0,0x0,0x0,0x70,0x38c7003f,0xff000000,0xff8f,0xf8000100,0xffffe,0x7c0f80,0x0,0x0,0x3ffc000,0xf0000020,0x1001f0,0x3c00003c,

       0x1f80,0x0,0x1c3ffc7,0x7c0780,0x0,0x0,0xe3,0xff038000,0xe0,0x38000078,0x78,0x1ff0,0x0,0x3c003c0,0xfffe1c00,0x0,0x0,0x380000f0,

       0x7800000,0x1c00,0xe000,0xe00,0xf000,0x78f000,0x3c78000,0x1e3c0000,0xf1e00007,0x8f00003c,0x78000787,0x8001e000,0x78000,0x3c0000,

       0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x780f3c0,0x3c03c001,0xe01e000f,0xf00078,0x78003c0,0x3c001e00,

       0x4000200f,0x3f80f0,0x3c0780,0x1e03c00,0xf01e000,0x7801f03e,0x1ffffe,0xf01fe0,0x3fff800,0x1fffc000,0xfffe0007,0xfff0003f,

       0xff8001ff,0xfc003ff3,0xfe0003ff,0xe0007ff8,0x3ffc0,0x1ffe00,0xfff000,0x3ff80001,0xffc0000f,0xfe00007f,0xf000003f,0xf8003c7f,

       0xe0003ffc,0x1ffe0,0xfff00,0x7ff800,0x3ffc000,0x1f80000,0xfff1c03c,0x3c01e0,0x1e00f00,0xf007800,0x781f0001,0xf01e7ff0,0x7c0007c,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,

       0x3c1e003f,0xfffff078,0x30003803,0x80000f00,0x1e0,0x1f00,0x7800,0x7f000,0x1e0000,0x0,0x0,0x0,0x3c000f00,0x780001e,0x0,0x7800000f,

       0x78780,0x3c00000,0x3c000000,0x7c00f,0x780f0,0x3c0007,0xe000003f,0x0,0xfe000000,0xfe0000,0x3c0,0x1f000070,0x7c7c003,0xc000f01e,

       0x1e0,0x7803c0,0x1e00,0x1e000,0x1e0007,0x80007800,0x780,0x3c1f0000,0x7800001e,0x783cf079,0xe01e03c0,0xf00780,0x1e0f000,0x3c078001,

       0xe03c0000,0xf000,0xf0003c0,0x3c003c07,0x81f03c00,0x7c7c000f,0x87c00000,0xf00003c,0x1e00,0x1e0,0x3e001f,0x0,0x0,0x3fffe001,

       0xefff8000,0x7fff001f,0xff78007f,0xfe001fff,0xfe003ffe,0xf0079ffe,0x1ffc00,0x7ff000,0x7801f00,0x1e0000f,0xffbfe01e,0x7ff8003f,

       0xff0007bf,0xfe000fff,0xbc003cff,0xf803fffc,0x1fffff0,0x3c003c0,0x78001e1e,0xf0f,0x800f80f0,0x1e00ff,0xffe0001e,0xf0,0x780,

       0x0,0x0,0x3c00000,0x380000,0x0,0x7800000,0x0,0x18,0xc0,0x0,0x1008000,0x7800000,0x3,0xe00f0000,0x3800000,0xf00000,0xe0000007,

       0xf,0x80001f00,0x3e0f8,0x1e07c0,0x0,0x0,0x0,0x70,0x3807007f,0xff800000,0x1ffdf,0xfc000380,0xffffe,0x3e1f00,0x0,0x0,0xfffe000,

       0xf0000030,0x3800f8,0x7c00003c,0xfc0,0x0,0x18780c3,0xf00780,0x80100,0x0,0xc3,0xffc18000,0xf0,0x78000078,0xf0,0xf0,0x0,0x3c003c0,

       0xfffe1c00,0x0,0x0,0x380000f0,0x7800801,0x1c00,0xe000,0x1e00,0xf000,0xf8f800,0x7c7c000,0x3e3e0001,0xf1f0000f,0x8f80007c,0x7c000787,

       0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x780f3c0,0x3c078001,0xe03c000f,

       0x1e00078,0xf0003c0,0x78001e00,0xe000701f,0x3fc0f0,0x3c0780,0x1e03c00,0xf01e000,0x7800f87c,0x1e007f,0xf07e00,0x7fffc00,0x3fffe001,

       0xffff000f,0xfff8007f,0xffc003ff,0xfe007ff7,0xff0007ff,0xf000fffc,0x7ffe0,0x3fff00,0x1fff800,0x3ff80001,0xffc0000f,0xfe00007f,

       0xf00000ff,0xf8003cff,0xf0007ffe,0x3fff0,0x1fff80,0xfffc00,0x7ffe000,0x1f80001,0xfffb803c,0x3c01e0,0x1e00f00,0xf007800,0x780f0001,

       0xe01efff8,0x3c00078,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x780000,0x3c1e003f,0xfffff078,0x30001c07,0xf80,0x1e0,0x1e00,0x3c00,0xff800,0x1e0000,0x0,0x0,0x0,0x3c001e00,

       0x3c0001e,0x0,0x7800001e,0x70780,0x3c00000,0x78000000,0x78007,0x800f00f0,0x3e0007,0xe000003f,0x3,0xfe000000,0xff8000,0x7c0,

       0x1e000070,0x783c003,0xc001f01e,0x1e0,0x7803c0,0x1e00,0x1e000,0x1e0007,0x80007800,0x780,0x3c3e0000,0x7800001e,0x3838f079,

       0xe01e03c0,0x780780,0x1e0f000,0x1e078001,0xe03c0000,0xf000,0xf0003c0,0x3c007c07,0x81f03c00,0x3ef80007,0x87800000,0x1f00003c,

       0x1e00,0x1e0,0x7c000f,0x80000000,0x0,0x3ffff001,0xffffc000,0xffff003f,0xff7800ff,0xff001fff,0xfe007ffe,0xf007bffe,0x1ffc00,

       0x7ff000,0x7803e00,0x1e0000f,0xffffe01e,0xfff8007f,0xff8007ff,0xff001fff,0xbc003dff,0xf807fffc,0x1fffff0,0x3c003c0,0x78001e0f,

       0x1e07,0xc01f00f0,0x1e00ff,0xffe0001e,0xf0,0x780,0x0,0x0,0x7c00000,0x7c0000,0x0,0x7800000,0x0,0x18,0xc0,0x0,0x1018000,0x7800000,

       0x3,0xc00f0000,0x7c00000,0x1f00001,0xf000000f,0x80000007,0xc0003e00,0x1e07c,0x3e0780,0x0,0x0,0x0,0x70,0x380700ff,0xff800000,

       0x3ffff,0xfe0007c0,0xffffe,0x1e1e00,0x0,0x780000,0x1fffe000,0xf0000078,0x7c0078,0x7800003c,0xff0,0x0,0x38e0003,0x80f00780,

       0x180300,0x0,0x1c3,0x81e1c000,0x7f,0xf0000078,0x1e0,0x38,0x0,0x3c003c0,0xfffe1c00,0x0,0x0,0x380000f0,0x7800c01,0x80001c00,

       0xe000,0x603e00,0xf000,0xf07800,0x783c000,0x3c1e0001,0xe0f0000f,0x7800078,0x3c000f87,0x8001e000,0x78000,0x3c0000,0x1e00000,

       0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x780f3c0,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f01,0xf000f81e,

       0x7bc0f0,0x3c0780,0x1e03c00,0xf01e000,0x78007878,0x1e001f,0xf0f800,0x7fffe00,0x3ffff001,0xffff800f,0xfffc007f,0xffe003ff,

       0xff007fff,0xff800fff,0xf001fffe,0xffff0,0x7fff80,0x3fffc00,0x3ff80001,0xffc0000f,0xfe00007f,0xf00001ff,0xfc003dff,0xf000ffff,

       0x7fff8,0x3fffc0,0x1fffe00,0xffff000,0x1f80003,0xffff803c,0x3c01e0,0x1e00f00,0xf007800,0x780f0001,0xe01ffffc,0x3c00078,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,

       0x3c1e003f,0xfffff078,0x30001e0f,0x300780,0x1e0,0x1e00,0x3c00,0x3dde00,0x1e0000,0x0,0x0,0x0,0x78001e00,0x3c0001e,0x0,0xf800003e,

       0xf0780,0x3dfc000,0x783f8000,0xf8007,0xc01f00f0,0x3e0007,0xe000003f,0x1f,0xfc000000,0x7ff000,0xf80,0x3e007c70,0x783c003,0xc001e03c,

       0x1e0,0x3c03c0,0x1e00,0x3c000,0x1e0007,0x80007800,0x780,0x3c7c0000,0x7800001e,0x3878f078,0xf01e03c0,0x780780,0x1e0f000,0x1e078001,

       0xe03e0000,0xf000,0xf0003c0,0x1e007807,0x83f03c00,0x3ef00007,0xcf800000,0x3e00003c,0xf00,0x1e0,0xf80007,0xc0000000,0x0,0x3e01f801,

       0xfe07e001,0xf80f007e,0x7f801f8,0x1f801fff,0xfe00fc0f,0xf007f83f,0x1ffc00,0x7ff000,0x7807c00,0x1e0000f,0x87e1e01f,0xe0fc00fc,

       0xfc007f8,0x1f803f03,0xfc003df0,0x3807e03c,0x1fffff0,0x3c003c0,0x78003e0f,0x1e03,0xe03e00f8,0x3e00ff,0xffe0001e,0xf0,0x780,

       0x0,0x0,0x7800000,0xfe0000,0x0,0x7800000,0x0,0x18,0xc0,0x0,0x1818000,0x7c00000,0x3,0xc00f0000,0xfe00000,0x3e00003,0xf800001f,

       0xc0000007,0xc0003e00,0x1e03c,0x3c0f80,0x0,0x0,0x0,0x70,0x380700fc,0x7800000,0x7c1fe,0x3e000fe0,0xffffe,0x1f3e00,0x0,0x780000,

       0x3f98e000,0xf000003c,0xfcf8007c,0xf800003c,0x3ffc,0x0,0x31c0001,0x80f00f80,0x380700,0x0,0x183,0x80e0c000,0x3f,0xe0000078,

       0x3c0,0x38,0x0,0x3c003c0,0xfffe1c00,0x0,0x0,0x38000078,0xf000e01,0xc003ffe0,0x1fff00,0x7ffc00,0xf000,0xf07800,0x783c000,0x3c1e0001,

       0xe0f0000f,0x7800078,0x3c000f07,0x8003c000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,

       0x3c0f1e0,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0xf801f01e,0xf3c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78007cf8,

       0x1e000f,0x80f0f000,0x7c03f00,0x3e01f801,0xf00fc00f,0x807e007c,0x3f003e0,0x1f80707f,0x8f801f80,0xf003f03f,0x1f81f8,0xfc0fc0,

       0x7e07e00,0x3ff80001,0xffc0000f,0xfe00007f,0xf00003ff,0xfc003fc1,0xf801f81f,0x800fc0fc,0x7e07e0,0x3f03f00,0x1f81f800,0x1f80007,

       0xe07f003c,0x3c01e0,0x1e00f00,0xf007800,0x780f8003,0xe01fe07e,0x3e000f8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3f,0xfffff078,0x30000ffe,0x1f007c0,0x0,0x1e00,

       0x3c00,0xf9cf80,0x1e0000,0x0,0x0,0x0,0x78001e00,0x3c0001e,0x0,0xf00000fc,0x1e0780,0x3fff800,0x78ffe000,0xf0003,0xe03e00f0,

       0x3e0007,0xe000003f,0x7f,0xe01fffff,0xf00ffc00,0x1f80,0x3c01ff70,0x783c003,0xc007e03c,0x1e0,0x3c03c0,0x1e00,0x3c000,0x1e0007,

       0x80007800,0x780,0x3cfc0000,0x7800001e,0x3c78f078,0xf01e03c0,0x780780,0x3e0f000,0x1e078003,0xc01f0000,0xf000,0xf0003c0,0x1e007807,

       0x83f83c00,0x1ff00003,0xcf000000,0x3e00003c,0xf00,0x1e0,0x0,0x0,0x0,0x20007801,0xfc03e003,0xe003007c,0x3f803e0,0x7c0003c,

       0xf807,0xf007e00f,0x3c00,0xf000,0x780f800,0x1e0000f,0x87e1f01f,0x803c00f8,0x7c007f0,0xf803e01,0xfc003f80,0x80f8004,0x3c000,

       0x3c003c0,0x3c003c0f,0x1e03,0xe03e0078,0x3c0000,0x7c0001e,0xf0,0x780,0x0,0x0,0x3ffff800,0x1ff0000,0x0,0x7800000,0x0,0x18,

       0xc0,0x0,0x1818000,0x3e00000,0x3,0xc00f0000,0x1ff00000,0x3e00007,0xfc00003f,0xe0000003,0xc0003c00,0xf03c,0x3c0f00,0x0,0x0,

       0x0,0x70,0x380701f0,0x800000,0x780fc,0x1e001ff0,0x7c,0xf3c00,0x0,0x780000,0x7e182000,0xf000001f,0xfff00ffc,0xffc0003c,0x3cfe,

       0x0,0x31c0001,0x80f01f80,0x780f00,0x0,0x183,0x80e0c000,0xf,0x80000078,0x780,0x38,0x0,0x3c003c0,0x7ffe1c00,0x0,0x0,0x38000078,

       0xf000f01,0xe003ffe0,0x1fff00,0x7ff800,0xf000,0xf07800,0x783c000,0x3c1e0001,0xe0f0000f,0x78000f8,0x3e000f07,0x8003c000,0x78000,

       0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x3c0f1e0,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,

       0x78000f00,0x7c03e01e,0x1e3c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78003cf0,0x1e0007,0x80f1e000,0x4000f00,0x20007801,0x3c008,

       0x1e0040,0xf00200,0x780403f,0x7803e00,0x3007c00f,0x803e007c,0x1f003e0,0xf801f00,0x780000,0x3c00000,0x1e000000,0xf00007f0,

       0x3e003f00,0x7801f00f,0x800f807c,0x7c03e0,0x3e01f00,0x1f00f800,0x1f80007,0xc03e003c,0x3c01e0,0x1e00f00,0xf007800,0x78078003,

       0xc01fc03e,0x1e000f0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x780000,0x0,0xf078007c,0x300007fc,0x7e00fe0,0x0,0x1e00,0x3c00,0x3e1c3e0,0x1e0000,0x0,0x0,0x0,0xf0001e00,

       0x3c0001e,0x1,0xf000fff8,0x1e0780,0x3fffe00,0x79fff000,0x1f0001,0xfffc00f0,0x7e0007,0xe000003f,0x3ff,0x801fffff,0xf003ff80,

       0x3f00,0x3c03fff0,0xf01e003,0xffffc03c,0x1e0,0x3c03ff,0xffc01fff,0xfe03c000,0x1fffff,0x80007800,0x780,0x3df80000,0x7800001e,

       0x1c70f078,0x781e03c0,0x780780,0x3c0f000,0x1e078007,0xc01f8000,0xf000,0xf0003c0,0x1e007807,0x83f83c00,0xfe00003,0xff000000,

       0x7c00003c,0x780,0x1e0,0x0,0x0,0x0,0x7c01,0xf801f007,0xc00100f8,0x1f803c0,0x3c0003c,0x1f003,0xf007c00f,0x80003c00,0xf000,

       0x783f000,0x1e0000f,0x3c0f01f,0x3e01f0,0x3e007e0,0x7c07c00,0xfc003f00,0xf0000,0x3c000,0x3c003c0,0x3c003c0f,0x1e01,0xf07c007c,

       0x7c0000,0xfc0001e,0xf0,0x780,0x0,0x0,0x3ffff000,0x3838000,0x0,0x7800000,0x0,0x18,0xc0,0x0,0xff0000,0x3f00000,0x3,0xc00fff00,

       0x38380000,0x7c0000e,0xe000070,0x70000001,0xe0003c00,0xf01e,0x780e00,0x0,0x0,0x0,0x0,0x1e0,0x0,0x780f8,0xf003838,0xfc,0xffc00,

       0x0,0x780000,0x7c180000,0xf000000f,0xffe00fff,0xffc0003c,0x783f,0x80000000,0x6380000,0xc0f83f80,0xf81f00,0x0,0x303,0x80e06000,

       0x0,0x78,0xf00,0x78,0x0,0x3c003c0,0x7ffe1c00,0x0,0x0,0x3800003c,0x3e000f81,0xf003ffe0,0x1fff00,0x1fc000,0xf000,0x1e03c00,

       0xf01e000,0x780f0003,0xc078001e,0x3c000f0,0x1e000f07,0xff83c000,0x7ffff,0x803ffffc,0x1ffffe0,0xfffff00,0xf00000,0x7800000,

       0x3c000001,0xe0001e00,0x3c0f0f0,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x3e07c01e,0x1e3c0f0,0x3c0780,0x1e03c00,

       0xf01e000,0x78003ff0,0x1e0007,0x80f1e000,0xf80,0x7c00,0x3e000,0x1f0000,0xf80000,0x7c0001e,0x3c07c00,0x10078007,0x803c003c,

       0x1e001e0,0xf000f00,0x780000,0x3c00000,0x1e000000,0xf00007c0,0x1e003e00,0x7c03e007,0xc01f003e,0xf801f0,0x7c00f80,0x3e007c00,

       0xf,0x801f003c,0x3c01e0,0x1e00f00,0xf007800,0x7807c007,0xc01f801f,0x1f001f0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x0,0xe078003c,0x300001f0,0x3f801ff0,0x0,

       0x3c00,0x1e00,0x3c1c1e0,0x1e0000,0x0,0x0,0x0,0xf0001e0f,0x3c0001e,0x3,0xe000fff0,0x3c0780,0x3ffff00,0x7bfff800,0x1e0000,0x7ff00078,

       0x7e0007,0xe000003f,0x1ffc,0x1fffff,0xf0007ff0,0x7e00,0x3c07c3f0,0xf01e003,0xffff003c,0x1e0,0x3c03ff,0xffc01fff,0xfe03c000,

       0x1fffff,0x80007800,0x780,0x3ffc0000,0x7800001e,0x1ef0f078,0x781e03c0,0x780780,0x7c0f000,0x1e07801f,0x800ff000,0xf000,0xf0003c0,

       0xf00f807,0x83b83c00,0xfc00001,0xfe000000,0xf800003c,0x780,0x1e0,0x0,0x0,0x0,0x3c01,0xf000f007,0xc00000f0,0xf80780,0x3c0003c,

       0x1e001,0xf007c007,0x80003c00,0xf000,0x787e000,0x1e0000f,0x3c0f01f,0x1e01e0,0x1e007c0,0x3c07800,0x7c003f00,0xf0000,0x3c000,

       0x3c003c0,0x3e007c07,0x80003c00,0xf8f8003c,0x780000,0xf80001e,0xf0,0x780,0x0,0x0,0x7ffff000,0x601c000,0x3,0xffff0000,0x0,

       0xfff,0xf8007fff,0xc0000000,0x7e003c,0x1fe0000,0xc0003,0xc00fff00,0x601c0000,0xf800018,0x70000c0,0x38000001,0xe0007800,0x701e,

       0x701e00,0x0,0x0,0x0,0x0,0x1e0,0x6,0x700f8,0xf00601c,0xf8,0x7f800,0x0,0x780000,0xf8180000,0xf000000f,0x87c00fff,0xffc0003c,

       0xf01f,0xc0000000,0x6380000,0xc07ff780,0x1f03e03,0xfffffe00,0x303,0x81c06000,0x0,0x1ffff,0xfe001e00,0x180f8,0x0,0x3c003c0,

       0x3ffe1c00,0x3f00000,0x0,0x3800003f,0xfe0007c0,0xf8000000,0x18000000,0xc0000006,0x1f000,0x1e03c00,0xf01e000,0x780f0003,0xc078001e,

       0x3c000f0,0x1e001f07,0xff83c000,0x7ffff,0x803ffffc,0x1ffffe0,0xfffff00,0xf00000,0x7800000,0x3c000001,0xe000fff8,0x3c0f0f0,

       0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x1f0f801e,0x3c3c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78001fe0,0x1e0007,

       0x80f1e000,0x780,0x3c00,0x1e000,0xf0000,0x780000,0x3c0001e,0x3c07c00,0xf0007,0x8078003c,0x3c001e0,0x1e000f00,0x780000,0x3c00000,

       0x1e000000,0xf0000f80,0x1f003e00,0x3c03c003,0xc01e001e,0xf000f0,0x7800780,0x3c003c00,0xf,0x3f003c,0x3c01e0,0x1e00f00,0xf007800,

       0x7803c007,0x801f000f,0xf001e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1,0xe078003f,0xb0000000,0xfc003cf0,0x0,0x3c00,0x1e00,0x101c040,0x1e0000,0x0,0x0,0x1,

       0xe0001e1f,0x83c0001e,0x7,0xe000fff0,0x3c0780,0x3c03f80,0x7fc0fc00,0x1e0000,0xfff80078,0xfe0007,0xe000003f,0x7fe0,0x1fffff,

       0xf0000ffc,0xfc00,0x780f81f0,0xf01e003,0xffff003c,0x1e0,0x3c03ff,0xffc01fff,0xfe03c000,0x1fffff,0x80007800,0x780,0x3ffc0000,

       0x7800001e,0x1ef0f078,0x3c1e03c0,0x780780,0x1fc0f000,0x1e07ffff,0x7ff00,0xf000,0xf0003c0,0xf00f007,0xc3b87c00,0x7c00001,0xfe000000,

       0xf800003c,0x3c0,0x1e0,0x0,0x0,0x0,0x3c01,0xf000f007,0x800000f0,0xf80780,0x1e0003c,0x1e001,0xf0078007,0x80003c00,0xf000,0x78fc000,

       0x1e0000f,0x3c0f01e,0x1e01e0,0x1e007c0,0x3c07800,0x7c003e00,0xf0000,0x3c000,0x3c003c0,0x1e007807,0x80003c00,0x7df0003c,0x780000,

       0x1f00001e,0xf0,0x780,0x0,0x0,0x7800000,0xe7ce000,0x3,0xffff0000,0x0,0xfff,0xf8007fff,0xc0000000,0x1f0,0xffe000,0x1c0003,

       0xc00fff00,0xe7ce0000,0xf800039,0xf38001cf,0x9c000000,0xe0007800,0x780e,0x701c00,0x0,0x0,0x0,0x0,0x1e0,0x7,0xf0078,0xf00e7ce,

       0x1f0,0x7f800,0x0,0x780000,0xf0180000,0xf000000e,0x1c0001f,0xe000003c,0xf007,0xe0000000,0x6380000,0xc03fe780,0x3e07c03,0xfffffe00,

       0x303,0xffc06000,0x0,0x1ffff,0xfe003ffe,0x1fff0,0x0,0x3c003c0,0x1ffe1c00,0x3f00000,0x7,0xffc0001f,0xfc0003e0,0x7c000001,0xfc00000f,

       0xe000007f,0x1e000,0x1e03c00,0xf01e000,0x780f0003,0xc078001e,0x3c000f0,0x1e001e07,0xff83c000,0x7ffff,0x803ffffc,0x1ffffe0,

       0xfffff00,0xf00000,0x7800000,0x3c000001,0xe000fff8,0x3c0f078,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0xf9f001e,

       0x783c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78001fe0,0x1e0007,0x80f1e000,0x780,0x3c00,0x1e000,0xf0000,0x780000,0x3c0001e,0x3c07800,

       0xf0003,0xc078001e,0x3c000f0,0x1e000780,0x780000,0x3c00000,0x1e000000,0xf0000f00,0xf003c00,0x3c03c003,0xc01e001e,0xf000f0,

       0x7800780,0x3c003c00,0xf,0x7f003c,0x3c01e0,0x1e00f00,0xf007800,0x7803c007,0x801f000f,0xf001e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1,0xe070001f,0xf8000007,

       0xf0007cf8,0x7800000,0x3c00,0x1e00,0x1c000,0x1e0000,0x0,0x0,0x1,0xe0001e1f,0x83c0001e,0xf,0xc000fff8,0x780780,0x2000f80,0x7f803e00,

       0x3e0003,0xfffe007c,0x1fe0000,0x0,0x3ff00,0x0,0x1ff,0x8001f000,0x780f00f0,0x1f00f003,0xffffc03c,0x1e0,0x3c03ff,0xffc01fff,

       0xfe03c00f,0xf81fffff,0x80007800,0x780,0x3ffe0000,0x7800001e,0xee0f078,0x3c1e03c0,0x7807ff,0xff80f000,0x1e07fffe,0x3ffe0,

       0xf000,0xf0003c0,0xf00f003,0xc7bc7800,0xfc00000,0xfc000001,0xf000003c,0x3c0,0x1e0,0x0,0x0,0x0,0x3c01,0xe000f80f,0x800001e0,

       0xf80f00,0x1e0003c,0x3c000,0xf0078007,0x80003c00,0xf000,0x79f8000,0x1e0000f,0x3c0f01e,0x1e03c0,0x1f00780,0x3e0f000,0x7c003e00,

       0xf0000,0x3c000,0x3c003c0,0x1e007807,0x81e03c00,0x7df0003e,0xf80000,0x3e00003e,0xf0,0x7c0,0xfc000,0x80000000,0x7800000,0x1e7cf000,

       0x3,0xffff0000,0x0,0x18,0xc0,0x0,0xf80,0x7ffc00,0x380003,0xc00fff01,0xe7cf0000,0x1f000079,0xf3c003cf,0x9e000000,0xe0007000,

       0x380e,0xe01c00,0x0,0x0,0x0,0x0,0x1e0,0x3,0x800f0078,0xf01e7cf,0x3e0,0x3f000,0x0,0x780000,0xf018001f,0xfff8001e,0x1e0000f,

       0xc000003c,0xf003,0xe0000000,0x6380000,0xc00fc780,0x7c0f803,0xfffffe00,0x303,0xfe006000,0x0,0x1ffff,0xfe003ffe,0x1ffe0,0x0,

       0x3c003c0,0xffe1c00,0x3f00000,0x7,0xffc00007,0xf00001f0,0x3e00001f,0xfc0000ff,0xe00007ff,0x3e000,0x3e01e00,0x1f00f000,0xf8078007,

       0xc03c003e,0x1e001e0,0xf001e07,0xff83c000,0x7ffff,0x803ffffc,0x1ffffe0,0xfffff00,0xf00000,0x7800000,0x3c000001,0xe000fff8,

       0x3c0f078,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x7fe001e,0xf03c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78000fc0,

       0x1e0007,0x80f1f000,0x780,0x3c00,0x1e000,0xf0000,0x780000,0x3c0001e,0x3c0f800,0x1e0003,0xc0f0001e,0x78000f0,0x3c000780,0x780000,

       0x3c00000,0x1e000000,0xf0000f00,0xf003c00,0x3c078003,0xe03c001f,0x1e000f8,0xf0007c0,0x78003e00,0x1e,0xf7803c,0x3c01e0,0x1e00f00,

       0xf007800,0x7803e00f,0x801e000f,0x80f803e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1,0xe0f0000f,0xff00001f,0x8000f87c,0x7800000,0x3c00,0x1e00,0x1c000,0x7fffff80,

       0x0,0x0,0x3,0xc0001e1f,0x83c0001e,0x1f,0x800000fe,0xf00780,0x7c0,0x7f001e00,0x3c0007,0xe03f003f,0x3fe0000,0x0,0x3fc00,0x0,

       0x7f,0x8001e000,0x781f00f0,0x1e00f003,0xc007e03c,0x1e0,0x3c03c0,0x1e00,0x3c00f,0xf81e0007,0x80007800,0x780,0x3f9f0000,0x7800001e,

       0xfe0f078,0x3c1e03c0,0x7807ff,0xff00f000,0x1e07fff8,0xfff8,0xf000,0xf0003c0,0xf81f003,0xc7bc7800,0xfe00000,0x78000003,0xe000003c,

       0x1e0,0x1e0,0x0,0x0,0x0,0x1fffc01,0xe000780f,0x1e0,0x780f00,0x1e0003c,0x3c000,0xf0078007,0x80003c00,0xf000,0x7bf0000,0x1e0000f,

       0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0xf8000,0x3c000,0x3c003c0,0x1f00f807,0x81f03c00,0x3fe0001e,0xf00000,0x7c00007c,

       0xf0,0x3e0,0x3ff801,0x80000000,0x7800000,0x3cfcf800,0x3,0xffff0000,0x0,0x18,0xc0,0x0,0x7c00,0x1fff00,0x700003,0xc00f0003,

       0xcfcf8000,0x3e0000f3,0xf3e0079f,0x9f000000,0xf000,0x1000,0x0,0x0,0x0,0x0,0x0,0x1f0,0x1,0xc00f0078,0xf03cfcf,0x800007c0,0x1e000,

       0x0,0x780001,0xe018001f,0xfff8001c,0xe00007,0x8000003c,0xf001,0xf0000000,0x6380000,0xc0000000,0xf81f003,0xfffffe00,0x303,

       0x87006000,0x0,0x1ffff,0xfe003ffe,0x7f00,0x0,0x3c003c0,0x3fe1c00,0x3f00000,0x7,0xffc00000,0xf8,0x1f0001ff,0xf0000fff,0x80007ffc,

       0xfc000,0x3c01e00,0x1e00f000,0xf0078007,0x803c003c,0x1e001e0,0xf001e07,0x8003c000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,

       0x7800000,0x3c000001,0xe000fff8,0x3c0f078,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x3fc001e,0x1e03c0f0,0x3c0780,

       0x1e03c00,0xf01e000,0x78000780,0x1e0007,0x80f0fc00,0x3fff80,0x1fffc00,0xfffe000,0x7fff0003,0xfff8001f,0xffc0001e,0x3c0f000,

       0x1e0003,0xc0f0001e,0x78000f0,0x3c000780,0x780000,0x3c00000,0x1e000000,0xf0001e00,0xf803c00,0x3c078001,0xe03c000f,0x1e00078,

       0xf0003c0,0x78001e07,0xfffffe1e,0x1e7803c,0x3c01e0,0x1e00f00,0xf007800,0x7801e00f,0x1e0007,0x807803c0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x3,0xc0f00007,

       0xffc0007e,0xf03e,0x7800000,0x3c00,0x1e00,0x1c000,0x7fffff80,0x0,0x0,0x3,0xc0001e1f,0x83c0001e,0x3f,0x3e,0xf00780,0x3c0,0x7e001e00,

       0x7c000f,0x800f001f,0xffde0000,0x0,0x3e000,0x0,0xf,0x8003e000,0x781e0070,0x1e00f003,0xc001f03c,0x1e0,0x3c03c0,0x1e00,0x3c00f,

       0xf81e0007,0x80007800,0x780,0x3f1f0000,0x7800001e,0x7c0f078,0x1e1e03c0,0x7807ff,0xfc00f000,0x1e07fffe,0xffc,0xf000,0xf0003c0,

       0x781e003,0xc71c7800,0x1ff00000,0x78000003,0xe000003c,0x1e0,0x1e0,0x0,0x0,0x0,0xffffc01,0xe000780f,0x1e0,0x780fff,0xffe0003c,

       0x3c000,0xf0078007,0x80003c00,0xf000,0x7ff0000,0x1e0000f,0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0x7f000,0x3c000,

       0x3c003c0,0xf00f007,0xc1f07c00,0x1fc0001f,0x1f00000,0xfc000ff8,0xf0,0x1ff,0xfffe07,0x80000000,0x7800000,0x7ffcfc00,0x0,0xf000000,

       0x0,0x18,0xc0,0x0,0x3e000,0x1ff80,0xe00003,0xc00f0007,0xffcfc000,0x3e0001ff,0xf3f00fff,0x9f800000,0x6000,0x0,0x0,0x7c000,

       0x0,0x0,0x0,0xfe,0x0,0xe00f007f,0xff07ffcf,0xc0000fc0,0x1e000,0x0,0x780001,0xe018001f,0xfff8001c,0xe00007,0x80000000,0xf800,

       0xf0000000,0x6380000,0xc0000000,0x1f03c000,0x1e00,0x303,0x83806000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xfe1c00,0x3f00000,0x0,

       0x0,0x3c,0xf801fff,0xfff8,0x7ffc0,0x1f8000,0x3c01e00,0x1e00f000,0xf0078007,0x803c003c,0x1e001e0,0xf003c07,0x8003c000,0x78000,

       0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x3c0f03c,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,

       0x78000f00,0x1f8001e,0x1e03c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1e000f,0x80f0ff00,0x1ffff80,0xffffc00,0x7fffe003,

       0xffff001f,0xfff800ff,0xffc007ff,0xffc0f000,0x1fffff,0xc0fffffe,0x7fffff0,0x3fffff80,0x780000,0x3c00000,0x1e000000,0xf0001e00,

       0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e07,0xfffffe1e,0x3c7803c,0x3c01e0,0x1e00f00,0xf007800,0x7801f01f,

       0x1e0007,0x807c07c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x780000,0x3,0xc0f00000,0xfff003f0,0x1f00f03e,0x7800000,0x3c00,0x1e00,0x1c000,0x7fffff80,0x0,0x7ff80000,0x3,

       0xc0001e0f,0x3c0001e,0x7e,0x1f,0x1e00780,0x3e0,0x7e000f00,0x78000f,0x7800f,0xff9e0000,0x0,0x3fc00,0x0,0x7f,0x8003c000,0x781e0070,

       0x3e00f803,0xc000f03c,0x1e0,0x3c03c0,0x1e00,0x3c00f,0xf81e0007,0x80007800,0x780,0x3e0f8000,0x7800001e,0x7c0f078,0x1e1e03c0,

       0x7807ff,0xf000f000,0x1e07807f,0xfe,0xf000,0xf0003c0,0x781e003,0xc71c7800,0x3ef00000,0x78000007,0xc000003c,0x1e0,0x1e0,0x0,

       0x0,0x0,0x1ffffc01,0xe000780f,0x1e0,0x780fff,0xffe0003c,0x3c000,0xf0078007,0x80003c00,0xf000,0x7ff0000,0x1e0000f,0x3c0f01e,

       0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0x7ff80,0x3c000,0x3c003c0,0xf00f003,0xc1f07800,0x1fc0000f,0x1e00000,0xf8000ff0,0xf0,

       0xff,0xffffff,0x80000000,0x3fffc000,0xfff9fe00,0x0,0xf000000,0x0,0x18,0xc0,0x0,0x1f0000,0x1fc0,0x1c00003,0xc00f000f,0xff9fe000,

       0x7c0003ff,0xe7f81fff,0x3fc00000,0x0,0x0,0x0,0xfe000,0x1ffffc0f,0xfffffc00,0x0,0xff,0xf0000000,0x700f007f,0xff0fff9f,0xe0000f80,

       0x1e000,0x0,0x780001,0xe018001f,0xfff8001c,0xe00fff,0xffc00000,0xf800,0xf0000000,0x6380000,0xc0ffff80,0x3e078000,0x1e00,0x7ff80303,

       0x83c06000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x3f00000,0x0,0x7f,0xff00001e,0x7c1fff0,0xfff80,0x7ffc00,0x3f0000,0x7c01f00,

       0x3e00f801,0xf007c00f,0x803e007c,0x1f003e0,0xf803c07,0x8003c000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,

       0xe0001e00,0x3c0f03c,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x1f8001e,0x3c03c0f0,0x3c0780,0x1e03c00,0xf01e000,

       0x78000780,0x1e001f,0xf07f80,0x3ffff80,0x1ffffc00,0xffffe007,0xffff003f,0xfff801ff,0xffc03fff,0xffc0f000,0x1fffff,0xc0fffffe,

       0x7fffff0,0x3fffff80,0x780000,0x3c00000,0x1e000000,0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e07,

       0xfffffe1e,0x787803c,0x3c01e0,0x1e00f00,0xf007800,0x7800f01e,0x1e0007,0x803c0780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1ff,0xffff8000,0x3ff80fc0,0x7fc1e01f,

       0x7800000,0x3c00,0x1e00,0x0,0x7fffff80,0x0,0x7ff80000,0x7,0x80001e00,0x3c0001e,0xfc,0xf,0x1e00780,0x1e0,0x7c000f00,0x78000f,

       0x78007,0xff1e0000,0x0,0x3ff00,0x0,0x1ff,0x8003c000,0x781e0070,0x3c007803,0xc000f03c,0x1e0,0x3c03c0,0x1e00,0x3c000,0x781e0007,

       0x80007800,0x780,0x3c07c000,0x7800001e,0x7c0f078,0xf1e03c0,0x780780,0xf000,0x1e07801f,0x3e,0xf000,0xf0003c0,0x781e003,0xcf1c7800,

       0x3cf80000,0x7800000f,0x8000003c,0xf0,0x1e0,0x0,0x0,0x0,0x3ffffc01,0xe000780f,0x1e0,0x780fff,0xffe0003c,0x3c000,0xf0078007,

       0x80003c00,0xf000,0x7ff8000,0x1e0000f,0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0x3fff0,0x3c000,0x3c003c0,0xf81f003,

       0xc3b87800,0xf80000f,0x1e00001,0xf0000ff0,0xf0,0xff,0xf03fff,0x80000000,0x3fff8001,0xfff1ff00,0x0,0xf000000,0x0,0x18,0xc0,

       0x0,0x380000,0x7c0,0x3c00003,0xc00f001f,0xff1ff000,0xf80007ff,0xc7fc3ffe,0x3fe00000,0x0,0x0,0x0,0x1ff000,0x7ffffe1f,0xffffff00,

       0x0,0x7f,0xfe000000,0x780f007f,0xff1fff1f,0xf0001f00,0x1e000,0x0,0x780001,0xe0180000,0xf000001c,0xe00fff,0xffc00000,0x7c00,

       0xf0000000,0x31c0001,0x80ffff80,0x3e078000,0x1e00,0x7ff80183,0x81c0c000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x3f00000,

       0x0,0x7f,0xff00001e,0x7c7ff03,0xc03ff8fe,0x1ffc0f0,0x7e0000,0x7800f00,0x3c007801,0xe003c00f,0x1e0078,0xf003c0,0x7803c07,0x8003c000,

       0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x3c0f01e,0x3c078000,0xf03c0007,0x81e0003c,

       0xf0001e0,0x78000f00,0x3fc001e,0x7803c0f0,0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1e007f,0xf03fe0,0x7ffff80,0x3ffffc01,

       0xffffe00f,0xffff007f,0xfff803ff,0xffc07fff,0xffc0f000,0x1fffff,0xc0fffffe,0x7fffff0,0x3fffff80,0x780000,0x3c00000,0x1e000000,

       0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e07,0xfffffe1e,0x707803c,0x3c01e0,0x1e00f00,0xf007800,

       0x7800f01e,0x1e0007,0x803c0780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1ff,0xffff8000,0x30f81f00,0xffe1e00f,0x87800000,0x3c00,0x1e00,0x0,0x1e0000,0x0,0x7ff80000,

       0x7,0x80001e00,0x3c0001e,0x1f8,0x7,0x83c00780,0x1e0,0x7c000f00,0xf8001e,0x3c001,0xfc1e0000,0x0,0x7fe0,0x0,0xffc,0x3c000,0x781e0070,

       0x3ffff803,0xc000783c,0x1e0,0x3c03c0,0x1e00,0x3c000,0x781e0007,0x80007800,0x780,0x3c07c000,0x7800001e,0x380f078,0xf1e03c0,

       0x780780,0xf000,0x1e07800f,0x8000001e,0xf000,0xf0003c0,0x3c3c003,0xcf1e7800,0x7c780000,0x7800000f,0x8000003c,0xf0,0x1e0,0x0,

       0x0,0x0,0x7f003c01,0xe000780f,0x1e0,0x780fff,0xffe0003c,0x3c000,0xf0078007,0x80003c00,0xf000,0x7f7c000,0x1e0000f,0x3c0f01e,

       0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0xfff8,0x3c000,0x3c003c0,0x781e003,0xc3b87800,0x1fc00007,0x83e00003,0xe0000ff8,0xf0,

       0x1ff,0xc007fe,0x0,0x7fff8001,0xffe3ff00,0x0,0x1e000000,0x0,0x18,0xc0,0x0,0x0,0x3c0,0x7800003,0xc00f001f,0xfe3ff000,0xf80007ff,

       0x8ffc3ffc,0x7fe00000,0x0,0x0,0x0,0x1ff000,0x0,0x0,0x0,0x1f,0xff000000,0x3c0f007f,0xff1ffe3f,0xf0003e00,0x1e000,0x0,0x780001,

       0xe0180000,0xf000001e,0x1e00fff,0xffc00000,0x3f00,0xf0000000,0x31c0001,0x80ffff80,0x1f03c000,0x1e00,0x7ff80183,0x81c0c000,

       0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x0,0x0,0x7f,0xff00003c,0xf87f007,0xc03f83ff,0x81fc01f0,0x7c0000,0x7ffff00,0x3ffff801,

       0xffffc00f,0xfffe007f,0xfff003ff,0xff807fff,0x8003c000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,

       0xe0001e00,0x3c0f01e,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0x7fe001e,0xf003c0f0,0x3c0780,0x1e03c00,0xf01e000,

       0x78000780,0x1ffffe,0xf00ff0,0xfe00780,0x7f003c03,0xf801e01f,0xc00f00fe,0x7807f0,0x3c0ffff,0xffc0f000,0x1fffff,0xc0fffffe,

       0x7fffff0,0x3fffff80,0x780000,0x3c00000,0x1e000000,0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e00,

       0x1e,0xf07803c,0x3c01e0,0x1e00f00,0xf007800,0x7800783e,0x1e0007,0x801e0f80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1ff,0xffff8000,0x307c0801,0xe1f1e00f,0x87000000,

       0x3c00,0x1e00,0x0,0x1e0000,0x0,0x7ff80000,0xf,0x1e00,0x3c0001e,0x3f0,0x7,0x83fffffc,0x1e0,0x7c000f00,0xf0001e,0x3c000,0x3e0000,

       0x0,0x1ffc,0x1fffff,0xf0007ff0,0x3c000,0x781e0070,0x7ffffc03,0xc000781e,0x1e0,0x7803c0,0x1e00,0x3c000,0x781e0007,0x80007800,

       0x780,0x3c03e000,0x7800001e,0xf078,0x79e03c0,0x780780,0xf000,0x1e078007,0x8000000f,0xf000,0xf0003c0,0x3c3c001,0xee0ef000,

       0xf87c0000,0x7800001f,0x3c,0x78,0x1e0,0x0,0x0,0x0,0x7c003c01,0xe000780f,0x1e0,0x780f00,0x3c,0x3c000,0xf0078007,0x80003c00,

       0xf000,0x7e3e000,0x1e0000f,0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0x1ffc,0x3c000,0x3c003c0,0x781e003,0xe3b8f800,

       0x1fc00007,0x83c00007,0xc00000fc,0xf0,0x3e0,0x8001f8,0x0,0x7800000,0xffc7fe00,0x0,0x1e000000,0x0,0x18,0xc0,0x0,0x0,0x1e0,

       0xf000003,0xc00f000f,0xfc7fe001,0xf00003ff,0x1ff81ff8,0xffc00000,0x0,0x0,0x0,0x1ff000,0x0,0x0,0x0,0x3,0xff800000,0x1e0f0078,

       0xffc7f,0xe0007c00,0x1e000,0x0,0x780001,0xe0180000,0xf000000e,0x1c00007,0x80000000,0x1f81,0xe0000000,0x38e0003,0x80000000,

       0xf81f000,0x1e00,0x7ff801c3,0x80e1c000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x0,0x0,0x0,0xf8,0x1f070007,0xc03803ff,0xc1c001f0,

       0xf80000,0xfffff00,0x7ffff803,0xffffc01f,0xfffe00ff,0xfff007ff,0xffc07fff,0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,

       0xf00000,0x7800000,0x3c000001,0xe0001e00,0x780f00f,0x3c078000,0xf03c0007,0x81e0003c,0xf0001e0,0x78000f00,0xf9f001e,0xf003c0f0,

       0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1ffffc,0xf003f8,0xf800780,0x7c003c03,0xe001e01f,0xf00f8,0x7807c0,0x3c0fc1e,0xf000,

       0x1e0000,0xf00000,0x7800000,0x3c000000,0x780000,0x3c00000,0x1e000000,0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,

       0xf0003c0,0x78001e00,0x1e,0x1e07803c,0x3c01e0,0x1e00f00,0xf007800,0x7800783c,0x1e0007,0x801e0f00,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ff,0xffff8000,0x303c0001,

       0xc071e007,0xcf000000,0x3c00,0x1e00,0x0,0x1e0000,0x0,0x0,0xf,0xf00,0x780001e,0x7e0,0x7,0x83fffffc,0x1e0,0x7c000f00,0x1f0001e,

       0x3c000,0x3c0000,0x0,0x3ff,0x801fffff,0xf003ff80,0x3c000,0x781e0070,0x7ffffc03,0xc000781e,0x1e0,0x7803c0,0x1e00,0x1e000,0x781e0007,

       0x80007800,0x780,0x3c01f000,0x7800001e,0xf078,0x79e03c0,0xf00780,0xf000,0x3e078007,0xc000000f,0xf000,0xf0003c0,0x3c3c001,

       0xee0ef000,0xf03e0000,0x7800003e,0x3c,0x78,0x1e0,0x0,0x0,0x0,0xf8003c01,0xe000780f,0x1e0,0x780f00,0x3c,0x3c000,0xf0078007,

       0x80003c00,0xf000,0x7c3e000,0x1e0000f,0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0xfc,0x3c000,0x3c003c0,0x3c3e001,0xe7b8f000,

       0x3fe00007,0xc7c0000f,0xc000003e,0xf0,0x7c0,0x0,0x0,0x7c00000,0x7fcffc00,0x0,0x1e000000,0x0,0x18,0xc0,0x0,0x0,0x1e0,0x1e000003,

       0xc00f0007,0xfcffc003,0xe00001ff,0x3ff00ff9,0xff800000,0x0,0x0,0x0,0x1ff000,0x0,0x0,0x0,0x0,0x1f800000,0xf0f0078,0x7fcff,

       0xc000fc00,0x1e000,0x0,0x780001,0xe0180000,0xf000000f,0x87c00007,0x80000000,0xfe3,0xe0000000,0x18780c3,0x0,0x7c0f800,0x1e00,

       0xc3,0x80e18000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x0,0x0,0x0,0x1f0,0x3e00000f,0xc0000303,0xe00003f0,0xf00000,0xfffff80,

       0x7ffffc03,0xffffe01f,0xffff00ff,0xfff807ff,0xffc07fff,0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,

       0x3c000001,0xe0001e00,0x780f00f,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e00,0x1f0f801f,0xe00780f0,0x3c0780,0x1e03c00,

       0xf01e000,0x78000780,0x1ffff8,0xf000f8,0x1f000780,0xf8003c07,0xc001e03e,0xf01f0,0x780f80,0x3c1f01e,0xf000,0x1e0000,0xf00000,

       0x7800000,0x3c000000,0x780000,0x3c00000,0x1e000000,0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e00,

       0x1e,0x3c07803c,0x3c01e0,0x1e00f00,0xf007800,0x78007c7c,0x1e0007,0x801f1f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x81c00000,0x303c0003,0x8039e003,0xef000000,

       0x3c00,0x1e00,0x0,0x1e0000,0x0,0x0,0x1e,0xf00,0x780001e,0xfc0,0x7,0x83fffffc,0x1e0,0x3c000f00,0x1e0001e,0x3c000,0x3c0000,

       0x0,0x7f,0xe01fffff,0xf00ffc00,0x3c000,0x781f00f0,0x7ffffc03,0xc000781e,0x1e0,0x7803c0,0x1e00,0x1e000,0x781e0007,0x80007800,

       0x780,0x3c01f000,0x7800001e,0xf078,0x7de01e0,0xf00780,0x7800,0x3c078003,0xc000000f,0xf000,0xf0003c0,0x3e7c001,0xee0ef001,

       0xf01e0000,0x7800003e,0x3c,0x3c,0x1e0,0x0,0x0,0x0,0xf0003c01,0xe000780f,0x1e0,0x780f00,0x3c,0x3c000,0xf0078007,0x80003c00,

       0xf000,0x781f000,0x1e0000f,0x3c0f01e,0x1e03c0,0xf00780,0x1e0f000,0x3c003c00,0x3e,0x3c000,0x3c003c0,0x3c3c001,0xe71cf000,0x7df00003,

       0xc780000f,0x8000003e,0xf0,0x780,0x0,0x0,0x3c00000,0x3fcff800,0x0,0x1e000000,0x0,0x18,0xc0,0x0,0x1f00fc,0x1e0,0x1e000001,

       0xe00f0003,0xfcff8003,0xe00000ff,0x3fe007f9,0xff000000,0x0,0x0,0x0,0x1ff000,0x0,0x0,0x0,0x0,0x7c00000,0xf0f0078,0x3fcff,0x8000f800,

       0x1e000,0x0,0x780001,0xe0180000,0xf000001f,0xffe00007,0x8000003c,0x7ff,0xc0000000,0x1c3ffc7,0x0,0x3e07c00,0x1e00,0xe3,0x80738000,

       0x0,0x78,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x0,0x0,0x0,0x3e0,0x7c00001d,0xc0000001,0xe0000770,0x1f00000,0xfffff80,0x7ffffc03,

       0xffffe01f,0xffff00ff,0xfff807ff,0xffc07fff,0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,

       0xe0001e00,0x780f00f,0x3c03c001,0xe01e000f,0xf00078,0x78003c0,0x3c001e00,0x3e07c01f,0xc00780f0,0x3c0780,0x1e03c00,0xf01e000,

       0x78000780,0x1fffc0,0xf0007c,0x1e000780,0xf0003c07,0x8001e03c,0xf01e0,0x780f00,0x3c1e01e,0xf000,0x1e0000,0xf00000,0x7800000,

       0x3c000000,0x780000,0x3c00000,0x1e000000,0xf0001e00,0x7803c00,0x3c078001,0xe03c000f,0x1e00078,0xf0003c0,0x78001e00,0x1e,0x7807803c,

       0x3c01e0,0x1e00f00,0xf007800,0x78003c78,0x1e0007,0x800f1e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x83c00000,0x303c0003,0x8039e001,0xee000000,0x1e00,0x3c00,

       0x0,0x1e0000,0x0,0x0,0x1e,0xf00,0x780001e,0x1f80,0x7,0x83fffffc,0x1e0,0x3c000f00,0x1e0001e,0x3c000,0x3c0000,0x0,0x1f,0xfc1fffff,

       0xf07ff000,0x0,0x780f00f0,0x78003c03,0xc000781e,0x1e0,0xf803c0,0x1e00,0x1e000,0x781e0007,0x80007800,0x780,0x3c00f800,0x7800001e,

       0xf078,0x3de01e0,0xf00780,0x7800,0x3c078003,0xe000000f,0xf000,0xf0003c0,0x1e78001,0xfe0ff003,0xe01f0000,0x7800007c,0x3c,0x3c,

       0x1e0,0x0,0x0,0x0,0xf0007c01,0xe000f80f,0x800001e0,0xf80f00,0x3c,0x1e001,0xf0078007,0x80003c00,0xf000,0x780f800,0x1e0000f,

       0x3c0f01e,0x1e03c0,0x1f00780,0x3e0f000,0x7c003c00,0x1e,0x3c000,0x3c003c0,0x3c3c001,0xe71cf000,0xf8f80003,0xe780001f,0x1e,

       0xf0,0x780,0x0,0x0,0x3c00000,0x1ffff000,0x0,0x1e000000,0x0,0x18,0xc0,0x0,0x3bc1de,0x1e0,0xf000001,0xe00f0001,0xffff0007,0xc000007f,

       0xffc003ff,0xfe000000,0x0,0x0,0x0,0xfe000,0x0,0x0,0x0,0x0,0x3c00000,0x1e0f0078,0x1ffff,0x1f000,0x1e000,0x0,0x780000,0xf0180000,

       0xf000001f,0xfff00007,0x8000003c,0x1ff,0x80000000,0xe0ff0e,0x0,0x1f03e00,0x1e00,0x70,0x70000,0x0,0x78,0x0,0x0,0x0,0x3c003c0,

       0xe1c00,0x0,0x0,0x0,0x7c0,0xf8000019,0xc0000000,0xe0000670,0x1e00000,0xf000780,0x78003c03,0xc001e01e,0xf00f0,0x780780,0x3c0f807,

       0x8001e000,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0xf80f007,0xbc03c001,0xe01e000f,

       0xf00078,0x78003c0,0x3c001e00,0x7c03e00f,0x800780f0,0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1e0000,0xf0003c,0x1e000f80,

       0xf0007c07,0x8003e03c,0x1f01e0,0xf80f00,0x7c1e01e,0xf800,0x1e0000,0xf00000,0x7800000,0x3c000000,0x780000,0x3c00000,0x1e000000,

       0xf0001e00,0x7803c00,0x3c078003,0xe03c001f,0x1e000f8,0xf0007c0,0x78003e00,0x1f8001f,0xf00f803c,0x3c01e0,0x1e00f00,0xf007800,

       0x78003e78,0x1e000f,0x800f9e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x3c00000,0x303c0003,0x8039f001,0xfe000000,0x1e00,0x3c00,0x0,0x1e0000,0x0,0x0,0x3c,0xf00,

       0x780001e,0x3f00,0x7,0x80000780,0x3e0,0x3e000f00,0x3c0001e,0x3c000,0x7c0000,0x0,0x3,0xfe000000,0xff8000,0x0,0x3c0f81f0,0xf0001e03,

       0xc000780f,0x1e0,0xf003c0,0x1e00,0xf000,0x781e0007,0x80007800,0x780,0x3c007c00,0x7800001e,0xf078,0x3de01e0,0xf00780,0x7800,

       0x3c078001,0xe000000f,0xf000,0xf0003c0,0x1e78001,0xfc07f003,0xe00f0000,0x78000078,0x3c,0x1e,0x1e0,0x0,0x0,0x0,0xf0007c01,

       0xf000f007,0x800000f0,0xf80780,0x3c,0x1e001,0xf0078007,0x80003c00,0xf000,0x7807c00,0x1e0000f,0x3c0f01e,0x1e01e0,0x1e007c0,

       0x3c07800,0x7c003c00,0x1e,0x3c000,0x3c007c0,0x1e78001,0xe71df000,0xf8f80001,0xef80003e,0x1e,0xf0,0x780,0x0,0x0,0x3c00000,

       0xfffe000,0x0,0x3e000000,0x0,0x18,0x7fff,0xc0000000,0x60c306,0x1e0,0x7800001,0xe00f0000,0xfffe0007,0x8000003f,0xff8001ff,

       0xfc000000,0x0,0x0,0x0,0x7c000,0x0,0x0,0x0,0x0,0x3c00000,0x3c0f0078,0xfffe,0x3e000,0x1e000,0x0,0x780000,0xf0180000,0xf000003c,

       0xfcf80007,0x8000003c,0x7f,0x0,0x70001c,0x0,0xf81f00,0x0,0x38,0xe0000,0x0,0x0,0x0,0x0,0x0,0x3c003c0,0xe1c00,0x0,0x0,0x0,0xf81,

       0xf0000039,0xc0000000,0xe0000e70,0x1e00000,0x1e0003c0,0xf0001e07,0x8000f03c,0x781e0,0x3c0f00,0x1e0f007,0x8000f000,0x78000,

       0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0xf00f007,0xbc03c001,0xe01e000f,0xf00078,0x78003c0,

       0x3c001e00,0xf801f00f,0x800780f0,0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1e0000,0xf0003c,0x1e000f80,0xf0007c07,0x8003e03c,

       0x1f01e0,0xf80f00,0x7c1e01e,0x7800,0xf0000,0x780000,0x3c00000,0x1e000000,0x780000,0x3c00000,0x1e000000,0xf0000f00,0xf003c00,

       0x3c03c003,0xc01e001e,0xf000f0,0x7800780,0x3c003c00,0x1f8000f,0xe00f003c,0x7c01e0,0x3e00f00,0x1f007800,0xf8001ef8,0x1f000f,

       0x7be00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0xf,0x3c00000,0x307c0003,0x8038f000,0xfc000000,0x1e00,0x3c00,0x0,0x1e0000,0xfc0000,0x0,0x7e00003c,0x780,0xf00001e,

       0x7e00,0xf,0x80000780,0x3c0,0x3e001e00,0x3c0001f,0x7c000,0x780007,0xe000003f,0x0,0xfe000000,0xfe0000,0x0,0x3c07c3f0,0xf0001e03,

       0xc000f80f,0x800001e0,0x1f003c0,0x1e00,0xf000,0x781e0007,0x80007800,0x4000f80,0x3c003c00,0x7800001e,0xf078,0x1fe01f0,0x1f00780,

       0x7c00,0x7c078001,0xf000001f,0xf000,0xf0003c0,0x1e78001,0xfc07f007,0xc00f8000,0x780000f8,0x3c,0x1e,0x1e0,0x0,0x0,0x0,0xf0007c01,

       0xf000f007,0xc00000f0,0xf80780,0x3c,0x1f003,0xf0078007,0x80003c00,0xf000,0x7807c00,0x1e0000f,0x3c0f01e,0x1e01e0,0x1e007c0,

       0x3c07800,0x7c003c00,0x1e,0x3c000,0x3c007c0,0x1e78000,0xfe0fe001,0xf07c0001,0xef00007c,0x1e,0xf0,0x780,0x0,0x0,0x1e00000,

       0x7cfc000,0xfc00000,0x3c00000f,0xc3f00000,0x18,0x7fff,0xc0000000,0x406303,0x3e0,0x3c00001,0xf00f0000,0x7cfc000f,0x8000001f,

       0x3f0000f9,0xf8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x780700f8,0x7cfc,0x7c000,0x1e000,0x0,0x780000,0xf8180000,

       0xf0000070,0x3c0007,0x8000003c,0x3f,0x80000000,0x3c0078,0x0,0x780f00,0x0,0x1e,0x3c0000,0x0,0x0,0x0,0x0,0x0,0x3e007c0,0xe1c00,

       0x0,0x0,0x0,0xf01,0xe0000071,0xc0000000,0xe0001c70,0x1e00000,0x1e0003c0,0xf0001e07,0x8000f03c,0x781e0,0x3c0f00,0x1e0f007,

       0x8000f800,0x78000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x1f00f003,0xfc03e003,0xe01f001f,

       0xf800f8,0x7c007c0,0x3e003e01,0xf000f80f,0xf00f0,0x3c0780,0x1e03c00,0xf01e000,0x78000780,0x1e0000,0xf0003c,0x1e000f80,0xf0007c07,

       0x8003e03c,0x1f01e0,0xf80f00,0x7c1e01e,0x7c00,0xf0000,0x780000,0x3c00000,0x1e000000,0x780000,0x3c00000,0x1e000000,0xf0000f00,

       0xf003c00,0x3c03c003,0xc01e001e,0xf000f0,0x7800780,0x3c003c00,0x1f8000f,0xc00f003c,0x7c01e0,0x3e00f00,0x1f007800,0xf8001ef0,

       0x1f000f,0x7bc00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x780000,0xf,0x3800040,0x30780003,0x8038f800,0x78000000,0x1e00,0x3c00,0x0,0x1e0000,0xfc0000,0x0,0x7e000078,

       0x780,0x1f00001e,0xfc00,0x20001f,0x780,0x80007c0,0x1f001e00,0x7c0000f,0x78000,0xf80007,0xe000003f,0x0,0x1e000000,0xf00000,

       0x3c000,0x3c03fff0,0xf0001e03,0xc001f007,0x800101e0,0x7e003c0,0x1e00,0x7800,0x781e0007,0x80007800,0x6000f00,0x3c003e00,0x7800001e,

       0xf078,0x1fe00f0,0x1e00780,0x3c00,0x78078000,0xf020001e,0xf000,0x7800780,0xff0001,0xfc07f00f,0x8007c000,0x780001f0,0x3c,0xf,

       0x1e0,0x0,0x0,0x0,0xf800fc01,0xf801f007,0xc00100f8,0x1f807c0,0x40003c,0xf807,0xf0078007,0x80003c00,0xf000,0x7803e00,0x1f0000f,

       0x3c0f01e,0x1e01f0,0x3e007e0,0x7c07c00,0xfc003c00,0x1e,0x3e000,0x3e007c0,0x1ff8000,0xfe0fe003,0xe03e0001,0xff0000fc,0x1e,

       0xf0,0x780,0x0,0x0,0x1f00080,0x3cf8000,0xfc00000,0x3c00001f,0x83f00000,0x18,0xc0,0x0,0xc06203,0x40003c0,0x1c00000,0xf80f0000,

       0x3cf8001f,0xf,0x3e000079,0xf0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x700780fc,0x3cf8,0xfc000,0x1e000,0x0,0x780000,

       0x7c180000,0xf0000020,0x100007,0x8000003c,0xf,0x80000000,0x1f01f0,0x0,0x380700,0x0,0xf,0x80f80000,0x0,0x0,0x0,0x0,0x0,0x3e007c0,

       0xe1c00,0x0,0x0,0x0,0xe01,0xc0000071,0xc0000001,0xc0001c70,0x1e00040,0x1e0003c0,0xf0001e07,0x8000f03c,0x781e0,0x3c0f00,0x1e0f007,

       0x80007800,0x10078000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e00,0x7e00f003,0xfc01e003,0xc00f001e,

       0x7800f0,0x3c00780,0x1e003c00,0xe000700f,0x800f0078,0x7803c0,0x3c01e00,0x1e00f000,0xf0000780,0x1e0000,0xf0003c,0x1f001f80,

       0xf800fc07,0xc007e03e,0x3f01f0,0x1f80f80,0xfc1e01f,0x7c00,0x100f8000,0x807c0004,0x3e00020,0x1f000100,0x780000,0x3c00000,0x1e000000,

       0xf0000f80,0x1f003c00,0x3c03e007,0xc01f003e,0xf801f0,0x7c00f80,0x3e007c00,0x1f8000f,0x801f003e,0x7c01f0,0x3e00f80,0x1f007c00,

       0xf8001ff0,0x1f801f,0x7fc00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0xf,0x7800078,0x31f80001,0xc070fc00,0xfc000000,0x1e00,0x7c00,0x0,0x1e0000,0xfc0000,0x0,0x7e000078,

       0x7c0,0x1f00001e,0x1f000,0x38003f,0x780,0xe000f80,0x1f803e00,0x780000f,0x800f8000,0x1f00007,0xe000003f,0x0,0x2000000,0x800000,

       0x3c000,0x3e01ff71,0xf0001f03,0xc007f007,0xc00301e0,0x1fc003c0,0x1e00,0x7c00,0x781e0007,0x80007800,0x7801f00,0x3c001f00,0x7800001e,

       0xf078,0xfe00f8,0x3e00780,0x3e00,0xf8078000,0xf838003e,0xf000,0x7c00f80,0xff0000,0xfc07e00f,0x8003c000,0x780001e0,0x3c,0xf,

       0x1e0,0x0,0x0,0x0,0xf801fc01,0xfc03e003,0xe003007c,0x3f803e0,0x1c0003c,0xfc0f,0xf0078007,0x80003c00,0xf000,0x7801f00,0xf8000f,

       0x3c0f01e,0x1e00f8,0x7c007f0,0xf803e01,0xfc003c00,0x8003e,0x1f000,0x1e00fc0,0xff0000,0xfe0fe007,0xc01f0000,0xfe0000f8,0x1e,

       0xf0,0x780,0x0,0x0,0xf80180,0x1cf0000,0x1f800000,0x3c00001f,0x83e00000,0x18,0xc0,0x0,0xc06203,0x70007c0,0xe00000,0x7e0f0000,

       0x1cf0001e,0x7,0x3c000039,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x7c00000,0xe00780fc,0x2001cf0,0xf8000,0x1e000,0x0,

       0x780000,0x7e182000,0xf0000000,0x7,0x8000003c,0x7,0xc0000000,0x7ffc0,0x0,0x180300,0x0,0x3,0xffe00000,0x0,0x0,0x0,0x0,0x0,

       0x3f00fc0,0xe1c00,0x0,0x0,0x0,0xc01,0x800000e1,0xc0000003,0xc0003870,0x1f001c0,0x3e0003e1,0xf0001f0f,0x8000f87c,0x7c3e0,0x3e1f00,

       0x1f1e007,0x80007c00,0x30078000,0x3c0000,0x1e00000,0xf000000,0xf00000,0x7800000,0x3c000001,0xe0001e03,0xfc00f001,0xfc01f007,

       0xc00f803e,0x7c01f0,0x3e00f80,0x1f007c00,0x4000201f,0xc01f007c,0xf803e0,0x7c01f00,0x3e00f801,0xf0000780,0x1e0000,0xf0007c,

       0x1f003f80,0xf801fc07,0xc00fe03e,0x7f01f0,0x3f80f80,0x1fc1f03f,0x803e00,0x3007c003,0x803e001c,0x1f000e0,0xf800700,0x780000,

       0x3c00000,0x1e000000,0xf00007c0,0x3e003c00,0x3c01f00f,0x800f807c,0x7c03e0,0x3e01f00,0x1f00f800,0x1f80007,0xc03e001e,0xfc00f0,

       0x7e00780,0x3f003c01,0xf8000fe0,0x1fc03e,0x3f800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1e,0x780007f,0xfff00001,0xe0f07f03,0xfe000000,0xf00,0x7800,0x0,

       0x1e0000,0xfc0000,0x0,0x7e0000f0,0x3f0,0x7e000fff,0xfc03ffff,0xf83f00fe,0x780,0xfc03f80,0xfc0fc00,0xf800007,0xe03f0018,0x7e00007,

       0xe000003f,0x0,0x0,0x0,0x3c000,0x1e007c71,0xe0000f03,0xffffe003,0xf01f01ff,0xff8003ff,0xffe01e00,0x3f01,0xf81e0007,0x803ffff0,

       0x7e03f00,0x3c000f00,0x7ffffe1e,0xf078,0xfe007e,0xfc00780,0x1f83,0xf0078000,0x783f00fe,0xf000,0x3f03f00,0xff0000,0xfc07e01f,

       0x3e000,0x780003ff,0xfffc003c,0x7,0x800001e0,0x0,0x0,0x0,0x7e07fc01,0xfe07e001,0xf80f007e,0x7f801f8,0xfc0003c,0x7ffe,0xf0078007,

       0x807ffffe,0xf000,0x7801f00,0xfff00f,0x3c0f01e,0x1e00fc,0xfc007f8,0x1f803f03,0xfc003c00,0xf80fc,0x1fff0,0x1f83fc0,0xff0000,

       0xfc07e007,0xc01f0000,0xfe0001ff,0xffe0001e,0xf0,0x780,0x0,0x0,0xfe0780,0xfe0000,0x1f000000,0x3c00001f,0x7c00e03,0x81c00018,

       0xc0,0x0,0x406203,0x7e01fc0,0x700000,0x7fffff80,0xfe0003f,0xffffc003,0xf800001f,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f0,

       0x1f800001,0xc007c1fe,0x6000fe0,0x1ffffe,0x1e000,0x0,0x780000,0x3f98e03f,0xffff8000,0x7,0x8000003c,0x7,0xc0000000,0xfe00,

       0x0,0x80100,0x0,0x0,0x7f000000,0x0,0x1ffff,0xfe000000,0x0,0x0,0x3f83fe8,0xe1c00,0x0,0x0,0x0,0x801,0xc1,0xc0000007,0x80003070,

       0xfc0fc0,0x3c0001e1,0xe0000f0f,0x7878,0x3c3c0,0x1e1e00,0xf1e007,0xffc03f01,0xf007ffff,0xc03ffffe,0x1fffff0,0xfffff80,0x7fffe003,

       0xffff001f,0xfff800ff,0xffc01fff,0xf800f001,0xfc00fc1f,0x8007e0fc,0x3f07e0,0x1f83f00,0xfc1f800,0x1f,0xf07e003f,0x3f001f8,

       0x1f800fc0,0xfc007e07,0xe0000780,0x1e0000,0xf301f8,0xfc0ff80,0x7e07fc03,0xf03fe01f,0x81ff00fc,0xff807e0,0x7fc0f87f,0x81801f80,

       0xf003f01f,0x801f80fc,0xfc07e0,0x7e03f00,0xfffffc07,0xffffe03f,0xffff01ff,0xfff807e0,0x7e003c00,0x3c01f81f,0x800fc0fc,0x7e07e0,

       0x3f03f00,0x1f81f800,0x1f8000f,0xe07e001f,0x83fc00fc,0x1fe007e0,0xff003f07,0xf8000fe0,0x1fe07e,0x3f800,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1e,0x780007f,

       0xffe00000,0xffe03fff,0xdf000000,0xf00,0x7800,0x0,0x0,0xfc0000,0x0,0x7e0000f0,0x1ff,0xfc000fff,0xfc03ffff,0xf83ffffc,0x780,

       0xfffff00,0x7fff800,0xf000007,0xffff001f,0xffe00007,0xe000003f,0x0,0x0,0x0,0x3c000,0x1e000001,0xe0000f03,0xffffc001,0xffff01ff,

       0xff0003ff,0xffe01e00,0x1fff,0xf81e0007,0x803ffff0,0x7fffe00,0x3c000f80,0x7ffffe1e,0xf078,0xfe003f,0xff800780,0xfff,0xf0078000,

       0x7c3ffffc,0xf000,0x3ffff00,0xff0000,0xf803e01e,0x1e000,0x780003ff,0xfffc003c,0x7,0x800001e0,0x0,0x0,0x0,0x7fffbc01,0xffffc000,

       0xffff003f,0xfff800ff,0xffc0003c,0x3ffe,0xf0078007,0x807ffffe,0xf000,0x7800f80,0x7ff00f,0x3c0f01e,0x1e007f,0xff8007ff,0xff001fff,

       0xbc003c00,0xffffc,0x1fff0,0x1fffbc0,0xff0000,0x7c07c00f,0x800f8000,0x7e0001ff,0xffe0001e,0xf0,0x780,0x0,0x0,0x7fff80,0x7c0000,

       0x1f000000,0x3c00001e,0x7c00f07,0xc1e00018,0xc0,0x0,0x60e303,0x7ffff80,0x380000,0x3fffff80,0x7c0003f,0xffffc001,0xf000000f,

       0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ff,0xff800003,0x8003ffff,0xfe0007c0,0x1ffffe,0x1e000,0x0,0x780000,0x1fffe03f,0xffff8000,

       0x7,0x8000003c,0x3,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ffff,0xfe000000,0x0,0x0,0x3fffdf8,0xe1c00,0x0,0x0,0x0,0x0,0x1c1,

       0xc000000f,0x7070,0x7fffc0,0x3c0001e1,0xe0000f0f,0x7878,0x3c3c0,0x1e1e00,0xf1e007,0xffc01fff,0xf007ffff,0xc03ffffe,0x1fffff0,

       0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01fff,0xf000f001,0xfc007fff,0x3fff8,0x1fffc0,0xfffe00,0x7fff000,0x3b,0xfffc003f,

       0xfff001ff,0xff800fff,0xfc007fff,0xe0000780,0x1e0000,0xf3fff8,0xffff780,0x7fffbc03,0xfffde01f,0xffef00ff,0xff7807ff,0xfbc0ffff,

       0xff800fff,0xf001ffff,0x800ffffc,0x7fffe0,0x3ffff00,0xfffffc07,0xffffe03f,0xffff01ff,0xfff803ff,0xfc003c00,0x3c00ffff,0x7fff8,

       0x3fffc0,0x1fffe00,0xffff000,0x1f,0xfffc001f,0xffbc00ff,0xfde007ff,0xef003fff,0x780007e0,0x1ffffc,0x1f800,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1e,0x700003f,

       0xffc00000,0x7fc01fff,0x9f800000,0xf80,0xf800,0x0,0x0,0xfc0000,0x0,0x7e0000f0,0xff,0xf8000fff,0xfc03ffff,0xf83ffff8,0x780,

       0xffffe00,0x7fff000,0xf000003,0xfffe001f,0xffc00007,0xe000003f,0x0,0x0,0x0,0x3c000,0xf000003,0xe0000f83,0xffff0000,0xffff01ff,

       0xfc0003ff,0xffe01e00,0xfff,0xf01e0007,0x803ffff0,0x7fffc00,0x3c0007c0,0x7ffffe1e,0xf078,0x7e003f,0xff000780,0x7ff,0xe0078000,

       0x3c3ffff8,0xf000,0x1fffe00,0x7e0000,0xf803e03e,0x1f000,0x780003ff,0xfffc003c,0x7,0x800001e0,0x0,0x0,0x0,0x3fff3c01,0xefff8000,

       0x7ffe001f,0xff78007f,0xff80003c,0x1ffc,0xf0078007,0x807ffffe,0xf000,0x78007c0,0x3ff00f,0x3c0f01e,0x1e003f,0xff0007bf,0xfe000fff,

       0xbc003c00,0xffff8,0xfff0,0xfff3c0,0x7e0000,0x7c07c01f,0x7c000,0x7c0001ff,0xffe0001e,0xf0,0x780,0x0,0x0,0x3fff80,0x380000,

       0x3e000000,0x7c00003e,0x7801f07,0xc1e00018,0xc0,0x0,0x39c1ce,0x7ffff00,0x1c0000,0xfffff80,0x380003f,0xffffc000,0xe0000007,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ff,0xff000007,0x1ffcf,0xfe000380,0x1ffffe,0x1e000,0x0,0x780000,0xfffe03f,0xffff8000,0x7,

       0x8000003c,0x3,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ffff,0xfe000000,0x0,0x0,0x3dffdf8,0xe1c00,0x0,0x0,0x0,0x0,0x381,

       0xc000001e,0xe070,0x7fff80,0x7c0001f3,0xe0000f9f,0x7cf8,0x3e7c0,0x1f3e00,0xfbe007,0xffc00fff,0xf007ffff,0xc03ffffe,0x1fffff0,

       0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01fff,0xc000f000,0xfc007ffe,0x3fff0,0x1fff80,0xfffc00,0x7ffe000,0x79,0xfff8001f,

       0xffe000ff,0xff0007ff,0xf8003fff,0xc0000780,0x1e0000,0xf3fff0,0x7ffe780,0x3fff3c01,0xfff9e00f,0xffcf007f,0xfe7803ff,0xf3c07ff3,

       0xff8007ff,0xe000ffff,0x7fff8,0x3fffc0,0x1fffe00,0xfffffc07,0xffffe03f,0xffff01ff,0xfff801ff,0xf8003c00,0x3c007ffe,0x3fff0,

       0x1fff80,0xfffc00,0x7ffe000,0x1d,0xfff8000f,0xff3c007f,0xf9e003ff,0xcf001ffe,0x780007c0,0x1efff8,0x1f000,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780000,0x1e,0xf000003,

       0xfe000000,0x1f000fff,0xfc00000,0x780,0xf000,0x0,0x0,0xf80000,0x0,0x7e0001e0,0x7f,0xf0000fff,0xfc03ffff,0xf81ffff0,0x780,

       0x7fff800,0x1ffe000,0x1f000000,0xfff8001f,0xff000007,0xe000003e,0x0,0x0,0x0,0x3c000,0xf800003,0xc0000783,0xfff80000,0x3ffe01ff,

       0xe00003ff,0xffe01e00,0x7ff,0xc01e0007,0x803ffff0,0x3fff800,0x3c0003c0,0x7ffffe1e,0xf078,0x7e000f,0xfe000780,0x3ff,0xc0078000,

       0x3e1fffe0,0xf000,0x7ff800,0x7e0000,0xf803e07c,0xf800,0x780003ff,0xfffc003c,0x3,0xc00001e0,0x0,0x0,0x0,0xffe3c01,0xe7ff0000,

       0x3ffc000f,0xfe78003f,0xfe00003c,0x7f0,0xf0078007,0x807ffffe,0xf000,0x78003e0,0xff00f,0x3c0f01e,0x1e001f,0xfe00079f,0xfc0007ff,

       0x3c003c00,0x7ffe0,0x1ff0,0x7fe3c0,0x7e0000,0x7c07c03e,0x3e000,0x7c0001ff,0xffe0001e,0xf0,0x780,0x0,0x0,0xfff00,0x100000,

       0x3e000000,0x7800003c,0xf800f07,0xc1e00018,0xc0,0x0,0x1f80fc,0x3fffc00,0xc0000,0x3ffff80,0x100003f,0xffffc000,0x40000002,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xfc000006,0xff87,0xfc000100,0x1ffffe,0x1e000,0x0,0x780000,0x3ffc03f,0xffff8000,0x7,

       0x8000003c,0x3,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ffff,0xfe000000,0x0,0x0,0x3dff9f8,0xe1c00,0x0,0x0,0x0,0x0,0x3ff,

       0xf800003c,0xfffe,0x1ffe00,0x780000f3,0xc000079e,0x3cf0,0x1e780,0xf3c00,0x7bc007,0xffc003ff,0xe007ffff,0xc03ffffe,0x1fffff0,

       0xfffff80,0x7fffe003,0xffff001f,0xfff800ff,0xffc01ffc,0xf000,0xfc001ffc,0xffe0,0x7ff00,0x3ff800,0x1ffc000,0x70,0xfff00007,

       0xff80003f,0xfc0001ff,0xe0000fff,0x780,0x1e0000,0xf3ffe0,0x1ffc780,0xffe3c00,0x7ff1e003,0xff8f001f,0xfc7800ff,0xe3c03fe1,

       0xff0003ff,0xc0007ffc,0x3ffe0,0x1fff00,0xfff800,0xfffffc07,0xffffe03f,0xffff01ff,0xfff800ff,0xf0003c00,0x3c003ffc,0x1ffe0,

       0xfff00,0x7ff800,0x3ffc000,0x38,0xfff00007,0xfe3c003f,0xf1e001ff,0x8f000ffc,0x780007c0,0x1e7ff0,0x1f000,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,

       0x1fc,0x0,0x780,0xf000,0x0,0x0,0x1f80000,0x0,0x1e0,0x1f,0xc0000000,0x0,0x1ff80,0x0,0xffc000,0x7f8000,0x0,0x3fe00007,0xfc000000,

       0x7e,0x0,0x0,0x0,0x0,0x7c00000,0x0,0x0,0xff00000,0x0,0x0,0xfe,0x0,0x0,0x3fc000,0x0,0x0,0x0,0x3,0xf8000000,0xff,0xc0000000,

       0x1ff00,0x0,0x1fe000,0x0,0x0,0x0,0x0,0x3c,0x3,0xc00001e0,0x0,0x0,0x0,0x3f80000,0x1fc0000,0x7f00003,0xf8000007,0xf0000000,

       0x0,0xf0000000,0x0,0xf000,0x0,0x0,0x0,0x7,0xf8000787,0xf00001fc,0x3c000000,0x7f80,0x0,0x1f8000,0x0,0x0,0x0,0x7c000000,0x1e,

       0xf0,0x780,0x0,0x0,0x3fc00,0x0,0x3c000000,0x7800003c,0xf000601,0xc00018,0xc0,0x0,0x0,0x3fe000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xf0000000,0x7e03,0xf0000000,0x0,0x0,0x0,0x0,0xfe0000,0x0,0x0,0x3c,0x2007,0x80000000,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c7e0f0,0xe1c00,0x0,0x3800000,0x0,0x0,0x3ff,0xf8000078,0xfffe,0x7f800,0x0,0x0,0x0,0x0,

       0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f0,0x3f80,0x1fc00,0xfe000,0x7f0000,0x70,0x3fc00001,0xfe00000f,0xf000007f,

       0x800003fc,0x0,0x0,0xff00,0x7f0000,0x3f80000,0x1fc00000,0xfe000007,0xf000003f,0x80001f80,0xfc00007f,0xfe0,0x7f00,0x3f800,

       0x1fc000,0x0,0x0,0x0,0x3f,0xc0000000,0xff0,0x7f80,0x3fc00,0x1fe000,0xff0000,0x78,0x3fc00001,0xf800000f,0xc000007e,0x3f0,0x7c0,

       0x1e1fc0,0x1f000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x3c0,0x1e000,0x0,0x0,0x1f00000,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x7c,0x0,0x0,0x0,0x0,0x3e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0xe0000000,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x3c,0x1,0xe00001e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0x0,0xf000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x78000000,0x1e,0xf0,0x780,0x0,0x0,0x0,0x0,0x3c000000,0x78000078,0xf000000,0x18,0xc0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x3c,0x3c0f,0x80000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0xe1c00,0x0,0x1800000,0x0,0x0,0x3ff,0xf80000f0,0xfffe,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x780,0x1e0000,0x1e000,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,

       0x0,0x0,0x3c0,0x1e000,0x0,0x0,0x1f00000,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c,0x0,0x0,0x0,0x0,0x1f80000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0xf0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x1,0xe00001e0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe0000000,0x0,0xf000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x0,0xf8000000,

       0x1f,0xf0,0xf80,0x0,0x0,0x0,0x0,0x78000000,0xf8000078,0x1e000000,0x8,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x3c,0x3fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x3c00000,0xe1c00,0x0,0x1c00000,0x0,0x0,0x1,0xc00001e0,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf80,0x1e0000,0x3e000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x1e0,0x3c000,0x0,0x0,0x1f00000,

       0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c,0x0,0x0,0x0,0x0,0xfe0100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0xf8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0xf0000000,0xf0007fe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe0000000,

       0x0,0xf000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0x1f,0x800000f0,0x1f80,0x0,0x0,0x0,0x0,

       0x78000000,0xf0000070,0x1c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x3c,0x3ffe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0xe1c00,0x0,0xe00000,

       0x0,0x0,0x1,0xc00003ff,0xe0000070,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0xf00,0x1e0000,0x3c000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x1e0,0x7c000,0x0,0x0,0x1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x78,0x0,0x0,0x0,0x0,0x7fff80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78000000,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0xf0000000,0x7fe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4003,0xe0000000,0x0,0x1f000,0x0,0x0,

       0x0,0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x1,0xf0000000,0xf,0xfc0000f0,0x3ff00,0x0,0x0,0x0,0x0,0x70000001,0xf00000e0,

       0x1c000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,

       0x0,0x0,0x3c,0xff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0xe1c00,0x0,0xe00000,0x0,0x0,0x1,0xc00003ff,

       0xe0000070,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f00,0x1e0000,

       0x7c000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0xf0,0x78000,0x0,0x0,0x3e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x0,

       0x0,0x0,0x0,0x1fff80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,

       0xf0000000,0x7fe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780f,0xc0000000,0x0,0x3e000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,

       0x0,0x0,0x0,0x0,0x3,0xe0000000,0xf,0xfc0000f0,0x3ff00,0x0,0x0,0x0,0x0,0xf0000103,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x0,0x0,0x21e00000,0x0,0x0,0x1,0xc00003ff,0xe0000070,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10f,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10f,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e00,0x1e0000,0xf8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,

       0xf8,0xf8000,0x0,0x0,0x3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x1fe00,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f,0xf0000000,0x7fe0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x7fff,0xc0000000,0x0,0x3ffe000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x7f,0xe0000000,0x7,0xfc0000f0,

       0x3fe00,0x0,0x0,0x0,0x0,0x600001ff,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x0,0x0,

       0x3fe00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x7fe00,0x1e0000,0x1ff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x1fffffe0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fff,0x80000000,0x0,0x3ffc000,0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,

       0x0,0x0,0x0,0x0,0x7f,0xc0000000,0x0,0xfc0000f0,0x3f000,0x0,0x0,0x0,0x0,0x1ff,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x3c00000,0x0,0x0,0x3fc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fe,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fe,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fc00,0x1e0000,0x1ff0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fffffe0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ffe,0x0,0x0,0x3ff8000,0x0,0x0,0x0,

       0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x7f,0x80000000,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x1ff,0x80000000,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x0,0x0,0x3f800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f800,0x1e0000,0x1fe0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fffffe0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f8,0x0,0x0,0x3fe0000,

       0x0,0x0,0x0,0x0,0x780,0x0,0x3c000000,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0xfe,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e000,0x1e0000,0x1f80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fffffe0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,

       0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 };


     // Definition of a 40x38 'danger' color logo.

     const unsigned char logo40x38[4576] = {

       177,200,200,200,3,123,123,0,36,200,200,200,1,123,123,0,2,255,255,0,1,189,189,189,1,0,0,0,34,200,200,200,

       1,123,123,0,4,255,255,0,1,189,189,189,1,0,0,0,1,123,123,123,32,200,200,200,1,123,123,0,5,255,255,0,1,0,0,

       0,2,123,123,123,30,200,200,200,1,123,123,0,6,255,255,0,1,189,189,189,1,0,0,0,2,123,123,123,29,200,200,200,

       1,123,123,0,7,255,255,0,1,0,0,0,2,123,123,123,28,200,200,200,1,123,123,0,8,255,255,0,1,189,189,189,1,0,0,0,

       2,123,123,123,27,200,200,200,1,123,123,0,9,255,255,0,1,0,0,0,2,123,123,123,26,200,200,200,1,123,123,0,10,255,

       255,0,1,189,189,189,1,0,0,0,2,123,123,123,25,200,200,200,1,123,123,0,3,255,255,0,1,189,189,189,3,0,0,0,1,189,

       189,189,3,255,255,0,1,0,0,0,2,123,123,123,24,200,200,200,1,123,123,0,4,255,255,0,5,0,0,0,3,255,255,0,1,189,

       189,189,1,0,0,0,2,123,123,123,23,200,200,200,1,123,123,0,4,255,255,0,5,0,0,0,4,255,255,0,1,0,0,0,2,123,123,123,

       22,200,200,200,1,123,123,0,5,255,255,0,5,0,0,0,4,255,255,0,1,189,189,189,1,0,0,0,2,123,123,123,21,200,200,200,

       1,123,123,0,5,255,255,0,5,0,0,0,5,255,255,0,1,0,0,0,2,123,123,123,20,200,200,200,1,123,123,0,6,255,255,0,5,0,0,

       0,5,255,255,0,1,189,189,189,1,0,0,0,2,123,123,123,19,200,200,200,1,123,123,0,6,255,255,0,1,123,123,0,3,0,0,0,1,

       123,123,0,6,255,255,0,1,0,0,0,2,123,123,123,18,200,200,200,1,123,123,0,7,255,255,0,1,189,189,189,3,0,0,0,1,189,

       189,189,6,255,255,0,1,189,189,189,1,0,0,0,2,123,123,123,17,200,200,200,1,123,123,0,8,255,255,0,3,0,0,0,8,255,255,

       0,1,0,0,0,2,123,123,123,16,200,200,200,1,123,123,0,9,255,255,0,1,123,123,0,1,0,0,0,1,123,123,0,8,255,255,0,1,189,

       189,189,1,0,0,0,2,123,123,123,15,200,200,200,1,123,123,0,9,255,255,0,1,189,189,189,1,0,0,0,1,189,189,189,9,255,255,

       0,1,0,0,0,2,123,123,123,14,200,200,200,1,123,123,0,11,255,255,0,1,0,0,0,10,255,255,0,1,189,189,189,1,0,0,0,2,123,

       123,123,13,200,200,200,1,123,123,0,23,255,255,0,1,0,0,0,2,123,123,123,12,200,200,200,1,123,123,0,11,255,255,0,1,189,

       189,189,2,0,0,0,1,189,189,189,9,255,255,0,1,189,189,189,1,0,0,0,2,123,123,123,11,200,200,200,1,123,123,0,11,255,255,

       0,4,0,0,0,10,255,255,0,1,0,0,0,2,123,123,123,10,200,200,200,1,123,123,0,12,255,255,0,4,0,0,0,10,255,255,0,1,189,189,

       189,1,0,0,0,2,123,123,123,9,200,200,200,1,123,123,0,12,255,255,0,1,189,189,189,2,0,0,0,1,189,189,189,11,255,255,0,1,

       0,0,0,2,123,123,123,9,200,200,200,1,123,123,0,27,255,255,0,1,0,0,0,3,123,123,123,8,200,200,200,1,123,123,0,26,255,

       255,0,1,189,189,189,1,0,0,0,3,123,123,123,9,200,200,200,1,123,123,0,24,255,255,0,1,189,189,189,1,0,0,0,4,123,123,

       123,10,200,200,200,1,123,123,0,24,0,0,0,5,123,123,123,12,200,200,200,27,123,123,123,14,200,200,200,25,123,123,123,86,

       200,200,200,91,49,124,118,124,71,32,124,95,49,56,114,52,82,121,0};


     inline void warn(const char *format, ...) {

       if (cimg::exception_mode()>=1) {

         char message[8192] = { 0 };

         std::va_list ap;

         va_start(ap,format);

         std::vsprintf(message,format,ap);

         va_end(ap);

 #ifdef cimg_strict_warnings

         throw CImgWarningException(message);

 #else

         std::fprintf(cimg_stdout,"\n%s# CImg Warning%s :\n%s\n",cimg::t_red,cimg::t_normal,message);

 #endif

       }

     }


     // Execute an external system command.

     inline int system(const char *const command, const char *const module_name=0) {

 #if cimg_OS==2

       PROCESS_INFORMATION pi;

       STARTUPINFO si;

       std::memset(&pi,0,sizeof(PROCESS_INFORMATION));

       std::memset(&si,0,sizeof(STARTUPINFO));

       GetStartupInfo(&si);

       si.cb = sizeof(si);

       si.wShowWindow = SW_HIDE;

       si.dwFlags |= SW_HIDE;

       const BOOL res = CreateProcess((LPCTSTR)module_name,(LPTSTR)command,0,0,FALSE,0,0,0,&si,&pi);

       if (res) {

         WaitForSingleObject(pi.hProcess, INFINITE);

         CloseHandle(pi.hThread);

         CloseHandle(pi.hProcess);

         return 0;

       } else

 #endif

         return std::system(command);

       return module_name?0:1;

     }


     template<typename T>

     inline T& temporary(const T&) {

       static T temp;

       return temp;

     }


     template<typename T>

     inline void swap(T& a, T& b) { T t = a; a = b; b = t; }


     template<typename T1, typename T2>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2) {

       cimg::swap(a1,b1); cimg::swap(a2,b2);

     }


     template<typename T1, typename T2, typename T3>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3) {

       cimg::swap(a1,b1,a2,b2); cimg::swap(a3,b3);

     }


     template<typename T1, typename T2, typename T3, typename T4>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3, T4& a4, T4& b4) {

       cimg::swap(a1,b1,a2,b2,a3,b3); cimg::swap(a4,b4);

     }


     template<typename T1, typename T2, typename T3, typename T4, typename T5>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3, T4& a4, T4& b4, T5& a5, T5& b5) {

       cimg::swap(a1,b1,a2,b2,a3,b3,a4,b4); cimg::swap(a5,b5);

     }


     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3, T4& a4, T4& b4, T5& a5, T5& b5, T6& a6, T6& b6) {

       cimg::swap(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5); cimg::swap(a6,b6);

     }


     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3, T4& a4, T4& b4, T5& a5, T5& b5, T6& a6, T6& b6,

                      T7& a7, T7& b7) {

       cimg::swap(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5,a6,b6); cimg::swap(a7,b7);

     }


     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>

     inline void swap(T1& a1, T1& b1, T2& a2, T2& b2, T3& a3, T3& b3, T4& a4, T4& b4, T5& a5, T5& b5, T6& a6, T6& b6,

                      T7& a7, T7& b7, T8& a8, T8& b8) {

       cimg::swap(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5,a6,b6,a7,b7); cimg::swap(a8,b8);

     }


     inline bool endianness() {

       const int x = 1;

       return ((unsigned char*)&x)[0]?false:true;

     }


     template<typename T>

     inline void invert_endianness(T* const buffer, const unsigned int size) {

       if (size) switch (sizeof(T)) {

       case 1 : break;

       case 2 : { for (unsigned short *ptr = (unsigned short*)buffer+size; ptr>(unsigned short*)buffer; ) {

         const unsigned short val = *(--ptr);

         *ptr = (unsigned short)((val>>8)|((val<<8)));

       }} break;

       case 4 : { for (unsigned int *ptr = (unsigned int*)buffer+size; ptr>(unsigned int*)buffer; ) {

         const unsigned int val = *(--ptr);

         *ptr = (val>>24)|((val>>8)&0xff00)|((val<<8)&0xff0000)|(val<<24);

       }} break;

       default : { for (T* ptr = buffer+size; ptr>buffer; ) {

         unsigned char *pb = (unsigned char*)(--ptr), *pe = pb + sizeof(T);

         for (int i = 0; i<(int)sizeof(T)/2; ++i) swap(*(pb++),*(--pe));

       }}

       }

     }


     template<typename T>

     inline T& invert_endianness(T& a) {

       invert_endianness(&a,1);

       return a;

     }


     inline unsigned long time() {

 #if cimg_OS==1

       struct timeval st_time;

       gettimeofday(&st_time,0);

       return (unsigned long)(st_time.tv_usec/1000 + st_time.tv_sec*1000);

 #elif cimg_OS==2

       static SYSTEMTIME st_time;

       GetSystemTime(&st_time);

       return (unsigned long)(st_time.wMilliseconds + 1000*(st_time.wSecond + 60*(st_time.wMinute + 60*st_time.wHour)));

 #else

       return 0;

 #endif

     }


     inline void sleep(const unsigned int milliseconds) {

 #if cimg_OS==1

       struct timespec tv;

       tv.tv_sec = milliseconds/1000;

       tv.tv_nsec = (milliseconds%1000)*1000000;

       nanosleep(&tv,0);

 #elif cimg_OS==2

       Sleep(milliseconds);

 #endif

     }


     inline unsigned int _sleep(const unsigned int milliseconds, unsigned long& timer) {

       if (!timer) timer = cimg::time();

       const unsigned long current_time = cimg::time();

       if (current_time>=timer+milliseconds) { timer = current_time; return 0; }

       const unsigned long time_diff = timer + milliseconds - current_time;

       timer = current_time + time_diff;

       cimg::sleep(time_diff);

       return (unsigned int)time_diff;

     }


     inline unsigned int wait(const unsigned int milliseconds) {

       static unsigned long timer = 0;

       if (!timer) timer = cimg::time();

       return _sleep(milliseconds,timer);

     }


     // Use a specific srand initialization to avoid multi-threads to have to the

     // same series of random numbers (executed only once for a single program).

     inline void srand() {

       static bool first_time = true;

       if (first_time) {

         std::srand(cimg::time());

         unsigned char *const rand_ptr = new unsigned char[1+std::rand()%2048];

         std::srand((unsigned int)std::rand() + *(unsigned int*)(void*)rand_ptr);

         delete[] rand_ptr;

         first_time = false;

       }

     }


     template<typename T>

     inline const T rol(const T a, const unsigned int n=1) {

       return n?(T)((a<<n)|(a>>((sizeof(T)<<3)-n))):a;

     }


     template<typename T>

     inline const T ror(const T a, const unsigned int n=1) {

       return n?(T)((a>>n)|(a<<((sizeof(T)<<3)-n))):a;

     }


     template<typename T>

     inline T abs(const T a) {

       return a>=0?a:-a;

     }

     inline bool abs(const bool a) {

       return a;

     }

     inline unsigned char abs(const unsigned char a) {

       return a;

     }

     inline unsigned short abs(const unsigned short a) {

       return a;

     }

     inline unsigned int abs(const unsigned int a) {

       return a;

     }

     inline unsigned long abs(const unsigned long a) {

       return a;

     }

     inline double abs(const double a) {

       return std::fabs(a);

     }

     inline float abs(const float a) {

       return (float)std::fabs((double)a);

     }

     inline int abs(const int a) {

       return std::abs(a);

     }


     template<typename T>

     inline T sqr(const T val) {

       return val*val;

     }


     inline int xln(const int x) {

       return x>0?(int)(1+std::log10((double)x)):1;

     }


     template<typename t1, typename t2>

     inline typename cimg::superset<t1,t2>::type min(const t1& a, const t2& b) {

       typedef typename cimg::superset<t1,t2>::type t1t2;

       return (t1t2)(a<=b?a:b);

     }


     template<typename t1, typename t2, typename t3>

     inline typename cimg::superset2<t1,t2,t3>::type min(const t1& a, const t2& b, const t3& c) {

       typedef typename cimg::superset2<t1,t2,t3>::type t1t2t3;

       return (t1t2t3)cimg::min(cimg::min(a,b),c);

     }


     template<typename t1, typename t2, typename t3, typename t4>

     inline typename cimg::superset3<t1,t2,t3,t4>::type min(const t1& a, const t2& b, const t3& c, const t4& d) {

       typedef typename cimg::superset3<t1,t2,t3,t4>::type t1t2t3t4;

       return (t1t2t3t4)cimg::min(cimg::min(a,b,c),d);

     }


     template<typename t1, typename t2>

     inline typename cimg::superset<t1,t2>::type max(const t1& a, const t2& b) {

       typedef typename cimg::superset<t1,t2>::type t1t2;

       return (t1t2)(a>=b?a:b);

     }


     template<typename t1, typename t2, typename t3>

     inline typename cimg::superset2<t1,t2,t3>::type max(const t1& a, const t2& b, const t3& c) {

       typedef typename cimg::superset2<t1,t2,t3>::type t1t2t3;

       return (t1t2t3)cimg::max(cimg::max(a,b),c);

     }


     template<typename t1, typename t2, typename t3, typename t4>

     inline typename cimg::superset3<t1,t2,t3,t4>::type max(const t1& a, const t2& b, const t3& c, const t4& d) {

       typedef typename cimg::superset3<t1,t2,t3,t4>::type t1t2t3t4;

       return (t1t2t3t4)cimg::max(cimg::max(a,b,c),d);

     }


     template<typename T>

     inline T sign(const T x) {

       return (x<0)?(T)(-1):(x==0?(T)0:(T)1);

     }


     template<typename T>

     inline unsigned int nearest_pow2(const T x) {

       unsigned int i = 1;

       while (x>i) i<<=1;

       return i;

     }


     template<typename T>

     inline T mod(const T& x, const T& m) {

       const double dx = (double)x, dm = (double)m;

       if (x<0) { return (T)(dm+dx+dm*std::floor(-dx/dm)); }

       return (T)(dx-dm*std::floor(dx/dm));

     }

     inline int mod(const bool x, const bool m) {

       return m?(x?1:0):0;

     }

     inline int mod(const char x, const char m) {

       return x>=0?x%m:(x%m?m+x%m:0);

     }

     inline int mod(const short x, const short m) {

       return x>=0?x%m:(x%m?m+x%m:0);

     }

     inline int mod(const int x, const int m) {

       return x>=0?x%m:(x%m?m+x%m:0);

     }

     inline int mod(const long x, const long m) {

       return x>=0?x%m:(x%m?m+x%m:0);

     }

     inline int mod(const unsigned char x, const unsigned char m) {

       return x%m;

     }

     inline int mod(const unsigned short x, const unsigned short m) {

       return x%m;

     }

     inline int mod(const unsigned int x, const unsigned int m) {

       return x%m;

     }

     inline int mod(const unsigned long x, const unsigned long m) {

       return x%m;

     }


     template<typename T>

     inline T minmod(const T a, const T b) {

       return a*b<=0?0:(a>0?(a<b?a:b):(a<b?b:a));

     }


     inline double rand() {

       static bool first_time = true;

       if (first_time) { cimg::srand(); first_time = false; }

       return (double)std::rand()/RAND_MAX;

     }


     inline double crand() {

       return 1-2*cimg::rand();

     }


     inline double grand() {

       double x1, w;

       do {

         const double x2 = 2*cimg::rand() - 1.0;

         x1 = 2*cimg::rand()-1.0;

         w = x1*x1 + x2*x2;

       } while (w<=0 || w>=1.0);

       return x1*std::sqrt((-2*std::log(w))/w);

     }


     inline unsigned int prand(const double z) {

       if (z<=1.0e-10) return 0;

       if (z>100.0) return (unsigned int)((std::sqrt(z) * cimg::grand()) + z);

       unsigned int k = 0;

       const double y = std::exp(-z);

       for (double s = 1.0; s>=y; ++k) s*=cimg::rand();

       return k-1;

     }


     inline double round(const double x, const double y, const int rounding_type=0) {

       if (y<=0) return x;

       const double delta = cimg::mod(x,y);

       if (delta==0.0) return x;

       const double

         backward = x - delta,

         forward = backward + y;

       return rounding_type<0?backward:(rounding_type>0?forward:(2*delta<y?backward:forward));

     }


     inline double _pythagore(double a, double b) {

       const double absa = cimg::abs(a), absb = cimg::abs(b);

       if (absa>absb) { const double tmp = absb/absa; return absa*std::sqrt(1.0+tmp*tmp); }

       else { const double tmp = absa/absb; return (absb==0?0:absb*std::sqrt(1.0+tmp*tmp)); }

     }


     inline char uncase(const char x) {

       return (char)((x<'A'||x>'Z')?x:x-'A'+'a');

     }


     inline void uncase(char *const string) {

       if (string) for (char *ptr = string; *ptr; ++ptr) *ptr = uncase(*ptr);

     }


     inline float atof(const char *const str) {

       float x = 0,y = 1;

       if (!str) return 0; else { std::sscanf(str,"%g/%g",&x,&y); return x/y; }

     }


     inline int strncasecmp(const char *const s1, const char *const s2, const int l) {

       if (!l) return 0;

       if (!s1) return s2?-1:0;

       const char *ns1 = s1, *ns2 = s2;

       int k, diff = 0; for (k = 0; k<l && !(diff = uncase(*ns1)-uncase(*ns2)); ++k) { ++ns1; ++ns2; }

       return k!=l?diff:0;

     }


     inline int strcasecmp(const char *const s1, const char *const s2) {

       if (!s1) return s2?-1:0;

       const unsigned int l1 = std::strlen(s1), l2 = std::strlen(s2);

       return cimg::strncasecmp(s1,s2,1+(l1<l2?l1:l2));

     }


     inline bool strpare(char *const s, const char delimiter=' ', const bool symmetric=false) {

       if (!s) return false;

       const int l = (int)std::strlen(s);

       int p, q;

       if (symmetric) for (p = 0, q = l-1; p<q && s[p]==delimiter && s[q]==delimiter; ++p) --q;

       else {

         for (p = 0; p<l && s[p]==delimiter; ) ++p;

         for (q = l-1; q>p && s[q]==delimiter; ) --q;

       }

       const int n = q - p + 1;

       if (n!=l) { std::memmove(s,s+p,n); s[n] = 0; return true; }

       return false;

     }


     inline void strclean(char *const s) {

       if (!s) return;

       strpare(s,' ',false);

       for (bool need_iter = true; need_iter; ) {

         need_iter = false;

         need_iter |= strpare(s,'\'',true);

         need_iter |= strpare(s,'\"',true);

         need_iter |= strpare(s,'`',true);

       }

     }


     inline void strescape(char *const s) {

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

       static unsigned int val = 0;

       for (char *ns = s, *nd = s; *ns || (bool)(*nd=0); ++nd) if (*ns=='\\') switch (*(++ns)) {

         cimg_strescape('n','\n');

         cimg_strescape('t','\t');

         cimg_strescape('v','\v');

         cimg_strescape('b','\b');

         cimg_strescape('r','\r');

         cimg_strescape('f','\f');

         cimg_strescape('a','\a');

         cimg_strescape('\\','\\');

         cimg_strescape('\?','\?');

         cimg_strescape('\'','\'');

         cimg_strescape('\"','\"');

       case 0 : *nd = 0; break;

       case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' :

         std::sscanf(ns,"%o",&val); while (*ns>='0' && *ns<='7') ++ns;

         *nd = val; break;

       case 'x':

         std::sscanf(++ns,"%x",&val); while ((*ns>='0' && *ns<='7') || (*ns>='a' && *ns<='f') || (*ns>='A' && *ns<='F')) ++ns;

         *nd = val; break;

       default : *nd='\\';

       } else *nd = *(ns++);

     }


     inline const char* basename(const char *const s)  {

       const char *p = 0;

       for (const char *np = s; np>=s && (p=np); np = std::strchr(np,cimg_file_separator)+1) {}

       return p;

     }


     // Generate a random filename.

     inline const char* filenamerand() {

       static char randomid[9] = { 0,0,0,0,0,0,0,0,0 };

       cimg::srand();

       for (unsigned int k = 0; k<8; ++k) {

         const int v = (int)std::rand()%3;

         randomid[k] = (char)(v==0?('0'+(std::rand()%10)):(v==1?('a'+(std::rand()%26)):('A'+(std::rand()%26))));

       }

       return randomid;

     }


     // Convert filename into a Windows-style filename.

     inline void winformat_string(char *const s) {

       if (s && s[0]) {

 #if cimg_OS==2

         char *const ns = new char[MAX_PATH];

         if (GetShortPathNameA(s,ns,MAX_PATH)) std::strcpy(s,ns);

 #endif

       }

     }


     inline const char* temporary_path(const char *const user_path=0, const bool reinit_path=false) {

 #define _cimg_test_temporary_path(p) \

       if (!path_found) { \

         std::sprintf(st_path,"%s",p); \

         std::sprintf(tmp,"%s%c%s",st_path,cimg_file_separator,filetmp); \

         if ((file=std::fopen(tmp,"wb"))!=0) { std::fclose(file); std::remove(tmp); path_found = true; } \

       }

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         char tmp[1024] = { 0 }, filetmp[512] = { 0 };

         std::FILE *file = 0;

         std::sprintf(filetmp,"%s.tmp",cimg::filenamerand());

         char *tmpPath = getenv("TMP");

         if (!tmpPath) { tmpPath = getenv("TEMP"); winformat_string(tmpPath); }

         if (tmpPath) _cimg_test_temporary_path(tmpPath);

 #if cimg_OS==2

         _cimg_test_temporary_path("C:\\WINNT\\Temp");

         _cimg_test_temporary_path("C:\\WINDOWS\\Temp");

         _cimg_test_temporary_path("C:\\Temp");

         _cimg_test_temporary_path("C:");

         _cimg_test_temporary_path("D:\\WINNT\\Temp");

         _cimg_test_temporary_path("D:\\WINDOWS\\Temp");

         _cimg_test_temporary_path("D:\\Temp");

         _cimg_test_temporary_path("D:");

 #else

         _cimg_test_temporary_path("/tmp");

         _cimg_test_temporary_path("/var/tmp");

 #endif

         if (!path_found) {

           st_path[0] = 0;

           std::strcpy(tmp,filetmp);

           if ((file=std::fopen(tmp,"wb"))!=0) { std::fclose(file); std::remove(tmp); path_found = true; }

         }

         if (!path_found)

           throw CImgIOException("cimg::temporary_path() : Unable to find a temporary path accessible for writing\n"

                                 "you have to set the macro 'cimg_temporary_path' to a valid path where you have writing access :\n"

                                 "#define cimg_temporary_path \"path\" (before including 'CImg.h')");

       }

       return st_path;

     }


     // Return or set path to the "Program files/" directory (windows only).

 #if cimg_OS==2

     inline const char* programfiles_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[MAX_PATH];

         std::memset(st_path,0,MAX_PATH);

         // Note : in the following line, 0x26 = CSIDL_PROGRAM_FILES (not defined on every compiler).

 #if !defined(__INTEL_COMPILER)

         if (!SHGetSpecialFolderPathA(0,st_path,0x0026,false)) {

           const char *pfPath = getenv("PROGRAMFILES");

           if (pfPath) std::strncpy(st_path,pfPath,MAX_PATH-1);

           else std::strcpy(st_path,"C:\\PROGRA~1");

         }

 #else

         std::strcpy(st_path,"C:\\PROGRA~1");

 #endif

       }

       return st_path;

     }

 #endif


     inline const char* imagemagick_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         const char *pf_path = programfiles_path();

         if (!path_found) {

           std::sprintf(st_path,".\\convert.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%.2d-\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%d-Q\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%d\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%.2d-\\VISUA~1\\BIN\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%d-Q\\VISUA~1\\BIN\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\IMAGEM~1.%d\\VISUA~1\\BIN\\convert.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%.2d-\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%d-Q\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%d\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%.2d-\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%d-Q\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\IMAGEM~1.%d\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%.2d-\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%d-Q\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%d\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%.2d-\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%d-Q\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\IMAGEM~1.%d\\VISUA~1\\BIN\\convert.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"convert.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./convert");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"convert");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char* graphicsmagick_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         const char* pf_path = programfiles_path();

         if (!path_found) {

           std::sprintf(st_path,".\\gm.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%.2d-\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%d-Q\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%d\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%.2d-\\VISUA~1\\BIN\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%d-Q\\VISUA~1\\BIN\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"%s\\GRAPHI~1.%d\\VISUA~1\\BIN\\gm.exe",pf_path,k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%.2d-\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%d-Q\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%d\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%.2d-\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%d-Q\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"C:\\GRAPHI~1.%d\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%.2d-\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%d-Q\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%d\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=10 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%.2d-\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 9; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%d-Q\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         for (int k = 32; k>=0 && !path_found; --k) {

           std::sprintf(st_path,"D:\\GRAPHI~1.%d\\VISUA~1\\BIN\\gm.exe",k);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gm.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./gm");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gm");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char* medcon_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         const char* pf_path = programfiles_path();

         if (!path_found) {

           std::sprintf(st_path,".\\medcon.bat");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) {

           std::sprintf(st_path,".\\medcon.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) {

           std::sprintf(st_path,"%s\\XMedCon\\bin\\medcon.bat",pf_path);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) {

           std::sprintf(st_path,"%s\\XMedCon\\bin\\medcon.exe",pf_path);

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"medcon.bat");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./medcon");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"medcon");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char *ffmpeg_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         if (!path_found) {

           std::sprintf(st_path,".\\ffmpeg.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"ffmpeg.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./ffmpeg");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"ffmpeg");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char *gzip_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         if (!path_found) {

           std::sprintf(st_path,".\\gzip.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gzip.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./gzip");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gzip");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char *gunzip_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         if (!path_found) {

           std::sprintf(st_path,".\\gunzip.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gunzip.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./gunzip");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"gunzip");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char *dcraw_path(const char *const user_path=0, const bool reinit_path=false) {

       static char *st_path = 0;

       if (reinit_path && st_path) { delete[] st_path; st_path = 0; }

       if (user_path) {

         if (!st_path) st_path = new char[1024];

         std::memset(st_path,0,1024);

         std::strncpy(st_path,user_path,1023);

       } else if (!st_path) {

         st_path = new char[1024];

         std::memset(st_path,0,1024);

         bool path_found = false;

         std::FILE *file = 0;

 #if cimg_OS==2

         if (!path_found) {

           std::sprintf(st_path,".\\dcraw.exe");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"dcraw.exe");

 #else

         if (!path_found) {

           std::sprintf(st_path,"./dcraw");

           if ((file=std::fopen(st_path,"r"))!=0) { std::fclose(file); path_found = true; }

         }

         if (!path_found) std::strcpy(st_path,"dcraw");

 #endif

         winformat_string(st_path);

       }

       return st_path;

     }


     inline const char *split_filename(const char *const filename, char *const body=0) {

       if (!filename) { if (body) body[0] = 0; return 0; }

       const char *p = 0; for (const char *np = filename; np>=filename && (p=np); np = std::strchr(np,'.')+1) {}

       if (p==filename) {

         if (body) std::strcpy(body,filename);

         return filename + std::strlen(filename);

       }

       const unsigned int l = p - filename - 1;

       if (body) { std::memcpy(body,filename,l); body[l] = 0; }

       return p;

     }


     inline char* number_filename(const char *const filename, const int number, const unsigned int n, char *const string) {

       if (!filename) { if (string) string[0] = 0; return 0; }

       char format[1024] = { 0 }, body[1024] = { 0 };

       const char *ext = cimg::split_filename(filename,body);

       if (n>0) std::sprintf(format,"%s_%%.%ud.%s",body,n,ext);

       else std::sprintf(format,"%s_%%d.%s",body,ext);

       std::sprintf(string,format,number);

       return string;

     }


     inline std::FILE *fopen(const char *const path, const char *const mode) {

       if(!path || !mode)

         throw CImgArgumentException("cimg::fopen() : File '%s', cannot open with mode '%s'.",

                                     path?path:"(null)",mode?mode:"(null)");

       if (path[0]=='-') return (mode[0]=='r')?stdin:stdout;

       std::FILE *dest = std::fopen(path,mode);

       if (!dest)

         throw CImgIOException("cimg::fopen() : File '%s', cannot open file %s",

                               path,mode[0]=='r'?"for reading.":(mode[0]=='w'?"for writing.":"."),path);

       return dest;

     }


     inline int fclose(std::FILE *file) {

       if (!file) warn("cimg::fclose() : Cannot close (null) file");

       if (!file || file==stdin || file==stdout) return 0;

       const int errn = std::fclose(file);

       if (errn!=0) warn("cimg::fclose() : Error %d during file closing",errn);

       return errn;

     }


     inline const char *file_type(std::FILE *const file, const char *const filename) {

       static const char

         *const _pnm = "pnm",

         *const _bmp = "bmp",

         *const _gif = "gif",

         *const _jpeg = "jpeg",

         *const _off = "off",

         *const _pan = "pan",

         *const _png = "png",

         *const _tiff = "tiff";

       if (!filename && !file) throw CImgArgumentException("cimg::file_type() : Cannot load (null) filename.");

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       const char *ftype = 0, *head;

       char header[2048] = { 0 }, item[1024] = { 0 };

       const unsigned char *const uheader = (unsigned char*)header;

       int err;

       const unsigned int siz = (unsigned int)std::fread(header,2048,1,nfile);   // Read first 2048 bytes.

       if (!file) cimg::fclose(nfile);

       if (!ftype) { // Check for BMP format.

         if (header[0]=='B' && header[1]=='M') ftype = _bmp;

       }

       if (!ftype) { // Check for GIF format.

         if (header[0]=='G' && header[1]=='I' && header[2]=='F' && header[3]=='8' && header[5]=='a' &&

             (header[4]=='7' || header[4]=='9')) ftype = _gif;

       }

       if (!ftype) { // Check for JPEG format.

         if (uheader[0]==0xFF && uheader[1]==0xD8 && uheader[2]==0xFF) ftype = _jpeg;

       }

       if (!ftype) { // Check for OFF format.

         if (header[0]=='O' && header[1]=='F' && header[2]=='F' && header[3]=='\n') ftype = _off;

       }

       if (!ftype) { // Check for PAN format.

         if (header[0]=='P' && header[1]=='A' && header[2]=='N' && header[3]=='D' && header[4]=='O' &&

             header[5]=='R' && header[6]=='E') ftype = _pan;

       }

       if (!ftype) { // Check for PNG format.

         if (uheader[0]==0x89 && uheader[1]==0x50 && uheader[2]==0x4E && uheader[3]==0x47 &&

             uheader[4]==0x0D && uheader[5]==0x0A && uheader[6]==0x1A && uheader[7]==0x0A) ftype = _png;

       }

       if (!ftype) { // Check for PNM format.

         head = header;

         while (head<header+siz && (err=std::sscanf(head,"%1023[^\n]",item))!=EOF && (item[0]=='#' || !err))

           head+=1+(err?std::strlen(item):0);

         if (std::sscanf(item," P%d",&err)==1) ftype = _pnm;

       }

       if (!ftype) { // Check for TIFF format.

         if ((uheader[0]==0x49 && uheader[1]==0x49) || (uheader[0]==0x4D && uheader[1]==0x4D)) ftype = _tiff;

       }

       return ftype;

     }


     template<typename T>

     inline int fread(T *const ptr, const unsigned int nmemb, std::FILE *stream) {

       if (!ptr || nmemb<=0 || !stream)

         throw CImgArgumentException("cimg::fread() : Cannot read %u x %u bytes of file pointer '%p' in buffer '%p'",

                                     nmemb,sizeof(T),stream,ptr);

       const unsigned long wlimitT = 63*1024*1024, wlimit = wlimitT/sizeof(T);

       unsigned int toread = nmemb, alread = 0, ltoread = 0, lalread = 0;

       do {

         ltoread = (toread*sizeof(T))<wlimitT?toread:wlimit;

         lalread = (unsigned int)std::fread((void*)(ptr+alread),sizeof(T),ltoread,stream);

         alread+=lalread;

         toread-=lalread;

       } while (ltoread==lalread && toread>0);

       if (toread>0) warn("cimg::fread() : File reading problems, only %u/%u elements read",alread,nmemb);

       return alread;

     }


     template<typename T>

     inline int fwrite(const T *ptr, const unsigned int nmemb, std::FILE *stream) {

       if (!ptr || !stream)

         throw CImgArgumentException("cimg::fwrite() : Cannot write %u x %u bytes of file pointer '%p' from buffer '%p'",

                                     nmemb,sizeof(T),stream,ptr);

       if (nmemb<=0) return 0;

       const unsigned long wlimitT = 63*1024*1024, wlimit = wlimitT/sizeof(T);

       unsigned int towrite = nmemb, alwrite = 0, ltowrite = 0, lalwrite = 0;

       do {

         ltowrite = (towrite*sizeof(T))<wlimitT?towrite:wlimit;

         lalwrite = (unsigned int)std::fwrite((void*)(ptr+alwrite),sizeof(T),ltowrite,stream);

         alwrite+=lalwrite;

         towrite-=lalwrite;

       } while (ltowrite==lalwrite && towrite>0);

       if (towrite>0) warn("cimg::fwrite() : File writing problems, only %u/%u elements written",alwrite,nmemb);

       return alwrite;

     }


     inline const char* option(const char *const name, const int argc, const char *const *const argv,

                               const char *defaut, const char *const usage=0) {

       static bool first = true, visu = false;

       const char *res = 0;

       if (first) {

         first=false;

         visu = (cimg::option("-h",argc,argv,(char*)0)!=0);

         visu |= (cimg::option("-help",argc,argv,(char*)0)!=0);

         visu |= (cimg::option("--help",argc,argv,(char*)0)!=0);

       }

       if (!name && visu) {

         if (usage) {

           std::fprintf(cimg_stdout,"\n %s%s%s",cimg::t_red,cimg::basename(argv[0]),cimg::t_normal);

           std::fprintf(cimg_stdout," : %s",usage);

           std::fprintf(cimg_stdout," (%s, %s)\n\n",__DATE__,__TIME__);

         }

         if (defaut) std::fprintf(cimg_stdout,"%s\n",defaut);

       }

       if (name) {

         if (argc>0) {

           int k = 0;

           while (k<argc && std::strcmp(argv[k],name)) ++k;

           res = (k++==argc?defaut:(k==argc?argv[--k]:argv[k]));

         } else res = defaut;

         if (visu && usage) std::fprintf(cimg_stdout,"    %s%-16s%s %-24s %s%s%s\n",

                                         cimg::t_bold,name,cimg::t_normal,res?res:"0",cimg::t_green,usage,cimg::t_normal);

       }

       return res;

     }


     inline bool option(const char *const name, const int argc, const char *const *const argv,

                        const bool defaut, const char *const usage=0) {

       const char *s = cimg::option(name,argc,argv,(char*)0);

       const bool res = s?(cimg::strcasecmp(s,"false") && cimg::strcasecmp(s,"off") && cimg::strcasecmp(s,"0")):defaut;

       cimg::option(name,0,0,res?"true":"false",usage);

       return res;

     }


     inline int option(const char *const name, const int argc, const char *const *const argv,

                       const int defaut, const char *const usage=0) {

       const char *s = cimg::option(name,argc,argv,(char*)0);

       const int res = s?std::atoi(s):defaut;

       char tmp[256] = { 0 };

       std::sprintf(tmp,"%d",res);

       cimg::option(name,0,0,tmp,usage);

       return res;

     }


     inline char option(const char *const name, const int argc, const char *const *const argv,

                        const char defaut, const char *const usage=0) {

       const char *s = cimg::option(name,argc,argv,(char*)0);

       const char res = s?s[0]:defaut;

       char tmp[8] = { 0 };

       tmp[0] = res;

       cimg::option(name,0,0,tmp,usage);

       return res;

     }


     inline float option(const char *const name, const int argc, const char *const *const argv,

                         const float defaut, const char *const usage=0) {

       const char *s = cimg::option(name,argc,argv,(char*)0);

       const float res = s?cimg::atof(s):defaut;

       char tmp[256] = { 0 };

       std::sprintf(tmp,"%g",res);

       cimg::option(name,0,0,tmp,usage);

       return res;

     }


     inline double option(const char *const name, const int argc, const char *const *const argv,

                          const double defaut, const char *const usage=0) {

       const char *s = cimg::option(name,argc,argv,(char*)0);

       const double res = s?cimg::atof(s):defaut;

       char tmp[256] = { 0 };

       std::sprintf(tmp,"%g",res);

       cimg::option(name,0,0,tmp,usage);

       return res;

     }


     inline const char* argument(const unsigned int nb, const int argc, const char *const *const argv, const unsigned int nb_singles=0, ...) {

       for (int k = 1, pos = 0; k<argc;) {

         const char *const item = argv[k];

         bool option = (*item=='-'), single_option = false;

         if (option) {

           va_list ap;

           va_start(ap,nb_singles);

           for (unsigned int i = 0; i<nb_singles; ++i) if (!cimg::strcasecmp(item,va_arg(ap,char*))) { single_option = true; break; }

           va_end(ap);

         }

         if (option) { ++k; if (!single_option) ++k; }

         else { if (pos++==(int)nb) return item; else ++k; }

       }

       return 0;

     }


     inline void info() {

       char tmp[1024] = { 0 };

       std::fprintf(cimg_stdout,"\n %sCImg Library %u.%u.%u%s, compiled %s ( %s ) with the following flags :\n\n",

                    cimg::t_red,cimg_version/100,(cimg_version/10)%10,cimg_version%10,

                    cimg::t_normal,__DATE__,__TIME__);


       std::fprintf(cimg_stdout,"  > Operating System :       %s%-13s%s %s('cimg_OS'=%d)%s\n",

                    cimg::t_bold,

                    cimg_OS==1?"Unix":(cimg_OS==2?"Windows":"Unknow"),

                    cimg::t_normal,cimg::t_green,

                    cimg_OS,

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > CPU endianness :         %s%s Endian%s\n",

                    cimg::t_bold,

                    cimg::endianness()?"Big":"Little",

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Debug messages :         %s%-13s%s %s('cimg_debug'=%d)%s\n",

                    cimg::t_bold,

                    cimg_debug==0?"Quiet":(cimg_debug==1?"Console":(cimg_debug==2?"Dialog":(cimg_debug==3?"Console+Warnings":"Dialog+Warnings"))),

                    cimg::t_normal,cimg::t_green,

                    cimg_debug,

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Stricts warnings :       %s%-13s%s %s('cimg_strict_warnings' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_strict_warnings

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using VT100 messages :   %s%-13s%s %s('cimg_use_vt100' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_vt100

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Display type :           %s%-13s%s %s('cimg_display'=%d)%s\n",

                    cimg::t_bold,

                    cimg_display==0?"No display":

                    (cimg_display==1?"X11":

                     (cimg_display==2?"Windows GDI":

                      (cimg_display==3?"Carbon":"Unknow"))),

                    cimg::t_normal,cimg::t_green,

                    cimg_display,

                    cimg::t_normal);


 #if cimg_display==1

       std::fprintf(cimg_stdout,"  > Using XShm for X11 :     %s%-13s%s %s('cimg_use_xshm' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_xshm

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using XRand for X11 :    %s%-13s%s %s('cimg_use_xrandr' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_xrandr

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);

 #endif

       std::fprintf(cimg_stdout,"  > Using OpenMP :           %s%-13s%s %s('cimg_use_openmp' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_openmp

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);

       std::fprintf(cimg_stdout,"  > Using PNG library :      %s%-13s%s %s('cimg_use_png' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_png

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);

       std::fprintf(cimg_stdout,"  > Using JPEG library :     %s%-13s%s %s('cimg_use_jpeg' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_jpeg

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using TIFF library :     %s%-13s%s %s('cimg_use_tiff' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_tiff

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using Magick++ library : %s%-13s%s %s('cimg_use_magick' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_magick

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using FFTW3 library :    %s%-13s%s %s('cimg_use_fftw3' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_fftw3

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"  > Using LAPACK library :   %s%-13s%s %s('cimg_use_lapack' %s)%s\n",

                    cimg::t_bold,

 #ifdef cimg_use_lapack

                    "Yes",cimg::t_normal,cimg::t_green,"defined",

 #else

                    "No",cimg::t_normal,cimg::t_green,"undefined",

 #endif

                    cimg::t_normal);


       std::sprintf(tmp,"\"%.1020s\"",cimg::imagemagick_path());

       std::fprintf(cimg_stdout,"  > Path of ImageMagick :    %s%-13s%s\n",

                    cimg::t_bold,

                    tmp,

                    cimg::t_normal);


       std::sprintf(tmp,"\"%.1020s\"",cimg::graphicsmagick_path());

       std::fprintf(cimg_stdout,"  > Path of GraphicsMagick : %s%-13s%s\n",

                    cimg::t_bold,

                    tmp,

                    cimg::t_normal);


       std::sprintf(tmp,"\"%.1020s\"",cimg::medcon_path());

       std::fprintf(cimg_stdout,"  > Path of 'medcon' :       %s%-13s%s\n",

                    cimg::t_bold,

                    tmp,

                    cimg::t_normal);


       std::sprintf(tmp,"\"%.1020s\"",cimg::temporary_path());

       std::fprintf(cimg_stdout,"  > Temporary path :         %s%-13s%s\n",

                    cimg::t_bold,

                    tmp,

                    cimg::t_normal);


       std::fprintf(cimg_stdout,"\n");

     }


     // Declare LAPACK function signatures if necessary.

 #ifdef cimg_use_lapack

     template<typename T>

     inline void getrf(int &N, T *lapA, int *IPIV, int &INFO) {

       dgetrf_(&N,&N,lapA,&N,IPIV,&INFO);

     }


     inline void getrf(int &N, float *lapA, int *IPIV, int &INFO) {

       sgetrf_(&N,&N,lapA,&N,IPIV,&INFO);

     }


     template<typename T>

     inline void getri(int &N, T *lapA, int *IPIV, T* WORK, int &LWORK, int &INFO) {

       dgetri_(&N,lapA,&N,IPIV,WORK,&LWORK,&INFO);

     }


     inline void getri(int &N, float *lapA, int *IPIV, float* WORK, int &LWORK, int &INFO) {

       sgetri_(&N,lapA,&N,IPIV,WORK,&LWORK,&INFO);

     }


     template<typename T>

     inline void gesvd(char &JOB, int &M, int &N, T *lapA, int &MN,

                       T *lapS, T *lapU, T *lapV, T *WORK, int &LWORK, int &INFO) {

       dgesvd_(&JOB,&JOB,&M,&N,lapA,&MN,lapS,lapU,&M,lapV,&N,WORK,&LWORK,&INFO);

     }


     inline void gesvd(char &JOB, int &M, int &N, float *lapA, int &MN,

                       float *lapS, float *lapU, float *lapV, float *WORK, int &LWORK, int &INFO) {

       sgesvd_(&JOB,&JOB,&M,&N,lapA,&MN,lapS,lapU,&M,lapV,&N,WORK,&LWORK,&INFO);

     }


     template<typename T>

     inline void getrs(char &TRANS, int &N, T *lapA, int *IPIV, T *lapB, int &INFO) {

       int one = 1;

       dgetrs_(&TRANS,&N,&one,lapA,&N,IPIV,lapB,&N,&INFO);

     }


     inline void getrs(char &TRANS, int &N, float *lapA, int *IPIV, float *lapB, int &INFO) {

       int one = 1;

       sgetrs_(&TRANS,&N,&one,lapA,&N,IPIV,lapB,&N,&INFO);

     }


     template<typename T>

     inline void syev(char &JOB, char &UPLO, int &N, T *lapA, T *lapW, T *WORK, int &LWORK, int &INFO) {

       dsyev_(&JOB,&UPLO,&N,lapA,&N,lapW,WORK,&LWORK,&INFO);

     }


     inline void syev(char &JOB, char &UPLO, int &N, float *lapA, float *lapW, float *WORK, int &LWORK, int &INFO) {

       ssyev_(&JOB,&UPLO,&N,lapA,&N,lapW,WORK,&LWORK,&INFO);

     }

 #endif


     // End of the 'cimg' namespace

   }


   /*------------------------------------------------

    #

    #

    #   Definition of mathematical operators and

    #   external functions.

    #

    #

    -------------------------------------------------*/


 #define _cimg_create_ext_operators(typ) \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator+(const typ val, const CImg<T>& img) { \

     return img + val; \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator-(const typ val, const CImg<T>& img) { \

     typedef typename cimg::superset<T,typ>::type Tt; \

     return CImg<Tt>(img.width,img.height,img.depth,img.dim,val)-=img; \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator*(const typ val, const CImg<T>& img) { \

     return img*val; \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator/(const typ val, const CImg<T>& img) { \

     return val*img.get_invert(); \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator&(const typ val, const CImg<T>& img) { \

     return img & val; \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator|(const typ val, const CImg<T>& img) { \

     return img | val; \

   } \

   template<typename T> \

   inline CImg<typename cimg::superset<T,typ>::type> operator^(const typ val, const CImg<T>& img) { \

     return img ^ val; \

   } \


   _cimg_create_ext_operators(bool)

   _cimg_create_ext_operators(unsigned char)

   _cimg_create_ext_operators(char)

   _cimg_create_ext_operators(signed char)

   _cimg_create_ext_operators(unsigned short)

   _cimg_create_ext_operators(short)

   _cimg_create_ext_operators(unsigned int)

   _cimg_create_ext_operators(int)

   _cimg_create_ext_operators(unsigned long)

   _cimg_create_ext_operators(long)

   _cimg_create_ext_operators(float)

   _cimg_create_ext_operators(double)


   template<typename T>

   inline CImg<_cimg_Tfloat> operator+(const char *const expression, const CImg<T>& img) {

     return img + expression;

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> operator-(const char *const expression, const CImg<T>& img) {

     return (CImg<_cimg_Tfloat>(img.width,img.height,img.depth,img.dim)=expression)-=img;

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> operator*(const char *const expression, const CImg<T>& img) {

     return img*expression;

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> operator/(const char *const expression, const CImg<T>& img) {

     return expression*img.get_invert();

   }


   template<typename T>

   inline CImg<T> operator&(const char *const expression, const CImg<T>& img) {

     return img & expression;

   }


   template<typename T>

   inline CImg<T> operator|(const char *const expression, const CImg<T>& img) {

     return img | expression;

   }


   template<typename T>

   inline CImg<T> operator^(const char *const expression, const CImg<T>& img) {

     return img ^ expression;

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> sqr(const CImg<T>& instance) {

     return instance.get_sqr();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> sqrt(const CImg<T>& instance) {

     return instance.get_sqrt();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> exp(const CImg<T>& instance) {

     return instance.get_exp();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> log(const CImg<T>& instance) {

     return instance.get_log();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> log10(const CImg<T>& instance) {

     return instance.get_log10();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> abs(const CImg<T>& instance) {

     return instance.get_abs();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> cos(const CImg<T>& instance) {

     return instance.get_cos();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> sin(const CImg<T>& instance) {

     return instance.get_sin();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> tan(const CImg<T>& instance) {

     return instance.get_tan();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> acos(const CImg<T>& instance) {

     return instance.get_acos();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> asin(const CImg<T>& instance) {

     return instance.get_asin();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> atan(const CImg<T>& instance) {

     return instance.get_atan();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> cosh(const CImg<T>& instance) {

     return instance.get_cosh();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> sinh(const CImg<T>& instance) {

     return instance.get_sinh();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> tanh(const CImg<T>& instance) {

     return instance.get_tanh();

   }


   template<typename T>

   inline CImg<T> transpose(const CImg<T>& instance) {

     return instance.get_transpose();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> invert(const CImg<T>& instance) {

     return instance.get_invert();

   }


   template<typename T>

   inline CImg<_cimg_Tfloat> pseudoinvert(const CImg<T>& instance) {

     return instance.get_pseudoinvert();

   }


   /*-------------------------------------------

    #

    #

    #

    # Definition of the CImgDisplay structure

    #

    #

    #

    --------------------------------------------*/


   struct CImgDisplay {


     unsigned int width;


     unsigned int height;


     volatile unsigned int window_width;


     volatile unsigned int window_height;


     volatile int window_x;


     volatile int window_y;


     volatile int mouse_x;


     volatile int mouse_y;


     unsigned int normalization;


     char* title;


     volatile unsigned int buttons[512];

     volatile unsigned int& button;


     volatile int wheel;


     volatile unsigned int& key;

     volatile unsigned int keys[512];


     volatile unsigned int& released_key;

     volatile unsigned int released_keys[512];


     volatile bool is_closed;


     volatile bool is_resized;


     volatile bool is_moved;


     volatile bool is_event;


     volatile bool is_keyESC;

     volatile bool is_keyF1;

     volatile bool is_keyF2;

     volatile bool is_keyF3;

     volatile bool is_keyF4;

     volatile bool is_keyF5;

     volatile bool is_keyF6;

     volatile bool is_keyF7;

     volatile bool is_keyF8;

     volatile bool is_keyF9;

     volatile bool is_keyF10;

     volatile bool is_keyF11;

     volatile bool is_keyF12;

     volatile bool is_keyPAUSE;

     volatile bool is_key1;

     volatile bool is_key2;

     volatile bool is_key3;

     volatile bool is_key4;

     volatile bool is_key5;

     volatile bool is_key6;

     volatile bool is_key7;

     volatile bool is_key8;

     volatile bool is_key9;

     volatile bool is_key0;

     volatile bool is_keyBACKSPACE;

     volatile bool is_keyINSERT;

     volatile bool is_keyHOME;

     volatile bool is_keyPAGEUP;

     volatile bool is_keyTAB;

     volatile bool is_keyQ;

     volatile bool is_keyW;

     volatile bool is_keyE;

     volatile bool is_keyR;

     volatile bool is_keyT;

     volatile bool is_keyY;

     volatile bool is_keyU;

     volatile bool is_keyI;

     volatile bool is_keyO;

     volatile bool is_keyP;

     volatile bool is_keyDELETE;

     volatile bool is_keyEND;

     volatile bool is_keyPAGEDOWN;

     volatile bool is_keyCAPSLOCK;

     volatile bool is_keyA;

     volatile bool is_keyS;

     volatile bool is_keyD;

     volatile bool is_keyF;

     volatile bool is_keyG;

     volatile bool is_keyH;

     volatile bool is_keyJ;

     volatile bool is_keyK;

     volatile bool is_keyL;

     volatile bool is_keyENTER;

     volatile bool is_keySHIFTLEFT;

     volatile bool is_keyZ;

     volatile bool is_keyX;

     volatile bool is_keyC;

     volatile bool is_keyV;

     volatile bool is_keyB;

     volatile bool is_keyN;

     volatile bool is_keyM;

     volatile bool is_keySHIFTRIGHT;

     volatile bool is_keyARROWUP;

     volatile bool is_keyCTRLLEFT;

     volatile bool is_keyAPPLEFT;

     volatile bool is_keyALT;

     volatile bool is_keySPACE;

     volatile bool is_keyALTGR;

     volatile bool is_keyAPPRIGHT;

     volatile bool is_keyMENU;

     volatile bool is_keyCTRLRIGHT;

     volatile bool is_keyARROWLEFT;

     volatile bool is_keyARROWDOWN;

     volatile bool is_keyARROWRIGHT;

     volatile bool is_keyPAD0;

     volatile bool is_keyPAD1;

     volatile bool is_keyPAD2;

     volatile bool is_keyPAD3;

     volatile bool is_keyPAD4;

     volatile bool is_keyPAD5;

     volatile bool is_keyPAD6;

     volatile bool is_keyPAD7;

     volatile bool is_keyPAD8;

     volatile bool is_keyPAD9;

     volatile bool is_keyPADADD;

     volatile bool is_keyPADSUB;

     volatile bool is_keyPADMUL;

     volatile bool is_keyPADDIV;


     bool is_fullscreen;


     // Internal variables

     float fps_fps, min, max;

     unsigned long timer, fps_frames, fps_timer;


     //---------------------------

     //


     //---------------------------


 #ifdef cimgdisplay_plugin

 #include cimgdisplay_plugin

 #endif

 #ifdef cimgdisplay_plugin1

 #include cimgdisplay_plugin1

 #endif

 #ifdef cimgdisplay_plugin2

 #include cimgdisplay_plugin2

 #endif

 #ifdef cimgdisplay_plugin3

 #include cimgdisplay_plugin3

 #endif

 #ifdef cimgdisplay_plugin4

 #include cimgdisplay_plugin4

 #endif

 #ifdef cimgdisplay_plugin5

 #include cimgdisplay_plugin5

 #endif

 #ifdef cimgdisplay_plugin6

 #include cimgdisplay_plugin6

 #endif

 #ifdef cimgdisplay_plugin7

 #include cimgdisplay_plugin7

 #endif

 #ifdef cimgdisplay_plugin8

 #include cimgdisplay_plugin8

 #endif


     //--------------------------------------------------------

     //


     //--------------------------------------------------------


     ~CImgDisplay() {

       assign();

     }


     CImgDisplay():

       width(0),height(0),window_width(0),window_height(0),mouse_x(-1),mouse_y(-1),

       normalization(0),title(0),button(*buttons),wheel(0),key(*keys),released_key(*released_keys),

       is_closed(true),is_resized(false),is_moved(false),is_event(false),is_fullscreen(false),min(0),max(0) {}


     CImgDisplay(const unsigned int dimw, const unsigned int dimh, const char *title=0,

                 const unsigned int normalization_type=3,

                 const bool fullscreen_flag=false, const bool closed_flag=false):

       width(0),height(0),window_width(0),window_height(0),mouse_x(-1),mouse_y(-1),

       normalization(0),title(0),button(*buttons),wheel(0),key(*keys),released_key(*released_keys),

       is_closed(true),is_resized(false),is_moved(false),is_event(false),is_fullscreen(false),min(0),max(0) {

       assign(dimw,dimh,title,normalization_type,fullscreen_flag,closed_flag);

     }


     template<typename T>

     explicit CImgDisplay(const CImg<T>& img, const char *title=0,

                          const unsigned int normalization_type=3,

                          const bool fullscreen_flag=false, const bool closed_flag=false):

       width(0),height(0),window_width(0),window_height(0),mouse_x(-1),mouse_y(-1),

       normalization(0),title(0),button(*buttons),wheel(0),key(*keys),released_key(*released_keys),

       is_closed(true),is_resized(false),is_moved(false),is_event(false),is_fullscreen(false),min(0),max(0) {

       assign(img,title,normalization_type,fullscreen_flag,closed_flag);

     }


     template<typename T>

     explicit CImgDisplay(const CImgList<T>& list, const char *title=0,

                          const unsigned int normalization_type=3,

                          const bool fullscreen_flag=false, const bool closed_flag=false):

       width(0),height(0),window_width(0),window_height(0),mouse_x(-1),mouse_y(-1),

       normalization(0),title(0),button(*buttons),wheel(0),key(*keys),released_key(*released_keys),

       is_closed(true),is_resized(false),is_moved(false),is_event(false),is_fullscreen(false),min(0),max(0) {

       assign(list,title,normalization_type,fullscreen_flag,closed_flag);

     }


     CImgDisplay(const CImgDisplay& disp):

       width(0),height(0),window_width(0),window_height(0),mouse_x(-1),mouse_y(-1),

       normalization(0),title(0),button(*buttons),wheel(0),key(*keys),released_key(*released_keys),

       is_closed(true),is_resized(false),is_moved(false),is_event(false),is_fullscreen(false),min(0),max(0) {

       assign(disp);

     }


 #if cimg_display==0

     CImgDisplay& assign() {

       return *this;

     }


     CImgDisplay& assign(const unsigned int dimw, const unsigned int dimh, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       throw CImgDisplayException("CImgDisplay() : Display has been required but is not available (cimg_display=0)");

       const char* avoid_warning = title + dimw + dimh + normalization_type + (int)fullscreen_flag + (int)closed_flag;

       avoid_warning = 0;

       return *this;

     }


     template<typename T>

     CImgDisplay& assign(const CImg<T>& img, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       throw CImgDisplayException("CImgDisplay()::assign() : Display has been required but is not available (cimg_display=0)");

       const char* avoid_warning = title + img.width + normalization_type + (int)fullscreen_flag + (int)closed_flag;

       avoid_warning = 0;

       return assign(0,0);

     }


     template<typename T>

     CImgDisplay& assign(const CImgList<T>& list, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       throw CImgDisplayException("CImgDisplay()::assign() : Display has been required but is not available (cimg_display=0)");

       const char* avoid_warning = title + list.width + normalization_type + (int)fullscreen_flag + (int)closed_flag;

       avoid_warning = 0;

       return assign(0,0);

     }


     CImgDisplay& assign(const CImgDisplay &disp) {

       return assign(disp.width,disp.height);

     }

 #endif


     static CImgDisplay& empty() {

       static CImgDisplay _empty;

       return _empty.assign();

     }


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

     static unsigned int _fitscreen(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1,

                                    const int dmin=128, const int dmax=-85,const bool return_last=false) {

       unsigned int nw = dx + (dz>1?dz:0), nh = dy + (dz>1?dz:0);

       const unsigned int

         sw = CImgDisplay::screen_dimx(), sh = CImgDisplay::screen_dimy(),

         mw = dmin<0?(unsigned int)(sw*-dmin/100):(unsigned int)dmin,

         mh = dmin<0?(unsigned int)(sh*-dmin/100):(unsigned int)dmin,

         Mw = dmax<0?(unsigned int)(sw*-dmax/100):(unsigned int)dmax,

         Mh = dmax<0?(unsigned int)(sh*-dmax/100):(unsigned int)dmax;

       if (nw<mw) { nh = nh*mw/nw; nh+=(nh==0); nw = mw; }

       if (nh<mh) { nw = nw*mh/nh; nw+=(nw==0); nh = mh; }

       if (nw>Mw) { nh = nh*Mw/nw; nh+=(nh==0); nw = Mw; }

       if (nh>Mh) { nw = nw*Mh/nh; nw+=(nw==0); nh = Mh; }

       if (nw<mw) nw = mw;

       if (nh<mh) nh = mh;

       if (return_last) return nh;

       return nw;

     }


     //------------------------------------------

     //


     //------------------------------------------


     // Operator=().

     template<typename t>

     CImgDisplay& operator=(const CImg<t>& img) {

       return display(img);

     }


     // Operator=().

     template<typename t>

     CImgDisplay& operator=(const CImgList<t>& list) {

       return display(list);

     }


     CImgDisplay& operator=(const CImgDisplay& disp) {

       return assign(disp);

     }


     operator bool() const {

       return !is_empty();

     }


     //------------------------------------------

     //


     //------------------------------------------


     bool is_empty() const {

       return (!width || !height);

     }


     bool is_key(const bool remove=false) {

       for (unsigned int *ptrs=(unsigned int*)keys+512-1; ptrs>=keys; --ptrs) if (*ptrs) { if (remove) *ptrs = 0; return true; }

       return false;

     }


     bool is_key(const unsigned int key1, const bool remove) {

       for (unsigned int *ptrs=(unsigned int*)keys+512-1; ptrs>=keys; --ptrs) if (*ptrs==key1) { if (remove) *ptrs = 0; return true; }

       return false;

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const bool remove) {

       const unsigned int seq[] = { key1, key2 };

       return is_key(seq,2,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3 };

       return is_key(seq,3,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                  const unsigned int key4, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4 };

       return is_key(seq,4,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                 const unsigned int key4, const unsigned int key5, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4, key5 };

       return is_key(seq,5,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                 const unsigned int key4, const unsigned int key5, const unsigned int key6, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4, key5, key6 };

       return is_key(seq,6,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                 const unsigned int key4, const unsigned int key5, const unsigned int key6,

                 const unsigned int key7, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4, key5, key6, key7 };

       return is_key(seq,7,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                 const unsigned int key4, const unsigned int key5, const unsigned int key6,

                 const unsigned int key7, const unsigned int key8, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4, key5, key6, key7, key8 };

       return is_key(seq,8,remove);

     }


     bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3,

                 const unsigned int key4, const unsigned int key5, const unsigned int key6,

                 const unsigned int key7, const unsigned int key8, const unsigned int key9, const bool remove) {

       const unsigned int seq[] = { key1, key2, key3, key4, key5, key6, key7, key8, key9 };

       return is_key(seq,9,remove);

     }


     bool is_key(const unsigned int *const keyseq, const unsigned int N, const bool remove=true) {

       if (keyseq && N) {

         const unsigned int *const ps_end = keyseq+N-1, k = *ps_end, *const pk_end = (unsigned int*)keys+1+512-N;

         for (unsigned int *pk = (unsigned int*)keys; pk<pk_end; ) {

           if (*(pk++)==k) {

             bool res = true;

             const unsigned int *ps = ps_end, *pk2 = pk;

             for (unsigned int i=1; i<N; ++i) res = (*(--ps)==*(pk2++));

             if (res) {

               if (remove) std::memset((void*)(pk-1),0,sizeof(unsigned int)*N);

               return true;

             }

           }

         }

       }

       return false;

     }


     // Update 'is_key' fields.

     void _update_iskey(const unsigned int key, const bool pressed=true) {

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

       _cimg_iskey_case(ESC); _cimg_iskey_case(F1); _cimg_iskey_case(F2); _cimg_iskey_case(F3);

       _cimg_iskey_case(F4); _cimg_iskey_case(F5); _cimg_iskey_case(F6); _cimg_iskey_case(F7);

       _cimg_iskey_case(F8); _cimg_iskey_case(F9); _cimg_iskey_case(F10); _cimg_iskey_case(F11);

       _cimg_iskey_case(F12); _cimg_iskey_case(PAUSE); _cimg_iskey_case(1); _cimg_iskey_case(2);

       _cimg_iskey_case(3); _cimg_iskey_case(4); _cimg_iskey_case(5); _cimg_iskey_case(6);

       _cimg_iskey_case(7); _cimg_iskey_case(8); _cimg_iskey_case(9); _cimg_iskey_case(0);

       _cimg_iskey_case(BACKSPACE); _cimg_iskey_case(INSERT); _cimg_iskey_case(HOME);

       _cimg_iskey_case(PAGEUP); _cimg_iskey_case(TAB); _cimg_iskey_case(Q); _cimg_iskey_case(W);

       _cimg_iskey_case(E); _cimg_iskey_case(R); _cimg_iskey_case(T); _cimg_iskey_case(Y);

       _cimg_iskey_case(U); _cimg_iskey_case(I); _cimg_iskey_case(O); _cimg_iskey_case(P);

       _cimg_iskey_case(DELETE); _cimg_iskey_case(END); _cimg_iskey_case(PAGEDOWN);

       _cimg_iskey_case(CAPSLOCK); _cimg_iskey_case(A); _cimg_iskey_case(S); _cimg_iskey_case(D);

       _cimg_iskey_case(F); _cimg_iskey_case(G); _cimg_iskey_case(H); _cimg_iskey_case(J);

       _cimg_iskey_case(K); _cimg_iskey_case(L); _cimg_iskey_case(ENTER);

       _cimg_iskey_case(SHIFTLEFT); _cimg_iskey_case(Z); _cimg_iskey_case(X); _cimg_iskey_case(C);

       _cimg_iskey_case(V); _cimg_iskey_case(B); _cimg_iskey_case(N); _cimg_iskey_case(M);

       _cimg_iskey_case(SHIFTRIGHT); _cimg_iskey_case(ARROWUP); _cimg_iskey_case(CTRLLEFT);

       _cimg_iskey_case(APPLEFT); _cimg_iskey_case(ALT); _cimg_iskey_case(SPACE); _cimg_iskey_case(ALTGR);

       _cimg_iskey_case(APPRIGHT); _cimg_iskey_case(MENU); _cimg_iskey_case(CTRLRIGHT);

       _cimg_iskey_case(ARROWLEFT); _cimg_iskey_case(ARROWDOWN); _cimg_iskey_case(ARROWRIGHT);

       _cimg_iskey_case(PAD0); _cimg_iskey_case(PAD1); _cimg_iskey_case(PAD2);

       _cimg_iskey_case(PAD3); _cimg_iskey_case(PAD4); _cimg_iskey_case(PAD5);

       _cimg_iskey_case(PAD6); _cimg_iskey_case(PAD7); _cimg_iskey_case(PAD8);

       _cimg_iskey_case(PAD9); _cimg_iskey_case(PADADD); _cimg_iskey_case(PADSUB);

       _cimg_iskey_case(PADMUL); _cimg_iskey_case(PADDIV);

     }


     //------------------------------------------

     //


     //------------------------------------------


     int dimx() const {

       return (int)width;

     }


     int dimy() const {

       return (int)height;

     }


     int window_dimx() const {

       return (int)window_width;

     }


     int window_dimy() const {

       return (int)window_height;

     }


     int window_posx() const {

       return window_x;

     }


     int window_posy() const {

       return window_y;

     }


 #if cimg_display==0


     static int screen_dimx() {

       return 0;

     }


     static int screen_dimy() {

       return 0;

     }


 #endif


     float frames_per_second() {

       if (!fps_timer) fps_timer = cimg::time();

       const float delta = (cimg::time()-fps_timer)/1000.0f;

       ++fps_frames;

       if (delta>=1) {

         fps_fps = fps_frames/delta;

         fps_frames = 0;

         fps_timer = cimg::time();

       }

       return fps_fps;

     }


     //------------------------------------------

     //


     //------------------------------------------


 #if cimg_display==0

     template<typename T>

     CImgDisplay& display(const CImg<T>& img) {

       unsigned int avoid_warning = img.width;

       avoid_warning = 0;

       return *this;

     }

 #endif


     template<typename T>

     CImgDisplay& display(const CImgList<T>& list, const char axis='x', const char align='p') {

       return display(list.get_append(axis,align));

     }


     template<typename T>

     CImgDisplay& resize(const CImg<T>& img, const bool redraw=true) {

       return resize(img.width,img.height,redraw);

     }


     CImgDisplay& resize(const CImgDisplay& disp, const bool redraw=true) {

       return resize(disp.width,disp.height,redraw);

     }


     CImgDisplay& resize(const bool redraw=true) {

       resize(window_width,window_height,redraw);

       return *this;

     }


 #if cimg_display==0


     CImgDisplay& resize(const int width, const int height, const bool redraw=true) {

       int avoid_warning = width | height | (int)redraw;

       avoid_warning = 0;

       return *this;

     }


 #endif


     template<typename t, typename T>

     static void _render_resize(const T *ptrs, const unsigned int ws, const unsigned int hs,

                                t *ptrd, const unsigned int wd, const unsigned int hd) {

       unsigned int *const offx = new unsigned int[wd], *const offy = new unsigned int[hd+1], *poffx, *poffy;

       float s, curr, old;

       s = (float)ws/wd;

       poffx = offx; curr = 0; for (unsigned int x = 0; x<wd; ++x) { old=curr; curr+=s; *(poffx++) = (unsigned int)curr-(unsigned int)old; }

       s = (float)hs/hd;

       poffy = offy; curr = 0; for (unsigned int y = 0; y<hd; ++y) { old=curr; curr+=s; *(poffy++) = ws*((unsigned int)curr-(unsigned int)old); }

       *poffy = 0;

       poffy = offy;

       for (unsigned int y = 0; y<hd; ) {

         const T *ptr = ptrs;

         poffx = offx;

         for (unsigned int x = 0; x<wd; ++x) { *(ptrd++) = *ptr; ptr+=*(poffx++); }

         ++y;

         unsigned int dy=*(poffy++);

         for (;!dy && y<hd; std::memcpy(ptrd, ptrd-wd, sizeof(t)*wd), ++y, ptrd+=wd, dy=*(poffy++)) {}

         ptrs+=dy;

       }

       delete[] offx; delete[] offy;

     }


     CImgDisplay& fullscreen(const bool redraw=true) {

       if (is_empty() || is_fullscreen) return *this;

       return toggle_fullscreen(redraw);

     }


     CImgDisplay& normalscreen(const bool redraw=true) {

       if (is_empty() || !is_fullscreen) return *this;

       return toggle_fullscreen(redraw);

     }


 #if cimg_display==0


     CImgDisplay& toggle_fullscreen(const bool redraw=true) {

       bool avoid_warning = redraw;

       avoid_warning = false;

       return *this;

     }


     CImgDisplay& show() {

       return *this;

     }


     CImgDisplay& close() {

       return *this;

     }


     CImgDisplay& move(const int posx, const int posy) {

       int avoid_warning = posx | posy;

       avoid_warning = 0;

       return *this;

     }


     CImgDisplay& show_mouse() {

       return *this;

     }


     CImgDisplay& hide_mouse() {

       return *this;

     }


     CImgDisplay& set_mouse(const int posx, const int posy) {

       int avoid_warning = posx | posy;

       avoid_warning = 0;

       return *this;

     }


     CImgDisplay& set_title(const char *format, ...) {

       const char *avoid_warning = format;

       avoid_warning = 0;

       return *this;

     }


     template<typename T>

     CImgDisplay& render(const CImg<T>& img) {

       unsigned int avoid_warning = img.width;

       avoid_warning = 0;

       return *this;

     }


     CImgDisplay& paint() {

       return *this;

     }


     template<typename T>

     const CImgDisplay& snapshot(CImg<T>& img) const {

       img.assign(width,height,1,3,0);

       return *this;

     }

 #endif


     CImgDisplay& flush() {

       std::memset((void*)buttons,0,512*sizeof(unsigned int));

       std::memset((void*)keys,0,512*sizeof(unsigned int));

       std::memset((void*)released_keys,0,512*sizeof(unsigned int));

       is_keyESC = is_keyF1 = is_keyF2 = is_keyF3 = is_keyF4 = is_keyF5 = is_keyF6 = is_keyF7 = is_keyF8 = is_keyF9 =

         is_keyF10 = is_keyF11 = is_keyF12 = is_keyPAUSE = is_key1 = is_key2 = is_key3 = is_key4 = is_key5 = is_key6 =

         is_key7 = is_key8 = is_key9 = is_key0 = is_keyBACKSPACE = is_keyINSERT = is_keyHOME = is_keyPAGEUP = is_keyTAB =

         is_keyQ = is_keyW = is_keyE = is_keyR = is_keyT = is_keyY = is_keyU = is_keyI = is_keyO = is_keyP = is_keyDELETE =

         is_keyEND = is_keyPAGEDOWN = is_keyCAPSLOCK = is_keyA = is_keyS = is_keyD = is_keyF = is_keyG = is_keyH = is_keyJ =

         is_keyK = is_keyL = is_keyENTER = is_keySHIFTLEFT = is_keyZ = is_keyX = is_keyC = is_keyV = is_keyB = is_keyN =

         is_keyM = is_keySHIFTRIGHT = is_keyARROWUP = is_keyCTRLLEFT = is_keyAPPLEFT = is_keyALT = is_keySPACE = is_keyALTGR = is_keyAPPRIGHT =

         is_keyMENU = is_keyCTRLRIGHT = is_keyARROWLEFT = is_keyARROWDOWN = is_keyARROWRIGHT = is_keyPAD0 = is_keyPAD1 = is_keyPAD2 =

         is_keyPAD3 = is_keyPAD4 = is_keyPAD5 = is_keyPAD6 = is_keyPAD7 = is_keyPAD8 = is_keyPAD9 = is_keyPADADD = is_keyPADSUB =

         is_keyPADMUL = is_keyPADDIV = false;

       is_resized = is_moved = is_event = false;

       fps_timer = fps_frames = timer = wheel = 0;

       mouse_x = mouse_y = -1;

       fps_fps = 0;

       return *this;

     }


     CImgDisplay& wait(const unsigned int milliseconds) {

       cimg::_sleep(milliseconds,timer);

       return *this;

     }


     CImgDisplay& wait() {

       if (!is_empty()) wait(*this);

       return *this;

     }


     static void wait(CImgDisplay& disp1) {

       disp1.is_event = 0;

       while (!disp1.is_event) wait_all();

     }


     static void wait(CImgDisplay& disp1, CImgDisplay& disp2) {

       disp1.is_event = disp2.is_event = 0;

       while (!disp1.is_event && !disp2.is_event) wait_all();

     }


     static void wait(CImgDisplay& disp1, CImgDisplay& disp2, CImgDisplay& disp3) {

       disp1.is_event = disp2.is_event = disp3.is_event = 0;

       while (!disp1.is_event && !disp2.is_event && !disp3.is_event) wait_all();

     }


     static void wait(CImgDisplay& disp1, CImgDisplay& disp2, CImgDisplay& disp3, CImgDisplay& disp4) {

       disp1.is_event = disp2.is_event = disp3.is_event = disp4.is_event = 0;

       while (!disp1.is_event && !disp2.is_event && !disp3.is_event && !disp4.is_event) wait_all();

     }


 #if cimg_display==0


     static void wait_all() {}


 #endif


     // Implementation for X11-based display

     //--------------------------------------

 #if cimg_display==1

     Atom wm_delete_window, wm_delete_protocol;

     Window window, background_window;

     Colormap colormap;

     XImage *image;

     void *data;

 #ifdef cimg_use_xshm

     XShmSegmentInfo *shminfo;

 #endif


     static int screen_dimx() {

       int res = 0;

       if (!cimg::X11attr().display) {

         Display *disp = XOpenDisplay((std::getenv("DISPLAY")?std::getenv("DISPLAY"):":0.0"));

         if (!disp)

           throw CImgDisplayException("CImgDisplay::screen_dimx() : Cannot open X11 display.");

         res = DisplayWidth(disp,DefaultScreen(disp));

         XCloseDisplay(disp);

       } else {

 #ifdef cimg_use_xrandr

         if (cimg::X11attr().resolutions && cimg::X11attr().curr_resolution)

           res = cimg::X11attr().resolutions[cimg::X11attr().curr_resolution].width;

         else

 #endif

           res = DisplayWidth(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display));

       }

       return res;

     }


     static int screen_dimy() {

       int res = 0;

       if (!cimg::X11attr().display) {

         Display *disp = XOpenDisplay((std::getenv("DISPLAY") ? std::getenv("DISPLAY") : ":0.0"));

         if (!disp)

           throw CImgDisplayException("CImgDisplay::screen_dimy() : Cannot open X11 display.");

         res = DisplayHeight(disp,DefaultScreen(disp));

         XCloseDisplay(disp);

       } else {

 #ifdef cimg_use_xrandr

         if (cimg::X11attr().resolutions && cimg::X11attr().curr_resolution)

           res = cimg::X11attr().resolutions[cimg::X11attr().curr_resolution].height;

         else

 #endif

           res = DisplayHeight(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display));

       }

       return res;

     }


     static void wait_all() {

       if (cimg::X11attr().display) {

         XLockDisplay(cimg::X11attr().display);

         bool flag = true;

         XEvent event;

         while (flag) {

           XNextEvent(cimg::X11attr().display, &event);

           for (unsigned int i = 0; i<cimg::X11attr().nb_wins; ++i)

             if (!cimg::X11attr().wins[i]->is_closed && event.xany.window==cimg::X11attr().wins[i]->window) {

               cimg::X11attr().wins[i]->_handle_events(&event);

               if (cimg::X11attr().wins[i]->is_event) flag = false;

             }

         }

         XUnlockDisplay(cimg::X11attr().display);

       }

     }


     void _handle_events(const XEvent *const pevent) {

       XEvent event = *pevent;

       switch (event.type) {

       case ClientMessage : {

         if ((int)event.xclient.message_type==(int)wm_delete_protocol &&

             (int)event.xclient.data.l[0]==(int)wm_delete_window) {

           XUnmapWindow(cimg::X11attr().display,window);

           mouse_x = mouse_y = -1;

           if (button) { std::memmove((void*)(buttons+1),(void*)buttons,512-1); button = 0; }

           if (key) { std::memmove((void*)(keys+1),(void*)keys,512-1); key = 0; }

           if (released_key) { std::memmove((void*)(released_keys+1),(void*)released_keys,512-1); released_key = 0; }

           is_closed = is_event = true;

         }

       } break;

       case ConfigureNotify : {

         while (XCheckWindowEvent(cimg::X11attr().display,window,StructureNotifyMask,&event)) {}

         const unsigned int

           nw = event.xconfigure.width,

           nh = event.xconfigure.height;

         const int

           nx = event.xconfigure.x,

           ny = event.xconfigure.y;

         if (nw && nh && (nw!=window_width || nh!=window_height)) {

           window_width = nw;

           window_height = nh;

           mouse_x = mouse_y = -1;

           XResizeWindow(cimg::X11attr().display,window,window_width,window_height);

           is_resized = is_event = true;

         }

         if (nx!=window_x || ny!=window_y) {

           window_x = nx;

           window_y = ny;

           is_moved = is_event = true;

         }

       } break;

       case Expose : {

         while (XCheckWindowEvent(cimg::X11attr().display,window,ExposureMask,&event)) {}

         _paint(false);

         if (is_fullscreen) {

           XWindowAttributes attr;

           XGetWindowAttributes(cimg::X11attr().display, window, &attr);

           while (attr.map_state != IsViewable) XSync(cimg::X11attr().display, False);

           XSetInputFocus(cimg::X11attr().display, window, RevertToParent, CurrentTime);

         }

       } break;

       case ButtonPress : {

         do {

         mouse_x = event.xmotion.x;

         mouse_y = event.xmotion.y;

         if (mouse_x<0 || mouse_y<0 || mouse_x>=dimx() || mouse_y>=dimy()) mouse_x = mouse_y = -1;

           switch (event.xbutton.button) {

           case 1 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button|=1; is_event = true; break;

           case 2 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button|=4; is_event = true; break;

           case 3 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button|=2; is_event = true; break;

           }

         } while (XCheckWindowEvent(cimg::X11attr().display,window,ButtonPressMask,&event));

       } break;

       case ButtonRelease : {

         do {

         mouse_x = event.xmotion.x;

         mouse_y = event.xmotion.y;

         if (mouse_x<0 || mouse_y<0 || mouse_x>=dimx() || mouse_y>=dimy()) mouse_x = mouse_y = -1;

           switch (event.xbutton.button) {

           case 1 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button&=~1U; is_event = true; break;

           case 2 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button&=~4U; is_event = true; break;

           case 3 : std::memmove((void*)(buttons+1),(void*)buttons,512-1); button&=~2U; is_event = true; break;

           case 4 : ++wheel; is_event = true; break;

           case 5 : --wheel; is_event = true; break;

           }

         } while (XCheckWindowEvent(cimg::X11attr().display,window,ButtonReleaseMask,&event));

       } break;

       case KeyPress : {

         char tmp;

         KeySym ksym;

         XLookupString(&event.xkey,&tmp,1,&ksym,0);

         _update_iskey((unsigned int)ksym,true);

         if (key) std::memmove((void*)(keys+1),(void*)keys,512-1);

         key = (unsigned int)ksym;

         if (released_key) { std::memmove((void*)(released_keys+1),(void*)released_keys,512-1); released_key = 0; }

         is_event = true;

       } break;

       case KeyRelease : {

         char tmp;

         KeySym ksym;

         XLookupString(&event.xkey,&tmp,1,&ksym,0);

         _update_iskey((unsigned int)ksym,false);

         if (key) { std::memmove((void*)(keys+1),(void*)keys,512-1); key = 0; }

         if (released_key) std::memmove((void*)(released_keys+1),(void*)released_keys,512-1);

         released_key = (unsigned int)ksym;

         is_event = true;

       } break;

       case EnterNotify: {

         while (XCheckWindowEvent(cimg::X11attr().display,window,EnterWindowMask,&event)) {}

         mouse_x = event.xmotion.x;

         mouse_y = event.xmotion.y;

         if (mouse_x<0 || mouse_y<0 || mouse_x>=dimx() || mouse_y>=dimy()) mouse_x = mouse_y = -1;

       } break;

       case LeaveNotify : {

         while (XCheckWindowEvent(cimg::X11attr().display,window,LeaveWindowMask,&event)) {}

         mouse_x = mouse_y =-1;

         is_event = true;

       } break;

       case MotionNotify : {

         while (XCheckWindowEvent(cimg::X11attr().display,window,PointerMotionMask,&event)) {}

         mouse_x = event.xmotion.x;

         mouse_y = event.xmotion.y;

         if (mouse_x<0 || mouse_y<0 || mouse_x>=dimx() || mouse_y>=dimy()) mouse_x = mouse_y = -1;

         is_event = true;

       } break;

       }

     }


     static void* _events_thread(void *arg) {

       arg = 0;

       XEvent event;

       pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,0);

       pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);

       for (;;) {

         XLockDisplay(cimg::X11attr().display);

         bool event_flag = XCheckTypedEvent(cimg::X11attr().display, ClientMessage, &event);

         if (!event_flag) event_flag = XCheckMaskEvent(cimg::X11attr().display,

                                                       ExposureMask|StructureNotifyMask|ButtonPressMask|

                                                       KeyPressMask|PointerMotionMask|EnterWindowMask|LeaveWindowMask|

                                                       ButtonReleaseMask|KeyReleaseMask,&event);

         if (event_flag) {

           for (unsigned int i = 0; i<cimg::X11attr().nb_wins; ++i)

             if (!cimg::X11attr().wins[i]->is_closed && event.xany.window==cimg::X11attr().wins[i]->window)

               cimg::X11attr().wins[i]->_handle_events(&event);

         }

         XUnlockDisplay(cimg::X11attr().display);

         pthread_testcancel();

         cimg::sleep(7);

       }

       return 0;

     }


     void _set_colormap(Colormap& colormap, const unsigned int dim) {

       XColor palette[256];

       switch (dim) {

       case 1 : { // palette for greyscale images

         for (unsigned int index = 0; index<256; ++index) {

           palette[index].pixel = index;

           palette[index].red = palette[index].green = palette[index].blue = (unsigned short)(index<<8);

           palette[index].flags = DoRed | DoGreen | DoBlue;

         }

       } break;

       case 2 : { // palette for RG images

         for (unsigned int index = 0, r = 8; r<256; r+=16)

           for (unsigned int g = 8; g<256; g+=16) {

             palette[index].pixel = index;

             palette[index].red = palette[index].blue = (unsigned short)(r<<8);

             palette[index].green = (unsigned short)(g<<8);

             palette[index++].flags = DoRed | DoGreen | DoBlue;

           }

       } break;

       default : { // palette for RGB images

         for (unsigned int index = 0, r = 16; r<256; r+=32)

           for (unsigned int g = 16; g<256; g+=32)

             for (unsigned int b = 32; b<256; b+=64) {

               palette[index].pixel = index;

               palette[index].red = (unsigned short)(r<<8);

               palette[index].green = (unsigned short)(g<<8);

               palette[index].blue = (unsigned short)(b<<8);

               palette[index++].flags = DoRed | DoGreen | DoBlue;

             }

       }

       }

       XStoreColors(cimg::X11attr().display,colormap,palette,256);

     }


     void _map_window() {

       XWindowAttributes attr;

       XEvent event;

       bool exposed = false, mapped = false;

       XMapRaised(cimg::X11attr().display,window);

       XSync(cimg::X11attr().display,False);

       do {

         XWindowEvent(cimg::X11attr().display,window,StructureNotifyMask | ExposureMask,&event);

         switch (event.type) {

         case MapNotify : mapped = true; break;

         case Expose : exposed = true; break;

         default : XSync(cimg::X11attr().display, False); cimg::sleep(10);

         }

       } while (!(exposed && mapped));

       do {

         XGetWindowAttributes(cimg::X11attr().display, window, &attr);

         if (attr.map_state!=IsViewable) { XSync(cimg::X11attr().display,False); cimg::sleep(10); }

       } while (attr.map_state != IsViewable);

       window_x = attr.x;

       window_y = attr.y;

     }


     void _paint(const bool wait_expose=true) {

       if (!is_closed) {

         if (wait_expose) {

           static XEvent event;

           event.xexpose.type = Expose;

           event.xexpose.serial = 0;

           event.xexpose.send_event = True;

           event.xexpose.display = cimg::X11attr().display;

           event.xexpose.window = window;

           event.xexpose.x = 0;

           event.xexpose.y = 0;

           event.xexpose.width = dimx();

           event.xexpose.height = dimy();

           event.xexpose.count = 0;

           XSendEvent(cimg::X11attr().display, window, False, 0, &event);

         } else {

 #ifdef cimg_use_xshm

           if (shminfo) XShmPutImage(cimg::X11attr().display,window,*cimg::X11attr().gc,image,0,0,0,0,width,height,False);

           else

 #endif

             XPutImage(cimg::X11attr().display,window,*cimg::X11attr().gc,image,0,0,0,0,width,height);

           XSync(cimg::X11attr().display, False);

         }

       }

     }


     template<typename T>

     void _resize(T foo, const unsigned int ndimx, const unsigned int ndimy, const bool redraw) {

       foo = 0;

 #ifdef cimg_use_xshm

       if (shminfo) {

         XShmSegmentInfo *nshminfo = new XShmSegmentInfo;

         XImage *nimage = XShmCreateImage(cimg::X11attr().display,DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                          cimg::X11attr().nb_bits,ZPixmap,0,nshminfo,ndimx,ndimy);

         if (!nimage) {

           delete nshminfo;

           return;

         } else {

           nshminfo->shmid = shmget(IPC_PRIVATE, ndimx*ndimy*sizeof(T), IPC_CREAT | 0777);

           if (nshminfo->shmid==-1) {

             XDestroyImage(nimage);

             delete nshminfo;

             return;

           } else {

             nshminfo->shmaddr = nimage->data = (char*)shmat(nshminfo->shmid,0,0);

             if (nshminfo->shmaddr==(char*)-1) {

               shmctl(nshminfo->shmid,IPC_RMID,0);

               XDestroyImage(nimage);

               delete nshminfo;

               return;

             } else {

               nshminfo->readOnly = False;

               cimg::X11attr().shm_enabled = true;

               XErrorHandler oldXErrorHandler = XSetErrorHandler(_assign_xshm);

               XShmAttach(cimg::X11attr().display, nshminfo);

               XSync(cimg::X11attr().display, False);

               XSetErrorHandler(oldXErrorHandler);

               if (!cimg::X11attr().shm_enabled) {

                 shmdt(nshminfo->shmaddr);

                 shmctl(nshminfo->shmid,IPC_RMID,0);

                 XDestroyImage(nimage);

                 delete nshminfo;

                 return;

               } else {

                 T *const ndata = (T*)nimage->data;

                 if (redraw) _render_resize((T*)data,width,height,ndata,ndimx,ndimy);

                 else std::memset(ndata,0,sizeof(T)*ndimx*ndimy);

                 XShmDetach(cimg::X11attr().display, shminfo);

                 XDestroyImage(image);

                 shmdt(shminfo->shmaddr);

                 shmctl(shminfo->shmid,IPC_RMID,0);

                 delete shminfo;

                 shminfo = nshminfo;

                 image = nimage;

                 data = (void*)ndata;

               }

             }

           }

         }

       } else

 #endif

         {

           T *ndata = (T*)std::malloc(ndimx*ndimy*sizeof(T));

           if (redraw) _render_resize((T*)data,width,height,ndata,ndimx,ndimy);

           else std::memset(ndata,0,sizeof(T)*ndimx*ndimy);

           data = (void*)ndata;

           XDestroyImage(image);

           image = XCreateImage(cimg::X11attr().display,DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                cimg::X11attr().nb_bits,ZPixmap,0,(char*)data,ndimx,ndimy,8,0);

         }

     }


     void _init_fullscreen() {

       background_window = 0;

       if (is_fullscreen && !is_closed) {

 #ifdef cimg_use_xrandr

         int foo;

         if (XRRQueryExtension(cimg::X11attr().display,&foo,&foo)) {

           XRRRotations(cimg::X11attr().display, DefaultScreen(cimg::X11attr().display), &cimg::X11attr().curr_rotation);

           if (!cimg::X11attr().resolutions) {

             cimg::X11attr().resolutions = XRRSizes(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display),&foo);

             cimg::X11attr().nb_resolutions = (unsigned int)foo;

           }

           if (cimg::X11attr().resolutions) {

             cimg::X11attr().curr_resolution = 0;

             for (unsigned int i = 0; i<cimg::X11attr().nb_resolutions; ++i) {

               const unsigned int

                 nw = (unsigned int)(cimg::X11attr().resolutions[i].width),

                 nh = (unsigned int)(cimg::X11attr().resolutions[i].height);

               if (nw>=width && nh>=height &&

                   nw<=(unsigned int)(cimg::X11attr().resolutions[cimg::X11attr().curr_resolution].width) &&

                   nh<=(unsigned int)(cimg::X11attr().resolutions[cimg::X11attr().curr_resolution].height))

                 cimg::X11attr().curr_resolution = i;

             }

             if (cimg::X11attr().curr_resolution>0) {

               XRRScreenConfiguration *config = XRRGetScreenInfo(cimg::X11attr().display, DefaultRootWindow(cimg::X11attr().display));

               XRRSetScreenConfig(cimg::X11attr().display, config, DefaultRootWindow(cimg::X11attr().display),

                                  cimg::X11attr().curr_resolution, cimg::X11attr().curr_rotation, CurrentTime);

               XRRFreeScreenConfigInfo(config);

               XSync(cimg::X11attr().display, False);

             }

           }

         }

         if (!cimg::X11attr().resolutions)

           cimg::warn("CImgDisplay::_create_window() : Xrandr extension is not supported by the X server.");

 #endif

         const unsigned int sx = screen_dimx(), sy = screen_dimy();

         XSetWindowAttributes winattr;

         winattr.override_redirect = True;

         if (sx!=width || sy!=height) {

           background_window = XCreateWindow(cimg::X11attr().display,

                                             RootWindow(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),0,0,

                                             sx,sy,0,0,InputOutput,CopyFromParent,CWOverrideRedirect,&winattr);

           const unsigned int bufsize = sx*sy*(cimg::X11attr().nb_bits==8?1:(cimg::X11attr().nb_bits==16?2:4));

           void *background_data = std::malloc(bufsize);

           std::memset(background_data,0,bufsize);

           XImage *background_image = XCreateImage(cimg::X11attr().display,DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                                   cimg::X11attr().nb_bits,ZPixmap,0,(char*)background_data,sx,sy,8,0);

           XEvent event;

           XSelectInput(cimg::X11attr().display,background_window,StructureNotifyMask);

           XMapRaised(cimg::X11attr().display,background_window);

           do XWindowEvent(cimg::X11attr().display,background_window,StructureNotifyMask,&event);

           while (event.type!=MapNotify);

 #ifdef cimg_use_xshm

           if (shminfo) XShmPutImage(cimg::X11attr().display,background_window,*cimg::X11attr().gc,background_image,0,0,0,0,sx,sy,False);

           else

 #endif

             XPutImage(cimg::X11attr().display,background_window,*cimg::X11attr().gc,background_image,0,0,0,0,sx,sy);

           XWindowAttributes attr;

           XGetWindowAttributes(cimg::X11attr().display, background_window, &attr);

           while (attr.map_state != IsViewable) XSync(cimg::X11attr().display, False);

           XDestroyImage(background_image);

         }

       }

     }


     void _desinit_fullscreen() {

       if (is_fullscreen) {

         XUngrabKeyboard(cimg::X11attr().display,CurrentTime);

 #ifdef cimg_use_xrandr

         if (cimg::X11attr().resolutions && cimg::X11attr().curr_resolution) {

           XRRScreenConfiguration *config = XRRGetScreenInfo(cimg::X11attr().display, DefaultRootWindow(cimg::X11attr().display));

           XRRSetScreenConfig(cimg::X11attr().display, config, DefaultRootWindow(cimg::X11attr().display),

                              0, cimg::X11attr().curr_rotation, CurrentTime);

           XRRFreeScreenConfigInfo(config);

           XSync(cimg::X11attr().display, False);

           cimg::X11attr().curr_resolution = 0;

         }

 #endif

         if (background_window) XDestroyWindow(cimg::X11attr().display,background_window);

         background_window = 0;

         is_fullscreen = false;

       }

     }


     static int _assign_xshm(Display *dpy, XErrorEvent *error) {

       dpy = 0; error = 0;

       cimg::X11attr().shm_enabled = false;

       return 0;

     }


     void _assign(const unsigned int dimw, const unsigned int dimh, const char *const ptitle=0,

                  const unsigned int normalization_type=3,

                  const bool fullscreen_flag=false, const bool closed_flag=false) {


       // Allocate space for window title

       const char *const nptitle = ptitle?ptitle:"";

       const unsigned int s = std::strlen(nptitle) + 1;

       char *tmp_title = s?new char[s]:0;

       if (s) std::memcpy(tmp_title,nptitle,s*sizeof(char));


       // Destroy previous display window if existing

       if (!is_empty()) assign();


       // Open X11 display if necessary.

       if (!cimg::X11attr().display) {

         static bool xinit_threads = false;

         if (!xinit_threads) { XInitThreads(); xinit_threads = true; }

         cimg::X11attr().nb_wins = 0;

         cimg::X11attr().display = XOpenDisplay((std::getenv("DISPLAY")?std::getenv("DISPLAY"):":0.0"));

         if (!cimg::X11attr().display)

           throw CImgDisplayException("CImgDisplay::_create_window() : Cannot open X11 display");

         cimg::X11attr().nb_bits = DefaultDepth(cimg::X11attr().display, DefaultScreen(cimg::X11attr().display));

         if (cimg::X11attr().nb_bits!=8 && cimg::X11attr().nb_bits!=16 && cimg::X11attr().nb_bits!=24 && cimg::X11attr().nb_bits!=32)

           throw CImgDisplayException("CImgDisplay::_create_window() : %u bits mode is not supported "

                                      "(only 8, 16, 24 and 32 bits modes are supported)",cimg::X11attr().nb_bits);

         cimg::X11attr().gc = new GC;

         *cimg::X11attr().gc = DefaultGC(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display));

         Visual *visual = DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display));

         XVisualInfo vtemplate;

         vtemplate.visualid = XVisualIDFromVisual(visual);

         int nb_visuals;

         XVisualInfo *vinfo = XGetVisualInfo(cimg::X11attr().display,VisualIDMask,&vtemplate,&nb_visuals);

         if (vinfo && vinfo->red_mask<vinfo->blue_mask) cimg::X11attr().blue_first = true;

         cimg::X11attr().byte_order = ImageByteOrder(cimg::X11attr().display);

         XFree(vinfo);

         XLockDisplay(cimg::X11attr().display);

         cimg::X11attr().event_thread = new pthread_t;

         pthread_create(cimg::X11attr().event_thread,0,_events_thread,0);

       } else XLockDisplay(cimg::X11attr().display);


       // Set display variables

       width = cimg::min(dimw,(unsigned int)screen_dimx());

       height = cimg::min(dimh,(unsigned int)screen_dimy());

       normalization = normalization_type<4?normalization_type:3;

       is_fullscreen = fullscreen_flag;

       window_x = window_y = 0;

       is_closed = closed_flag;

       title = tmp_title;

       flush();


       // Create X11 window and palette (if 8bits display)

       if (is_fullscreen) {

         if (!is_closed) _init_fullscreen();

         const unsigned int sx = screen_dimx(), sy = screen_dimy();

         XSetWindowAttributes winattr;

         winattr.override_redirect = True;

         window = XCreateWindow(cimg::X11attr().display,

                                RootWindow(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                (sx-width)/2,(sy-height)/2,

                                width,height,0,0,InputOutput,CopyFromParent,CWOverrideRedirect,&winattr);

       } else

         window = XCreateSimpleWindow(cimg::X11attr().display,

                                      RootWindow(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                      0,0,width,height,2,0,0x0L);

       XStoreName(cimg::X11attr().display,window,title?title:" ");

       if (cimg::X11attr().nb_bits==8) {

         colormap = XCreateColormap(cimg::X11attr().display,window,DefaultVisual(cimg::X11attr().display,

                                                                                 DefaultScreen(cimg::X11attr().display)),AllocAll);

         _set_colormap(colormap,3);

         XSetWindowColormap(cimg::X11attr().display,window,colormap);

       }

       window_width = width;

       window_height = height;


       // Create XImage

       const unsigned int bufsize = width*height*(cimg::X11attr().nb_bits==8?1:(cimg::X11attr().nb_bits==16?2:4));

 #ifdef cimg_use_xshm

       shminfo = 0;

       if (XShmQueryExtension(cimg::X11attr().display)) {

         shminfo = new XShmSegmentInfo;

         image = XShmCreateImage(cimg::X11attr().display,DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                 cimg::X11attr().nb_bits,ZPixmap,0,shminfo,width,height);

         if (!image) {

           delete shminfo;

           shminfo = 0;

         } else {

           shminfo->shmid = shmget(IPC_PRIVATE, bufsize, IPC_CREAT | 0777);

           if (shminfo->shmid==-1) {

             XDestroyImage(image);

             delete shminfo;

             shminfo = 0;

           } else {

             shminfo->shmaddr = image->data = (char*)(data = shmat(shminfo->shmid,0,0));

             if (shminfo->shmaddr==(char*)-1) {

               shmctl(shminfo->shmid,IPC_RMID,0);

               XDestroyImage(image);

               delete shminfo;

               shminfo = 0;

             } else {

               shminfo->readOnly = False;

               cimg::X11attr().shm_enabled = true;

               XErrorHandler oldXErrorHandler = XSetErrorHandler(_assign_xshm);

               XShmAttach(cimg::X11attr().display, shminfo);

               XSync(cimg::X11attr().display, False);

               XSetErrorHandler(oldXErrorHandler);

               if (!cimg::X11attr().shm_enabled) {

                 shmdt(shminfo->shmaddr);

                 shmctl(shminfo->shmid,IPC_RMID,0);

                 XDestroyImage(image);

                 delete shminfo;

                 shminfo = 0;

               }

             }

           }

         }

       }

       if (!shminfo)

 #endif

         {

           data = std::malloc(bufsize);

           image = XCreateImage(cimg::X11attr().display,DefaultVisual(cimg::X11attr().display,DefaultScreen(cimg::X11attr().display)),

                                cimg::X11attr().nb_bits,ZPixmap,0,(char*)data,width,height,8,0);

         }


       wm_delete_window = XInternAtom(cimg::X11attr().display, "WM_DELETE_WINDOW", False);

       wm_delete_protocol = XInternAtom(cimg::X11attr().display, "WM_PROTOCOLS", False);

       XSetWMProtocols(cimg::X11attr().display, window, &wm_delete_window, 1);

       XSelectInput(cimg::X11attr().display,window,

                    ExposureMask | StructureNotifyMask | ButtonPressMask | KeyPressMask | PointerMotionMask |

                    EnterWindowMask | LeaveWindowMask | ButtonReleaseMask | KeyReleaseMask);

       if (is_fullscreen) XGrabKeyboard(cimg::X11attr().display, window, True, GrabModeAsync, GrabModeAsync, CurrentTime);

       cimg::X11attr().wins[cimg::X11attr().nb_wins++]=this;

       if (!is_closed) _map_window(); else { window_x = window_y = cimg::type<int>::min(); }

       XUnlockDisplay(cimg::X11attr().display);

     }


     CImgDisplay& assign() {

       if (is_empty()) return *this;

       XLockDisplay(cimg::X11attr().display);


       // Remove display window from event thread list.

       unsigned int i;

       for (i = 0; i<cimg::X11attr().nb_wins && cimg::X11attr().wins[i]!=this; ++i) {}

       for (; i<cimg::X11attr().nb_wins-1; ++i) cimg::X11attr().wins[i] = cimg::X11attr().wins[i+1];

       --cimg::X11attr().nb_wins;


       // Destroy window, image, colormap and title.

       if (is_fullscreen && !is_closed) _desinit_fullscreen();

       XDestroyWindow(cimg::X11attr().display,window);

       window = 0;

 #ifdef cimg_use_xshm

       if (shminfo) {

         XShmDetach(cimg::X11attr().display, shminfo);

         XDestroyImage(image);

         shmdt(shminfo->shmaddr);

         shmctl(shminfo->shmid,IPC_RMID,0);

         delete shminfo;

         shminfo = 0;

       } else

 #endif

         XDestroyImage(image);

       data = 0; image = 0;

       if (cimg::X11attr().nb_bits==8) XFreeColormap(cimg::X11attr().display,colormap);

       colormap = 0;

       XSync(cimg::X11attr().display, False);


       // Reset display variables

       if (title) delete[] title;

       width = height = normalization = window_width = window_height = 0;

       window_x = window_y = 0;

       is_fullscreen = false;

       is_closed = true;

       min = max = 0;

       title = 0;

       flush();


       // End event thread and close display if necessary

       XUnlockDisplay(cimg::X11attr().display);


       /* The code below was used to close the X11 display when not used anymore,

          unfortunately, since the latest Xorg versions, it randomely hangs, so

          I prefer to remove it. A fix would be needed anyway.


          if (!cimg::X11attr().nb_wins) {

          // Kill event thread

          pthread_cancel(*cimg::X11attr().event_thread);

          XUnlockDisplay(cimg::X11attr().display);

          pthread_join(*cimg::X11attr().event_thread,0);

          delete cimg::X11attr().event_thread;

          cimg::X11attr().event_thread = 0;

          XCloseDisplay(cimg::X11attr().display);

          cimg::X11attr().display = 0;

          delete cimg::X11attr().gc;

          cimg::X11attr().gc = 0;

          } else XUnlockDisplay(cimg::X11attr().display);

       */

       return *this;

     }


     CImgDisplay& assign(const unsigned int dimw, const unsigned int dimh, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!dimw || !dimh) return assign();

       _assign(dimw,dimh,title,normalization_type,fullscreen_flag,closed_flag);

       min = max = 0;

       std::memset(data,0,(cimg::X11attr().nb_bits==8?sizeof(unsigned char):

                           (cimg::X11attr().nb_bits==16?sizeof(unsigned short):sizeof(unsigned int)))*width*height);

       return paint();

     }


     template<typename T>

     CImgDisplay& assign(const CImg<T>& img, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!img) return assign();

       CImg<T> tmp;

       const CImg<T>& nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return render(nimg).paint();

     }


     template<typename T>

     CImgDisplay& assign(const CImgList<T>& list, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!list) return assign();

       CImg<T> tmp;

       const CImg<T> img = list>'x', &nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return render(nimg).paint();

     }


     CImgDisplay& assign(const CImgDisplay& disp) {

       if (!disp) return assign();

       _assign(disp.width,disp.height,disp.title,disp.normalization,disp.is_fullscreen,disp.is_closed);

       std::memcpy(data,disp.data,(cimg::X11attr().nb_bits==8?sizeof(unsigned char):

                                   cimg::X11attr().nb_bits==16?sizeof(unsigned short):

                                   sizeof(unsigned int))*width*height);

       return paint();

     }


     CImgDisplay& resize(const int nwidth, const int nheight, const bool redraw=true) {

       if (!nwidth || !nheight || (is_empty() && (nwidth<0 || nheight<0))) return assign();

       if (is_empty()) return assign(nwidth,nheight);

       const unsigned int

         tmpdimx = (nwidth>0)?nwidth:(-nwidth*width/100),

         tmpdimy = (nheight>0)?nheight:(-nheight*height/100),

         dimx = tmpdimx?tmpdimx:1,

         dimy = tmpdimy?tmpdimy:1;

       XLockDisplay(cimg::X11attr().display);

       if (window_width!=dimx || window_height!=dimy) XResizeWindow(cimg::X11attr().display,window,dimx,dimy);

       if (width!=dimx || height!=dimy) switch (cimg::X11attr().nb_bits) {

       case 8 :  { unsigned char foo = 0; _resize(foo,dimx,dimy,redraw); } break;

       case 16 : { unsigned short foo = 0; _resize(foo,dimx,dimy,redraw); } break;

       default : { unsigned int foo = 0; _resize(foo,dimx,dimy,redraw); }

       }

       window_width = width = dimx; window_height = height = dimy;

       is_resized = false;

       XUnlockDisplay(cimg::X11attr().display);

       if (is_fullscreen) move((screen_dimx()-width)/2,(screen_dimy()-height)/2);

       if (redraw) return paint();

       return *this;

     }


     CImgDisplay& toggle_fullscreen(const bool redraw=true) {

       if (is_empty()) return *this;

       if (redraw) {

         const unsigned int bufsize = width*height*(cimg::X11attr().nb_bits==8?1:(cimg::X11attr().nb_bits==16?2:4));

         void *odata = std::malloc(bufsize);

         std::memcpy(odata,data,bufsize);

         assign(width,height,title,normalization,!is_fullscreen,false);

         std::memcpy(data,odata,bufsize);

         std::free(odata);

         return paint(false);

       }

       return assign(width,height,title,normalization,!is_fullscreen,false);

     }


     CImgDisplay& show() {

       if (!is_empty() && is_closed) {

         XLockDisplay(cimg::X11attr().display);

         if (is_fullscreen) _init_fullscreen();

         _map_window();

         is_closed = false;

         XUnlockDisplay(cimg::X11attr().display);

         return paint();

       }

       return *this;

     }


     CImgDisplay& close() {

       if (!is_empty() && !is_closed) {

         XLockDisplay(cimg::X11attr().display);

         if (is_fullscreen) _desinit_fullscreen();

         XUnmapWindow(cimg::X11attr().display,window);

         window_x = window_y = -1;

         is_closed = true;

         XUnlockDisplay(cimg::X11attr().display);

       }

       return *this;

     }


     CImgDisplay& move(const int posx, const int posy) {

       if (is_empty()) return *this;

       show();

       XLockDisplay(cimg::X11attr().display);

       XMoveWindow(cimg::X11attr().display,window,posx,posy);

       window_x = posx; window_y = posy;

       is_moved = false;

       XUnlockDisplay(cimg::X11attr().display);

       return paint();

     }


     CImgDisplay& show_mouse() {

       if (is_empty()) return *this;

       XLockDisplay(cimg::X11attr().display);

       XUndefineCursor(cimg::X11attr().display,window);

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     CImgDisplay& hide_mouse() {

       if (is_empty()) return *this;

       XLockDisplay(cimg::X11attr().display);

       const char pix_data[8] = { 0 };

       XColor col;

       col.red = col.green = col.blue = 0;

       Pixmap pix = XCreateBitmapFromData(cimg::X11attr().display,window,pix_data,8,8);

       Cursor cur = XCreatePixmapCursor(cimg::X11attr().display,pix,pix,&col,&col,0,0);

       XFreePixmap(cimg::X11attr().display,pix);

       XDefineCursor(cimg::X11attr().display,window,cur);

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     CImgDisplay& set_mouse(const int posx, const int posy) {

       if (is_empty() || is_closed) return *this;

       XLockDisplay(cimg::X11attr().display);

       //      XWarpPointer(cimg::X11attr().display,None,window,0,0,0,0,posx,posy);

       XWarpPointer(cimg::X11attr().display,0L,window,0,0,0,0,posx,posy);

       mouse_x = posx; mouse_y = posy;

       is_moved = false;

       XSync(cimg::X11attr().display, False);

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     CImgDisplay& set_title(const char *format, ...) {

       if (is_empty()) return *this;

       char tmp[1024] = { 0 };

       va_list ap;

       va_start(ap, format);

       std::vsprintf(tmp,format,ap);

       va_end(ap);

       if (title) delete[] title;

       const unsigned int s = std::strlen(tmp) + 1;

       title = new char[s];

       std::memcpy(title,tmp,s*sizeof(char));

       XLockDisplay(cimg::X11attr().display);

       XStoreName(cimg::X11attr().display,window,tmp);

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     template<typename T>

     CImgDisplay& display(const CImg<T>& img) {

       if (img.is_empty())

         throw CImgArgumentException("CImgDisplay::display() : Cannot display empty image.");

       if (is_empty()) assign(img.width,img.height);

       return render(img).paint(false);

     }


     CImgDisplay& paint(const bool wait_expose=true) {

       if (is_empty()) return *this;

       XLockDisplay(cimg::X11attr().display);

       _paint(wait_expose);

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     template<typename T>

     CImgDisplay& render(const CImg<T>& img, const bool flag8=false) {

       if (is_empty()) return *this;

       if (!img)

         throw CImgArgumentException("CImgDisplay::_render_image() : Specified input image (%u,%u,%u,%u,%p) is empty.",

                                     img.width,img.height,img.depth,img.dim,img.data);

       if (img.depth!=1) return render(img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       if (cimg::X11attr().nb_bits==8 && (img.width!=width || img.height!=height)) return render(img.get_resize(width,height,1,-100,1));

       if (cimg::X11attr().nb_bits==8 && !flag8 && img.dim==3) {

         typedef typename cimg::last<T,unsigned char>::type uchar;

         static const CImg<uchar> default_palette = CImg<uchar>::default_LUT256();

         return render(img.get_index(default_palette,true,false));

       }


       const T

         *data1 = img.data,

         *data2 = (img.dim>1)?img.ptr(0,0,0,1):data1,

         *data3 = (img.dim>2)?img.ptr(0,0,0,2):data1;


       if (cimg::X11attr().blue_first) cimg::swap(data1,data3);

       XLockDisplay(cimg::X11attr().display);


       if (!normalization || (normalization==3 && cimg::type<T>::string()==cimg::type<unsigned char>::string())) {

         min = max = 0;

         switch (cimg::X11attr().nb_bits) {

         case 8 : { // 256 color palette, no normalization

           _set_colormap(colormap,img.dim);

           unsigned char *const ndata = (img.width==width && img.height==height)?(unsigned char*)data:new unsigned char[img.width*img.height];

           unsigned char *ptrd = (unsigned char*)ndata;

           switch (img.dim) {

           case 1 : for (unsigned int xy = img.width*img.height; xy>0; --xy) (*ptrd++) = (unsigned char)*(data1++);

             break;

           case 2 : for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char R = (unsigned char)*(data1++), G = (unsigned char)*(data2++);

               (*ptrd++) = (R&0xf0) | (G>>4);

             } break;

           default : for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char R = (unsigned char)*(data1++), G = (unsigned char)*(data2++), B = (unsigned char)*(data3++);

               (*ptrd++) = (R&0xe0) | ((G>>5)<<2) | (B>>6);

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned char*)data,width,height); delete[] ndata; }

         } break;

         case 16 : { // 16 bits colors, no normalization

           unsigned short *const ndata = (img.width==width && img.height==height)?(unsigned short*)data:new unsigned short[img.width*img.height];

           unsigned char *ptrd = (unsigned char*)ndata;

           const unsigned int M = 248;

           switch (img.dim) {

           case 1 :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char val = (unsigned char)*(data1++), G = val>>2;

               *(ptrd++) = (val&M) | (G>>3);

               *(ptrd++) = (G<<5) | (G>>1);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char val = (unsigned char)*(data1++), G = val>>2;

               *(ptrd++) = (G<<5) | (G>>1);

               *(ptrd++) = (val&M) | (G>>3);

             }

             break;

           case 2 :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)*(data2++)>>2;

               *(ptrd++) = ((unsigned char)*(data1++)&M) | (G>>3);

               *(ptrd++) = (G<<5);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)*(data2++)>>2;

               *(ptrd++) = (G<<5);

               *(ptrd++) = ((unsigned char)*(data1++)&M) | (G>>3);

             }

             break;

           default :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)*(data2++)>>2;

               *(ptrd++) = ((unsigned char)*(data1++)&M) | (G>>3);

               *(ptrd++) = (G<<5) | ((unsigned char)*(data3++)>>3);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)*(data2++)>>2;

               *(ptrd++) = (G<<5) | ((unsigned char)*(data3++)>>3);

               *(ptrd++) = ((unsigned char)*(data1++)&M) | (G>>3);

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned short*)data,width,height); delete[] ndata; }

         } break;

         default : { // 24 bits colors, no normalization

           unsigned int *const ndata = (img.width==width && img.height==height)?(unsigned int*)data:new unsigned int[img.width*img.height];

           if (sizeof(int)==4) { // 32 bits int uses optimized version

             unsigned int *ptrd = ndata;

             switch (img.dim) {

             case 1 :

               if (cimg::X11attr().byte_order==cimg::endianness())

                 for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                   const unsigned char val = (unsigned char)*(data1++);

                   *(ptrd++) = (val<<16) | (val<<8) | val;

                 }

               else

                for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                   const unsigned char val = (unsigned char)*(data1++)<<8;

                   *(ptrd++) = (val<<16) | (val<<8) | val;

                 }

               break;

             case 2 :

               if (cimg::X11attr().byte_order==cimg::endianness())

                for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) = ((unsigned char)*(data1++)<<16) | ((unsigned char)*(data2++)<<8);

               else

                for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) = ((unsigned char)*(data2++)<<16) | ((unsigned char)*(data1++)<<8);

               break;

             default :

               if (cimg::X11attr().byte_order==cimg::endianness())

                for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) = ((unsigned char)*(data1++)<<16) | ((unsigned char)*(data2++)<<8) | (unsigned char)*(data3++);

               else

                for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) = ((unsigned char)*(data3++)<<24) | ((unsigned char)*(data2++)<<16) | ((unsigned char)*(data1++)<<8);

             }

           } else {

             unsigned char *ptrd = (unsigned char*)ndata;

             switch (img.dim) {

             case 1 :

               if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 *(ptrd++) = 0;

                 *(ptrd++) = (unsigned char)*(data1++);

                 *(ptrd++) = 0;

                 *(ptrd++) = 0;

               } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 *(ptrd++) = 0;

                 *(ptrd++) = 0;

                 *(ptrd++) = (unsigned char)*(data1++);

                 *(ptrd++) = 0;

               }

               break;

             case 2 :

               if (cimg::X11attr().byte_order) cimg::swap(data1,data2);

               for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 *(ptrd++) = 0;

                 *(ptrd++) = (unsigned char)*(data2++);

                 *(ptrd++) = (unsigned char)*(data1++);

                 *(ptrd++) = 0;

               }

               break;

             default :

               if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 *(ptrd++) = 0;

                 *(ptrd++) = (unsigned char)*(data1++);

                 *(ptrd++) = (unsigned char)*(data2++);

                 *(ptrd++) = (unsigned char)*(data3++);

               } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 *(ptrd++) = (unsigned char)*(data3++);

                 *(ptrd++) = (unsigned char)*(data2++);

                 *(ptrd++) = (unsigned char)*(data1++);

                 *(ptrd++) = 0;

               }

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned int*)data,width,height); delete[] ndata; }

         }

         }

       } else {

         if (normalization==3) {

           if (cimg::type<T>::is_float()) min = (float)img.minmax(max);

           else { min = (float)cimg::type<T>::min(); max = (float)cimg::type<T>::max(); }

         } else if ((min>max) || normalization==1) min = (float)img.minmax(max);

         const float delta = max-min, mm = delta?delta:1.0f;

         switch (cimg::X11attr().nb_bits) {

         case 8 : { // 256 color palette, with normalization

           _set_colormap(colormap,img.dim);

           unsigned char *const ndata = (img.width==width && img.height==height)?(unsigned char*)data:new unsigned char[img.width*img.height];

           unsigned char *ptrd = (unsigned char*)ndata;

           switch (img.dim) {

           case 1 : for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char R = (unsigned char)(255*(*(data1++)-min)/mm);

             *(ptrd++) = R;

           } break;

           case 2 : for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char

               R = (unsigned char)(255*(*(data1++)-min)/mm),

               G = (unsigned char)(255*(*(data2++)-min)/mm);

             (*ptrd++) = (R&0xf0) | (G>>4);

           } break;

           default :

             for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char

                 R = (unsigned char)(255*(*(data1++)-min)/mm),

                 G = (unsigned char)(255*(*(data2++)-min)/mm),

                 B = (unsigned char)(255*(*(data3++)-min)/mm);

               *(ptrd++) = (R&0xe0) | ((G>>5)<<2) | (B>>6);

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned char*)data,width,height); delete[] ndata; }

         } break;

         case 16 : { // 16 bits colors, with normalization

           unsigned short *const ndata = (img.width==width && img.height==height)?(unsigned short*)data:new unsigned short[img.width*img.height];

           unsigned char *ptrd = (unsigned char*)ndata;

           const unsigned int M = 248;

           switch (img.dim) {

           case 1 :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm), G = val>>2;

               *(ptrd++) = (val&M) | (G>>3);

               *(ptrd++) = (G<<5) | (val>>3);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm), G = val>>2;

               *(ptrd++) = (G<<5) | (val>>3);

               *(ptrd++) = (val&M) | (G>>3);

             }

             break;

           case 2 :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)(255*(*(data2++)-min)/mm)>>2;

               *(ptrd++) = ((unsigned char)(255*(*(data1++)-min)/mm)&M) | (G>>3);

               *(ptrd++) = (G<<5);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)(255*(*(data2++)-min)/mm)>>2;

               *(ptrd++) = (G<<5);

               *(ptrd++) = ((unsigned char)(255*(*(data1++)-min)/mm)&M) | (G>>3);

             }

             break;

           default :

             if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)(255*(*(data2++)-min)/mm)>>2;

               *(ptrd++) = ((unsigned char)(255*(*(data1++)-min)/mm)&M) | (G>>3);

               *(ptrd++) = (G<<5) | ((unsigned char)(255*(*(data3++)-min)/mm)>>3);

             } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

               const unsigned char G = (unsigned char)(255*(*(data2++)-min)/mm)>>2;

               *(ptrd++) = (G<<5) | ((unsigned char)(255*(*(data3++)-min)/mm)>>3);

               *(ptrd++) = ((unsigned char)(255*(*(data1++)-min)/mm)&M) | (G>>3);

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned short*)data,width,height); delete[] ndata; }

         } break;

         default : { // 24 bits colors, with normalization

           unsigned int *const ndata = (img.width==width && img.height==height)?(unsigned int*)data:new unsigned int[img.width*img.height];

           if (sizeof(int)==4) { // 32 bits int uses optimized version

             unsigned int *ptrd = ndata;

             switch (img.dim) {

             case 1 :

               if (cimg::X11attr().byte_order==cimg::endianness())

                 for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                   const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm);

                   *(ptrd++) = (val<<16) | (val<<8) | val;

                 }

               else

                 for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                   const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm);

                   *(ptrd++) = (val<<24) | (val<<16) | (val<<8);

                 }

               break;

             case 2 :

               if (cimg::X11attr().byte_order==cimg::endianness())

                 for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) =

                     ((unsigned char)(255*(*(data1++)-min)/mm)<<16) |

                     ((unsigned char)(255*(*(data2++)-min)/mm)<<8);

               else

                 for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) =

                     ((unsigned char)(255*(*(data2++)-min)/mm)<<16) |

                     ((unsigned char)(255*(*(data1++)-min)/mm)<<8);

               break;

             default :

               if (cimg::X11attr().byte_order==cimg::endianness())

                 for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) =

                     ((unsigned char)(255*(*(data1++)-min)/mm)<<16) |

                     ((unsigned char)(255*(*(data2++)-min)/mm)<<8) |

                     (unsigned char)(255*(*(data3++)-min)/mm);

               else

                 for (unsigned int xy = img.width*img.height; xy>0; --xy)

                   *(ptrd++) =

                     ((unsigned char)(255*(*(data3++)-min)/mm)<<24) |

                     ((unsigned char)(255*(*(data2++)-min)/mm)<<16) |

                     ((unsigned char)(255*(*(data1++)-min)/mm)<<8);

             }

           } else {

             unsigned char *ptrd = (unsigned char*)ndata;

             switch (img.dim) {

             case 1 :

               if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm);

                 (*ptrd++) = 0;

                 (*ptrd++) = val;

                 (*ptrd++) = val;

                 (*ptrd++) = val;

               } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm);

                 (*ptrd++) = val;

                 (*ptrd++) = val;

                 (*ptrd++) = val;

                 (*ptrd++) = 0;

               }

               break;

             case 2 :

               if (cimg::X11attr().byte_order) cimg::swap(data1,data2);

               for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 (*ptrd++) = 0;

                 (*ptrd++) = (unsigned char)(255*(*(data2++)-min)/mm);

                 (*ptrd++) = (unsigned char)(255*(*(data1++)-min)/mm);

                 (*ptrd++) = 0;

               }

               break;

             default :

               if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 (*ptrd++) = 0;

                 (*ptrd++) = (unsigned char)(255*(*(data1++)-min)/mm);

                 (*ptrd++) = (unsigned char)(255*(*(data2++)-min)/mm);

                 (*ptrd++) = (unsigned char)(255*(*(data3++)-min)/mm);

               } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

                 (*ptrd++) = (unsigned char)(255*(*(data3++)-min)/mm);

                 (*ptrd++) = (unsigned char)(255*(*(data2++)-min)/mm);

                 (*ptrd++) = (unsigned char)(255*(*(data1++)-min)/mm);

                 (*ptrd++) = 0;

               }

             }

           }

           if (ndata!=data) { _render_resize(ndata,img.width,img.height,(unsigned int*)data,width,height); delete[] ndata; }

         }

         }

       }

       XUnlockDisplay(cimg::X11attr().display);

       return *this;

     }


     template<typename T>

     const CImgDisplay& snapshot(CImg<T>& img) const {

       if (is_empty()) img.assign();

       else {

         img.assign(width,height,1,3);

         T

           *data1 = img.ptr(0,0,0,0),

           *data2 = img.ptr(0,0,0,1),

           *data3 = img.ptr(0,0,0,2);

         if (cimg::X11attr().blue_first) cimg::swap(data1,data3);

         switch (cimg::X11attr().nb_bits) {

         case 8 : {

           unsigned char *ptrs = (unsigned char*)data;

           for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char val = *(ptrs++);

             *(data1++) = val&0xe0;

             *(data2++) = (val&0x1c)<<3;

             *(data3++) = val<<6;

           }

         } break;

         case 16 : {

           unsigned char *ptrs = (unsigned char*)data;

           if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char val0 = *(ptrs++), val1 = *(ptrs++);

             *(data1++) = val0&0xf8;

             *(data2++) = (val0<<5) | ((val1&0xe0)>>5);

             *(data3++) = val1<<3;

           } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned short val0 = *(ptrs++), val1 = *(ptrs++);

             *(data1++) = val1&0xf8;

             *(data2++) = (val1<<5) | ((val0&0xe0)>>5);

             *(data3++) = val0<<3;

           }

         } break;

         default : {

           unsigned char *ptrs = (unsigned char*)data;

           if (cimg::X11attr().byte_order) for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             ++ptrs;

             *(data1++) = *(ptrs++);

             *(data2++) = *(ptrs++);

             *(data3++) = *(ptrs++);

           } else for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             *(data3++) = *(ptrs++);

             *(data2++) = *(ptrs++);

             *(data1++) = *(ptrs++);

             ++ptrs;

           }

         }

         }

       }

       return *this;

     }


     // Implementation for Windows-based display

     //-------------------------------------------

 #elif cimg_display==2

     CLIENTCREATESTRUCT ccs;

     BITMAPINFO bmi;

     unsigned int *data;

     DEVMODE curr_mode;

     HWND window;

     HWND background_window;

     HDC hdc;

     HANDLE thread;

     HANDLE created;

     HANDLE mutex;

     bool mouse_tracking;

     bool visible_cursor;


     static int screen_dimx() {

       DEVMODE mode;

       mode.dmSize = sizeof(DEVMODE);

       mode.dmDriverExtra = 0;

       EnumDisplaySettings(0,ENUM_CURRENT_SETTINGS,&mode);

       return mode.dmPelsWidth;

     }


     static int screen_dimy() {

       DEVMODE mode;

       mode.dmSize = sizeof(DEVMODE);

       mode.dmDriverExtra = 0;

       EnumDisplaySettings(0,ENUM_CURRENT_SETTINGS,&mode);

       return mode.dmPelsHeight;

     }


     static void wait_all() {

       WaitForSingleObject(cimg::Win32attr().wait_event,INFINITE);

     }


     static LRESULT APIENTRY _handle_events(HWND window,UINT msg,WPARAM wParam,LPARAM lParam) {

 #ifdef _WIN64

       CImgDisplay* disp = (CImgDisplay*)GetWindowLongPtr(window,GWLP_USERDATA);

 #else

       CImgDisplay* disp = (CImgDisplay*)GetWindowLong(window,GWL_USERDATA);

 #endif

       MSG st_msg;


       switch (msg) {

       case WM_CLOSE :

         disp->mouse_x = disp->mouse_y = -1;

         disp->window_x = disp->window_y = 0;

         if (disp->button) {

           std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

           disp->button = 0;

         }

         if (disp->key) {

           std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1);

           disp->key = 0;

         }

         if (disp->released_key) { std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1); disp->released_key = 0; }

         disp->is_closed = true;

         ReleaseMutex(disp->mutex);

         ShowWindow(disp->window,SW_HIDE);

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         return 0;

       case WM_SIZE : {

         while (PeekMessage(&st_msg,window,WM_SIZE,WM_SIZE,PM_REMOVE)) {}

         WaitForSingleObject(disp->mutex,INFINITE);

         const unsigned int nw = LOWORD(lParam),nh = HIWORD(lParam);

         if (nw && nh && (nw!=disp->width || nh!=disp->height)) {

           disp->window_width = nw;

           disp->window_height = nh;

           disp->mouse_x = disp->mouse_y = -1;

           disp->is_resized = disp->is_event = true;

           SetEvent(cimg::Win32attr().wait_event);

         }

         ReleaseMutex(disp->mutex);

       } break;

       case WM_MOVE : {

         while (PeekMessage(&st_msg,window,WM_SIZE,WM_SIZE,PM_REMOVE)) {}

         WaitForSingleObject(disp->mutex,INFINITE);

         const int nx = (int)(short)(LOWORD(lParam)), ny = (int)(short)(HIWORD(lParam));

         if (nx!=disp->window_x || ny!=disp->window_y) {

           disp->window_x = nx;

           disp->window_y = ny;

           disp->is_moved = disp->is_event = true;

           SetEvent(cimg::Win32attr().wait_event);

         }

         ReleaseMutex(disp->mutex);

       } break;

       case WM_PAINT :

         disp->paint();

         break;

       case WM_KEYDOWN :

         disp->_update_iskey((unsigned int)wParam,true);

         if (disp->key) std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1);

         disp->key = (unsigned int)wParam;

         if (disp->released_key) { std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1); disp->released_key = 0; }

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_MOUSEMOVE : {

         while (PeekMessage(&st_msg,window,WM_MOUSEMOVE,WM_MOUSEMOVE,PM_REMOVE)) {}

         disp->mouse_x = LOWORD(lParam);

         disp->mouse_y = HIWORD(lParam);

 #if (_WIN32_WINNT>=0x0400) && !defined(NOTRACKMOUSEEVENT)

         if (!disp->mouse_tracking) {

           TRACKMOUSEEVENT tme;

           tme.cbSize = sizeof(TRACKMOUSEEVENT);

           tme.dwFlags = TME_LEAVE;

           tme.hwndTrack = disp->window;

           if (TrackMouseEvent(&tme)) disp->mouse_tracking = true;

         }

 #endif

         if (disp->mouse_x<0 || disp->mouse_y<0 || disp->mouse_x>=disp->dimx() || disp->mouse_y>=disp->dimy())

           disp->mouse_x = disp->mouse_y = -1;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

       } break;

       case WM_MOUSELEAVE : {

         disp->mouse_x = disp->mouse_y = -1;

         disp->mouse_tracking = false;

       } break;

       case WM_LBUTTONDOWN :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button|=1U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_RBUTTONDOWN :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button|=2U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_MBUTTONDOWN :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button|=4U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case 0x020A : // WM_MOUSEWHEEL:

         disp->wheel+=(int)((short)HIWORD(wParam))/120;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

       case WM_KEYUP :

         disp->_update_iskey((unsigned int)wParam,false);

         if (disp->key) { std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1); disp->key = 0; }

         if (disp->released_key) std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1);

         disp->released_key = (unsigned int)wParam;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_LBUTTONUP :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button&=~1U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_RBUTTONUP :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button&=~2U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_MBUTTONUP :

         std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

         disp->button&=~4U;

         disp->is_event = true;

         SetEvent(cimg::Win32attr().wait_event);

         break;

       case WM_SETCURSOR :

         if (disp->visible_cursor) ShowCursor(TRUE);

         else ShowCursor(FALSE);

         break;

       }

       return DefWindowProc(window,msg,wParam,lParam);

     }


     static DWORD WINAPI _events_thread(void* arg) {

       CImgDisplay *disp = (CImgDisplay*)(((void**)arg)[0]);

       const char *title = (const char*)(((void**)arg)[1]);

       MSG msg;

       delete[] (void**)arg;

       disp->bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

       disp->bmi.bmiHeader.biWidth = disp->width;

       disp->bmi.bmiHeader.biHeight = -(int)disp->height;

       disp->bmi.bmiHeader.biPlanes = 1;

       disp->bmi.bmiHeader.biBitCount = 32;

       disp->bmi.bmiHeader.biCompression = BI_RGB;

       disp->bmi.bmiHeader.biSizeImage = 0;

       disp->bmi.bmiHeader.biXPelsPerMeter = 1;

       disp->bmi.bmiHeader.biYPelsPerMeter = 1;

       disp->bmi.bmiHeader.biClrUsed = 0;

       disp->bmi.bmiHeader.biClrImportant = 0;

       disp->data = new unsigned int[disp->width*disp->height];

       if (!disp->is_fullscreen) { // Normal window

         RECT rect;

         rect.left = rect.top = 0; rect.right = disp->width-1; rect.bottom = disp->height-1;

         AdjustWindowRect(&rect,WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,false);

         const int border1 = (rect.right-rect.left+1-disp->width)/2, border2 = rect.bottom-rect.top+1-disp->height-border1;

         disp->window = CreateWindowA("MDICLIENT",title?title:" ",

                                      WS_OVERLAPPEDWINDOW | (disp->is_closed?0:WS_VISIBLE), CW_USEDEFAULT,CW_USEDEFAULT,

                                      disp->width + 2*border1, disp->height + border1 + border2,

                                      0,0,0,&(disp->ccs));

         if (!disp->is_closed) {

           GetWindowRect(disp->window,&rect);

           disp->window_x = rect.left + border1;

           disp->window_y = rect.top + border2;

         } else disp->window_x = disp->window_y = 0;

       } else { // Fullscreen window

         const unsigned int sx = screen_dimx(), sy = screen_dimy();

         disp->window = CreateWindowA("MDICLIENT",title?title:" ",

                                      WS_POPUP | (disp->is_closed?0:WS_VISIBLE), (sx-disp->width)/2, (sy-disp->height)/2,

                                      disp->width,disp->height,0,0,0,&(disp->ccs));

         disp->window_x = disp->window_y = 0;

       }

       SetForegroundWindow(disp->window);

       disp->hdc = GetDC(disp->window);

       disp->window_width = disp->width;

       disp->window_height = disp->height;

       disp->flush();

 #ifdef _WIN64

       SetWindowLongPtr(disp->window,GWLP_USERDATA,(LONG_PTR)disp);

       SetWindowLongPtr(disp->window,GWLP_WNDPROC,(LONG_PTR)_handle_events);

 #else

       SetWindowLong(disp->window,GWL_USERDATA,(LONG)disp);

       SetWindowLong(disp->window,GWL_WNDPROC,(LONG)_handle_events);

 #endif

       SetEvent(disp->created);

       while (GetMessage(&msg,0,0,0)) DispatchMessage(&msg);

       return 0;

     }


     CImgDisplay& _update_window_pos() {

       if (!is_closed) {

         RECT rect;

         rect.left = rect.top = 0; rect.right = width-1; rect.bottom = height-1;

         AdjustWindowRect(&rect,WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,false);

         const int border1 = (rect.right-rect.left+1-width)/2, border2 = rect.bottom-rect.top+1-height-border1;

         GetWindowRect(window,&rect);

         window_x = rect.left + border1;

         window_y = rect.top + border2;

       } else window_x = window_y = -1;

       return *this;

     }


     void _init_fullscreen() {

       background_window = 0;

       if (is_fullscreen && !is_closed) {

         DEVMODE mode;

         unsigned int imode = 0, ibest = 0, bestbpp = 0, bw = ~0U, bh = ~0U;

         for (mode.dmSize = sizeof(DEVMODE), mode.dmDriverExtra = 0; EnumDisplaySettings(0,imode,&mode); ++imode) {

           const unsigned int nw = mode.dmPelsWidth, nh = mode.dmPelsHeight;

           if (nw>=width && nh>=height && mode.dmBitsPerPel>=bestbpp && nw<=bw && nh<=bh) {

             bestbpp = mode.dmBitsPerPel;

             ibest = imode;

             bw = nw; bh = nh;

           }

         }

         if (bestbpp) {

           curr_mode.dmSize = sizeof(DEVMODE); curr_mode.dmDriverExtra = 0;

           EnumDisplaySettings(0,ENUM_CURRENT_SETTINGS,&curr_mode);

           EnumDisplaySettings(0,ibest,&mode);

           ChangeDisplaySettings(&mode,0);

         } else curr_mode.dmSize = 0;


         const unsigned int sx = screen_dimx(), sy = screen_dimy();

         if (sx!=width || sy!=height) {

           CLIENTCREATESTRUCT background_ccs;

           background_window = CreateWindowA("MDICLIENT","",WS_POPUP | WS_VISIBLE, 0,0,sx,sy,0,0,0,&background_ccs);

           SetForegroundWindow(background_window);

         }

       } else curr_mode.dmSize = 0;

     }


     void _desinit_fullscreen() {

       if (is_fullscreen) {

         if (background_window) DestroyWindow(background_window);

         background_window = 0;

         if (curr_mode.dmSize) ChangeDisplaySettings(&curr_mode,0);

         is_fullscreen = false;

       }

     }


     CImgDisplay& _assign(const unsigned int dimw, const unsigned int dimh, const char *const ptitle=0,

                          const unsigned int normalization_type=3,

                          const bool fullscreen_flag=false, const bool closed_flag=false) {


       // Allocate space for window title

       const char *const nptitle = ptitle?ptitle:"";

       const unsigned int s = std::strlen(nptitle) + 1;

       char *tmp_title = s?new char[s]:0;

       if (s) std::memcpy(tmp_title,nptitle,s*sizeof(char));


       // Destroy previous window if existing

       if (!is_empty()) assign();


       // Set display variables

       width = cimg::min(dimw,(unsigned int)screen_dimx());

       height = cimg::min(dimh,(unsigned int)screen_dimy());

       normalization = normalization_type<4?normalization_type:3;

       is_fullscreen = fullscreen_flag;

       window_x = window_y = 0;

       is_closed = closed_flag;

       visible_cursor = true;

       mouse_tracking = false;

       title = tmp_title;

       flush();

       if (is_fullscreen) _init_fullscreen();


       // Create event thread

       void *arg = (void*)(new void*[2]);

       ((void**)arg)[0]=(void*)this;

       ((void**)arg)[1]=(void*)title;

       unsigned long ThreadID = 0;

       mutex = CreateMutex(0,FALSE,0);

       created = CreateEvent(0,FALSE,FALSE,0);

       thread = CreateThread(0,0,_events_thread,arg,0,&ThreadID);

       WaitForSingleObject(created,INFINITE);

       return *this;

     }


     CImgDisplay& assign() {

       if (is_empty()) return *this;

       DestroyWindow(window);

       TerminateThread(thread,0);

       if (data) delete[] data;

       if (title) delete[] title;

       if (is_fullscreen) _desinit_fullscreen();

       width = height = normalization = window_width = window_height = 0;

       window_x = window_y = 0;

       is_fullscreen = false;

       is_closed = true;

       min = max = 0;

       title = 0;

       flush();

       return *this;

     }


     CImgDisplay& assign(const unsigned int dimw, const unsigned int dimh, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!dimw || !dimh) return assign();

       _assign(dimw,dimh,title,normalization_type,fullscreen_flag,closed_flag);

       min = max = 0;

       std::memset(data,0,sizeof(unsigned int)*width*height);

       return paint();

     }


     template<typename T>

     CImgDisplay& assign(const CImg<T>& img, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!img) return assign();

       CImg<T> tmp;

       const CImg<T>& nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return display(nimg);

     }


     template<typename T>

     CImgDisplay& assign(const CImgList<T>& list, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!list) return assign();

       CImg<T> tmp;

       const CImg<T> img = list>'x', &nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return display(nimg);

     }


     CImgDisplay& assign(const CImgDisplay& disp) {

       if (!disp) return assign();

       _assign(disp.width,disp.height,disp.title,disp.normalization,disp.is_fullscreen,disp.is_closed);

       std::memcpy(data,disp.data,sizeof(unsigned int)*width*height);

       return paint();

     }


     CImgDisplay& resize(const int nwidth, const int nheight, const bool redraw=true) {

       if (!nwidth || !nheight || (is_empty() && (nwidth<0 || nheight<0))) return assign();

       if (is_empty()) return assign(nwidth,nheight);

       const unsigned int

         tmpdimx=(nwidth>0)?nwidth:(-nwidth*width/100),

         tmpdimy=(nheight>0)?nheight:(-nheight*height/100),

         dimx = tmpdimx?tmpdimx:1,

         dimy = tmpdimy?tmpdimy:1;

       if (window_width!=dimx || window_height!=dimy) {

         RECT rect; rect.left = rect.top = 0; rect.right = dimx-1; rect.bottom = dimy-1;

         AdjustWindowRect(&rect,WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,false);

         const int cwidth = rect.right-rect.left+1, cheight = rect.bottom-rect.top+1;

         SetWindowPos(window,0,0,0,cwidth,cheight,SWP_NOMOVE | SWP_NOZORDER | SWP_NOCOPYBITS);

       }

       if (width!=dimx || height!=dimy) {

         unsigned int *ndata = new unsigned int[dimx*dimy];

         if (redraw) _render_resize(data,width,height,ndata,dimx,dimy);

         else std::memset(ndata,0x80,sizeof(unsigned int)*dimx*dimy);

         delete[] data;

         data = ndata;

         bmi.bmiHeader.biWidth = dimx;

         bmi.bmiHeader.biHeight = -(int)dimy;

         width = dimx;

         height = dimy;

       }

       window_width = dimx; window_height = dimy;

       is_resized = false;

       if (is_fullscreen) move((screen_dimx()-width)/2,(screen_dimy()-height)/2);

       if (redraw) return paint();

       return *this;

     }


     CImgDisplay& toggle_fullscreen(const bool redraw=true) {

       if (is_empty()) return *this;

       if (redraw) {

         const unsigned int bufsize = width*height*4;

         void *odata = std::malloc(bufsize);

         std::memcpy(odata,data,bufsize);

         assign(width,height,title,normalization,!is_fullscreen,false);

         std::memcpy(data,odata,bufsize);

         std::free(odata);

         return paint();

       }

       return assign(width,height,title,normalization,!is_fullscreen,false);

     }


     CImgDisplay& show() {

       if (is_empty()) return *this;

       if (is_closed) {

         is_closed = false;

         if (is_fullscreen) _init_fullscreen();

         ShowWindow(window,SW_SHOW);

         _update_window_pos();

       }

       return paint();

     }


     CImgDisplay& close() {

       if (is_empty()) return *this;

       if (!is_closed && !is_fullscreen) {

         if (is_fullscreen) _desinit_fullscreen();

         ShowWindow(window,SW_HIDE);

         is_closed = true;

         window_x = window_y = 0;

       }

       return *this;

     }


     CImgDisplay& move(const int posx, const int posy) {

       if (is_empty()) return *this;

       if (!is_fullscreen) {

         RECT rect; rect.left = rect.top = 0; rect.right=window_width-1; rect.bottom=window_height-1;

         AdjustWindowRect(&rect,WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,false);

         const int border1 = (rect.right-rect.left+1-width)/2, border2 = rect.bottom-rect.top+1-height-border1;

         SetWindowPos(window,0,posx-border1,posy-border2,0,0,SWP_NOSIZE | SWP_NOZORDER);

       } else SetWindowPos(window,0,posx,posy,0,0,SWP_NOSIZE | SWP_NOZORDER);

       window_x = posx;

       window_y = posy;

       is_moved = false;

       return show();

     }


     CImgDisplay& show_mouse() {

       if (is_empty()) return *this;

       visible_cursor = true;

       ShowCursor(TRUE);

       SendMessage(window,WM_SETCURSOR,0,0);

       return *this;

     }


     CImgDisplay& hide_mouse() {

       if (is_empty()) return *this;

       visible_cursor = false;

       ShowCursor(FALSE);

       SendMessage(window,WM_SETCURSOR,0,0);

       return *this;

     }


     CImgDisplay& set_mouse(const int posx, const int posy) {

       if (!is_closed && posx>=0 && posy>=0) {

         _update_window_pos();

         const int res = (int)SetCursorPos(window_x+posx,window_y+posy);

         if (res) { mouse_x = posx; mouse_y = posy; }

       }

       return *this;

     }


     CImgDisplay& set_title(const char *format, ...) {

       if (is_empty()) return *this;

       char tmp[1024] = { 0 };

       va_list ap;

       va_start(ap, format);

       std::vsprintf(tmp,format,ap);

       va_end(ap);

       if (title) delete[] title;

       const unsigned int s = std::strlen(tmp) + 1;

       title = new char[s];

       std::memcpy(title,tmp,s*sizeof(char));

       SetWindowTextA(window, tmp);

       return *this;

     }


     template<typename T>

     CImgDisplay& display(const CImg<T>& img) {

       if (img.is_empty())

         throw CImgArgumentException("CImgDisplay::display() : Cannot display empty image.");

       if (is_empty()) assign(img.width,img.height);

       return render(img).paint();

     }


     CImgDisplay& paint() {

       if (!is_closed) {

         WaitForSingleObject(mutex,INFINITE);

         SetDIBitsToDevice(hdc,0,0,width,height,0,0,0,height,data,&bmi,DIB_RGB_COLORS);

         ReleaseMutex(mutex);

       }

       return *this;

     }


     template<typename T>

     CImgDisplay& render(const CImg<T>& img) {

       if (is_empty()) return *this;

       if (!img)

         throw CImgArgumentException("CImgDisplay::_render_image() : Specified input image (%u,%u,%u,%u,%p) is empty.",

                                     img.width,img.height,img.depth,img.dim,img.data);

       if (img.depth!=1) return render(img.get_projections2d(img.width/2,img.height/2,img.depth/2));


       const T

         *data1 = img.data,

         *data2 = (img.dim>=2)?img.ptr(0,0,0,1):data1,

         *data3 = (img.dim>=3)?img.ptr(0,0,0,2):data1;


       WaitForSingleObject(mutex,INFINITE);

       unsigned int

         *const ndata = (img.width==width && img.height==height)?data:new unsigned int[img.width*img.height],

         *ptrd = ndata;


       if (!normalization || (normalization==3 && cimg::type<T>::string()==cimg::type<unsigned char>::string())) {

         min = max = 0;

         switch (img.dim) {

         case 1 : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char val = (unsigned char)*(data1++);

             *(ptrd++) = (val<<16) | (val<<8) | val;

           }} break;

         case 2 : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy)

             *(ptrd++) = ((unsigned char)*(data1++)<<16) | ((unsigned char)*(data2++)<<8);

         } break;

         default : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy)

             *(ptrd++) = ((unsigned char)*(data1++)<<16) | ((unsigned char)*(data2++)<<8) | (unsigned char)*(data3++);

         }

         }

       } else {

         if (normalization==3) {

           if (cimg::type<T>::is_float()) min = (float)img.minmax(max);

           else { min = (float)cimg::type<T>::min(); max = (float)cimg::type<T>::max(); }

         } else if ((min>max) || normalization==1) min = (float)img.minmax(max);

         const float delta = max-min, mm = delta?delta:1.0f;

         switch (img.dim) {

         case 1 : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char val = (unsigned char)(255*(*(data1++)-min)/mm);

             *(ptrd++) = (val<<16) | (val<<8) | val;

           }} break;

         case 2 : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char

               R = (unsigned char)(255*(*(data1++)-min)/mm),

               G = (unsigned char)(255*(*(data2++)-min)/mm);

             *(ptrd++) = (R<<16) | (G<<8);

           }} break;

         default : {

           for (unsigned int xy = img.width*img.height; xy>0; --xy) {

             const unsigned char

               R = (unsigned char)(255*(*(data1++)-min)/mm),

               G = (unsigned char)(255*(*(data2++)-min)/mm),

               B = (unsigned char)(255*(*(data3++)-min)/mm);

             *(ptrd++) = (R<<16) | (G<<8) | B;

           }}

         }

       }

       if (ndata!=data) { _render_resize(ndata,img.width,img.height,data,width,height); delete[] ndata; }

       ReleaseMutex(mutex);

       return *this;

     }


     template<typename T>

     const CImgDisplay& snapshot(CImg<T>& img) const {

       if (is_empty()) img.assign();

       else {

         img.assign(width,height,1,3);

         T

           *data1 = img.ptr(0,0,0,0),

           *data2 = img.ptr(0,0,0,1),

           *data3 = img.ptr(0,0,0,2);

         unsigned int *ptrs = data;

          for (unsigned int xy = img.width*img.height; xy>0; --xy) {

           const unsigned int val = *(ptrs++);

           *(data1++) = (unsigned char)(val>>16);

           *(data2++) = (unsigned char)((val>>8)&0xFF);

           *(data3++) = (unsigned char)(val&0xFF);

         }

       }

       return *this;

     }


     // Implementation for MacOSX/Carbon-based display

     //------------------------------------------------

 #elif cimg_display==3

     unsigned int *data;                     // The bits of the picture

     WindowRef carbonWindow;                 // The opaque carbon window struct associated with the display

     MPCriticalRegionID paintCriticalRegion; // Critical section used when drawing

     CGColorSpaceRef csr;                    // Needed for painting

     CGDataProviderRef dataProvider;         // Needed for painting

     CGImageRef imageRef;                    // The image

     UInt32 lastKeyModifiers;                // Buffer storing modifiers state


     // Define the kind of the queries which can be serialized using the event thread.

     typedef enum {

       COM_CREATEWINDOW = 0, // Create window query

       COM_RELEASEWINDOW,    // Release window query

       COM_SHOWWINDOW,       // Show window query

       COM_HIDEWINDOW,       // Hide window query

       COM_SHOWMOUSE,        // Show mouse query

       COM_HIDEMOUSE,        // Hide mouse query

       COM_RESIZEWINDOW,     // Resize window query

       COM_MOVEWINDOW,       // Move window query

       COM_SETTITLE,         // Set window title query

       COM_SETMOUSEPOS       // Set cursor position query

     } CImgCarbonQueryKind;


     // The query destructor send to the event thread.

     struct CbSerializedQuery {

       CImgDisplay* sender;         // Query's sender

       CImgCarbonQueryKind kind;    // The kind of the query sent to the background thread

       short x, y;                  // X:Y values for move/resize operations

       char *c;                     // Char values for window title

       bool createFullScreenWindow; // Boolean value used for full-screen window creation

       bool createClosedWindow;     // Boolean value used for closed-window creation

       bool update;                 // Boolean value used for resize

       bool success;                // Succes or failure of the message, used as return value

       CbSerializedQuery(CImgDisplay *s, CImgCarbonQueryKind k):sender(s),kind(k),success(false) {}


       inline static CbSerializedQuery BuildReleaseWindowQuery(CImgDisplay* sender) {

         return CbSerializedQuery(sender, COM_RELEASEWINDOW);

       }

       inline static CbSerializedQuery BuildCreateWindowQuery(CImgDisplay* sender, const bool fullscreen, const bool closed) {

         CbSerializedQuery q(sender, COM_CREATEWINDOW);

         q.createFullScreenWindow = fullscreen;

         q.createClosedWindow = closed;

         return q;

       }

       inline static CbSerializedQuery BuildShowWindowQuery(CImgDisplay* sender) {

         return CbSerializedQuery(sender, COM_SHOWWINDOW);

       }

       inline static CbSerializedQuery BuildHideWindowQuery(CImgDisplay* sender) {

         return CbSerializedQuery(sender, COM_HIDEWINDOW);

       }

       inline static CbSerializedQuery BuildShowMouseQuery(CImgDisplay* sender) {

         return CbSerializedQuery(sender, COM_SHOWMOUSE);

       }

       inline static CbSerializedQuery BuildHideMouseQuery(CImgDisplay* sender) {

         return CbSerializedQuery(sender, COM_HIDEMOUSE);

       }

       inline static CbSerializedQuery BuildResizeWindowQuery(CImgDisplay* sender, const int x, const int y, bool update) {

         CbSerializedQuery q(sender, COM_RESIZEWINDOW);

         q.x = x, q.y = y;

         q.update = update;

         return q;

       }

       inline static CbSerializedQuery BuildMoveWindowQuery(CImgDisplay* sender, const int x, const int y) {

         CbSerializedQuery q(sender, COM_MOVEWINDOW);

         q.x = x, q.y = y;

         return q;

       }

       inline static CbSerializedQuery BuildSetWindowTitleQuery(CImgDisplay* sender, char* c) {

         CbSerializedQuery q(sender, COM_SETTITLE);

         q.c = c;

         return q;

       }

       inline static CbSerializedQuery BuildSetWindowPosQuery(CImgDisplay* sender, const int x, const int y) {

         CbSerializedQuery q(sender, COM_SETMOUSEPOS);

         q.x = x, q.y = y;

         return q;

       }

     };


     // Send a serialized query in a synchroneous way.

     // @param c Application Carbon global settings.

     // @param m The query to send.

     // @result Success/failure of the operation returned by the event thread.

     bool _CbSendMsg(cimg::CarbonInfo& c, CbSerializedQuery m) {

       MPNotifyQueue(c.com_queue,&m,0,0); // Send the given message

       MPWaitOnSemaphore(c.sync_event,kDurationForever); // Wait end of processing notification

       return m.success;

     }


     // Free the window attached to the current display.

     // @param c Application Carbon global settings.

     // @result Success/failure of the operation.

     bool _CbFreeAttachedWindow(cimg::CarbonInfo& c) {

       if (!_CbSendMsg(c, CbSerializedQuery::BuildReleaseWindowQuery(this))) // Ask the main thread to free the given window

         throw CImgDisplayException("Cannot release window associated with the current display.");

       // If a window existed, ask to release it

       MPEnterCriticalRegion(c.windowListCR,kDurationForever); // Lock the list of the windows

       --c.windowCount; //Decrement the window count

       MPExitCriticalRegion(c.windowListCR); // Unlock the list

       return c.windowCount == 0;

     }


     // Create the window attached to the current display.

     // @param c Application Carbon global settings.

     // @param title The window title, if any.

     // @param fullscreen Shoud we start in fullscreen mode ?

     // @param create_closed If true, the window is created but not displayed.

     // @result Success/failure of the operation.

     void _CbCreateAttachedWindow(cimg::CarbonInfo& c, const char* title, const bool fullscreen, const bool create_closed) {

       if (!_CbSendMsg(c,CbSerializedQuery::BuildCreateWindowQuery(this,fullscreen,create_closed))) // Ask the main thread to create the window

         throw CImgDisplayException("Cannot create the window associated with the current display.");

       if (title) set_title(title); // Set the title, if any

       // Now we can register the window

       MPEnterCriticalRegion(c.windowListCR,kDurationForever); // Lock the list of the windows

       ++c.windowCount; //Increment the window count

       MPExitCriticalRegion(c.windowListCR); // Unlock the list

     }


     // Destroy graphic objects previously allocated. We free the image, the data provider, then the colorspace.

     void _CbFinalizeGraphics() {

       CGImageRelease (imageRef); // Release the picture

       CGDataProviderRelease(dataProvider); // Release the DP

       CGColorSpaceRelease(csr); // Free the cs

     }


     // Create graphic objects associated to a display. We have to create a colormap, a data provider, and the image.

     void _CbInitializeGraphics() {

       csr = CGColorSpaceCreateDeviceRGB(); // Create the color space first

       if (!csr)

         throw CImgDisplayException("CGColorSpaceCreateDeviceRGB() failed.");

       // Create the DP

       dataProvider = CGDataProviderCreateWithData(0,data,height*width*sizeof(unsigned int),0);

       if (!dataProvider)

         throw CImgDisplayException("CGDataProviderCreateWithData() failed.");

       // ... and finally the image.

       if (cimg::endianness())

         imageRef = CGImageCreate(width,height,8,32,width*sizeof(unsigned int),csr,

                                  kCGImageAlphaNoneSkipFirst,dataProvider,0,false,kCGRenderingIntentDefault);

       else

         imageRef = CGImageCreate(width,height,8,32,width*sizeof(unsigned int),csr,

                                  kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,dataProvider,0,false,kCGRenderingIntentDefault);

       if (!imageRef)

         throw CImgDisplayException("CGImageCreate() failed.");

     }


     // Reinit graphic objects. Free them, then reallocate all.

     // This is used when image bounds are changed or when data source get invalid.

     void _CbReinitGraphics() {

       MPEnterCriticalRegion(paintCriticalRegion, kDurationForever);

       _CbFinalizeGraphics();

       _CbInitializeGraphics();

       MPExitCriticalRegion(paintCriticalRegion);

     }


     // Convert a point having global coordonates into the window coordonates.

     // We use this function to replace the deprecated GlobalToLocal QuickDraw API.

     // @param mouseEvent The mouse event which triggered the event handler.

     // @param window The window where the event occured.

     // @param point The modified point struct.

     // @result True if the point struct has been converted successfully.

     static bool _CbToLocalPointFromMouseEvent(EventRef mouseEvent, WindowRef window, HIPoint* point) {

       Rect bounds;

       if (GetWindowBounds(window,kWindowStructureRgn,&bounds)==noErr) {

         point->x -= bounds.left;

         point->y -= bounds.top;

         HIViewRef view = NULL;

         if (HIViewGetViewForMouseEvent(HIViewGetRoot(window),mouseEvent,&view)==noErr)

           return HIViewConvertPoint(point, NULL, view) == noErr;

       }

       return false;

     }


     static int screen_dimx() {

       return CGDisplayPixelsWide(kCGDirectMainDisplay);

     }


     static int screen_dimy() {

       return CGDisplayPixelsHigh(kCGDirectMainDisplay);

     }


     CImgDisplay& assign(const unsigned int dimw, const unsigned int dimh, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!dimw || !dimh) return assign();

       _assign(dimw,dimh,title,normalization_type,fullscreen_flag,closed_flag);

       min = max = 0;

       std::memset(data,0,sizeof(unsigned int)*width*height);

       return paint();

     }


     template<typename T>

     CImgDisplay& assign(const CImg<T>& img, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!img) return assign();

       CImg<T> tmp;

       const CImg<T>& nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return display(nimg);

     }


     template<typename T>

     CImgDisplay& assign(const CImgList<T>& list, const char *title=0,

                         const unsigned int normalization_type=3,

                         const bool fullscreen_flag=false, const bool closed_flag=false) {

       if (!list) return assign();

       CImg<T> tmp;

       const CImg<T> img = list>'x', &nimg = (img.depth==1)?img:(tmp=img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       _assign(nimg.width,nimg.height,title,normalization_type,fullscreen_flag,closed_flag);

       if (normalization==2) min = (float)nimg.minmax(max);

       return display(nimg);

     }


     CImgDisplay& assign(const CImgDisplay &win) {

       if (!win) return assign();

       _assign(win.width,win.height,win.title,win.normalization,win.is_fullscreen,win.is_closed);

       std::memcpy(data,win.data,sizeof(unsigned int)*width*height);

       return paint();

     }


     template<typename T>

     CImgDisplay& display(const CImg<T>& img) {

       if (is_empty()) assign(img.width,img.height);

       return render(img).paint();

     }


     CImgDisplay& resize(const int nwidth, const int nheight, const bool redraw=true) {

       if (!nwidth || !nheight || (is_empty() && (nwidth<0 || nheight<0))) return assign();

       if (is_empty()) return assign(nwidth,nheight);

       const unsigned int

         tmpdimx = (nwidth>0)?nwidth:(-nwidth*width/100),

         tmpdimy = (nheight>0)?nheight:(-nheight*height/100),

         dimx = tmpdimx?tmpdimx:1,

         dimy = tmpdimy?tmpdimy:1;

       cimg::CarbonInfo& c = cimg::CarbonAttr();


       if ((window_width!=dimx || window_height!=dimy) &&

           !_CbSendMsg(c,CbSerializedQuery::BuildResizeWindowQuery(this,dimx,dimy,redraw)))

         throw CImgDisplayException("CImgDisplay::resize() : Cannot resize the window associated to the current display.");


       if (width!=dimx || height!=dimy) {

         unsigned int *ndata = new unsigned int[dimx*dimy];

         if (redraw) _render_resize(data,width,height,ndata,dimx,dimy);

         else std::memset(ndata,0x80,sizeof(unsigned int)*dimx*dimy);

         unsigned int const* old_data = data;

         data = ndata;

         delete[] old_data;

         _CbReinitGraphics();

       }

       window_width = width = dimx; window_height = height = dimy;

       is_resized = false;

       if (is_fullscreen) move((screen_dimx()-width)/2,(screen_dimy()-height)/2);

       if (redraw) return paint();

       return *this;

     }


     CImgDisplay& move(const int posx, const int posy) {

       if (is_empty()) return *this;

       if (!is_fullscreen) {

         // If the operation succeeds, window_x and window_y are updated by the event thread

         cimg::CarbonInfo& c = cimg::CarbonAttr();

         // Send the query

         if (!_CbSendMsg(c,CbSerializedQuery::BuildMoveWindowQuery(this,posx,posy)))

           throw CImgDisplayException("CImgDisplay::move() : Cannot move the window associated to the current display.");

       }

       return show();

     }


     CImgDisplay& set_mouse(const int posx, const int posy) {

       if (!is_closed && posx>=0 && posy>=0) {

         // If the operation succeeds, mouse_x and mouse_y are updated by the event thread

         cimg::CarbonInfo& c = cimg::CarbonAttr();

         // Send the query

         if (!_CbSendMsg(c,CbSerializedQuery::BuildSetWindowPosQuery(this,posx,posy)))

           throw CImgDisplayException("CImgDisplay::set_mouse() : Cannot set the mouse position to the current display.");

       }

       return *this;

     }


     CImgDisplay& hide_mouse() {

       if (is_empty()) return *this;

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       // Send the query

       if (!_CbSendMsg(c,CbSerializedQuery::BuildHideMouseQuery(this)))

         throw CImgDisplayException("CImgDisplay::hide_mouse() : Cannot hide the mouse associated to the current display.");

       return *this;

     }


     CImgDisplay& show_mouse() {

       if (is_empty()) return *this;

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       // Send the query

       if (!_CbSendMsg(c,CbSerializedQuery::BuildShowMouseQuery(this)))

         throw CImgDisplayException("CImgDisplay::show_mouse() : Cannot show the mouse associated to the current display.");

       return *this;

     }


     static void wait_all() {

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       MPWaitOnSemaphore(c.wait_event,kDurationForever);

     }


     CImgDisplay& show() {

       if (is_empty()) return *this;

       if (is_closed) {

         cimg::CarbonInfo& c = cimg::CarbonAttr();

         if (!_CbSendMsg(c,CbSerializedQuery::BuildShowWindowQuery(this)))

           throw CImgDisplayException("CImgDisplay::show() : Cannot show the window associated to the current display.");

       }

       return paint();

     }


     CImgDisplay& close() {

       if (is_empty()) return *this;

       if (!is_closed && !is_fullscreen) {

         cimg::CarbonInfo& c = cimg::CarbonAttr();

         // If the operation succeeds, window_x and window_y are updated on the event thread

         if (!_CbSendMsg(c,CbSerializedQuery::BuildHideWindowQuery(this)))

           throw CImgDisplayException("CImgDisplay::close() : Cannot hide the window associated to the current display.");

       }

       return *this;

     }


     CImgDisplay& set_title(const char *format, ...) {

       if (is_empty()) return *this;

       char tmp[1024] = { 0 };

       va_list ap;

       va_start(ap, format);

       std::vsprintf(tmp,format,ap);

       va_end(ap);

       if (title) delete[] title;

       const unsigned int s = std::strlen(tmp) + 1;

       title = new char[s];

       std::memcpy(title,tmp,s*sizeof(char));

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       if (!_CbSendMsg(c,CbSerializedQuery::BuildSetWindowTitleQuery(this,tmp)))

         throw CImgDisplayException("CImgDisplay::set_title() : Cannot set the window title associated to the current display.");

       return *this;

     }


     CImgDisplay& paint() {

       if (!is_closed) {

         MPEnterCriticalRegion(paintCriticalRegion,kDurationForever);

         CGrafPtr portPtr = GetWindowPort(carbonWindow);

         CGContextRef currentContext = 0;

         QDBeginCGContext(portPtr,&currentContext);

         CGContextSetRGBFillColor(currentContext,255,255,255,255);

         CGContextFillRect(currentContext,CGRectMake(0,0,window_width,window_height));

         CGContextDrawImage(currentContext,CGRectMake(0,int(window_height-height)<0?0:window_height-height,width,height),imageRef);

         CGContextFlush(currentContext);

         QDEndCGContext(portPtr, &currentContext);

         MPExitCriticalRegion(paintCriticalRegion);

       }

       return *this;

     }


     template<typename T>

     CImgDisplay& render(const CImg<T>& img) {

       if (is_empty()) return *this;

       if (!img)

         throw CImgArgumentException("CImgDisplay::_render_image() : Specified input image (%u,%u,%u,%u,%p) is empty.",

                                     img.width,img.height,img.depth,img.dim,img.data);

       if (img.depth!=1) return render(img.get_projections2d(img.width/2,img.height/2,img.depth/2));

       const T

         *data1 = img.data,

         *data2 = (img.dim>=2)?img.ptr(0,0,0,1):data1,

         *data3 = (img.dim>=3)?img.ptr(0,0,0,2):data1;

       MPEnterCriticalRegion(paintCriticalRegion, kDurationForever);

       unsigned int

         *const ndata = (img.width==width && img.height==height)?data:new unsigned int[img.width*img.height],

         *ptrd = ndata;

       if (!normalization || (normalization==3 && cimg::type<T>::string()==cimg::type<unsigned char>::string())) {

         min = max = 0;

         for (unsigned int xy = img.width*img.height; xy>0; --xy)

           *(ptrd++) = ((unsigned char)*(data1++)<<16) | ((unsigned char)*(data2++)<<8) | (unsigned char)*(data3++);

       } else {

         if (normalization==3) {

           if (cimg::type<T>::is_float()) min = (float)img.minmax(max);

           else {

             min = (float)cimg::type<T>::min();

             max = (float)cimg::type<T>::max();

           }

         } else if ((min>max) || normalization==1) min = (float)img.minmax(max);

         const float delta = max-min, mm = delta?delta:1.0f;

         for (unsigned int xy = img.width*img.height; xy>0; --xy) {

           const unsigned char

             R = (unsigned char)(255*(*(data1++)-min)/mm),

             G = (unsigned char)(255*(*(data2++)-min)/mm),

             B = (unsigned char)(255*(*(data3++)-min)/mm);

           *(ptrd++) = (R<<16) | (G<<8) | (B);

         }

       }

       if (ndata!=data) {

         _render_resize(ndata,img.width,img.height,data,width,height);

         delete[] ndata;

       }

       MPExitCriticalRegion(paintCriticalRegion);

       return *this;

     }


     template<typename T>

     const CImgDisplay& snapshot(CImg<T>& img) const {

       if (is_empty()) img.assign();

       else {

         img.assign(width,height,1,3);

         T

           *data1 = img.ptr(0,0,0,0),

           *data2 = img.ptr(0,0,0,1),

           *data3 = img.ptr(0,0,0,2);

         unsigned int *ptrs = data;

         for (unsigned int xy = img.width*img.height; xy>0; --xy) {

           const unsigned int val = *(ptrs++);

           *(data1++) = (unsigned char)(val>>16);

           *(data2++) = (unsigned char)((val>>8)&0xFF);

           *(data3++) = (unsigned char)(val&0xFF);

         }

       }

       return *this;

     }


     CImgDisplay& toggle_fullscreen(const bool redraw=true) {

       if (is_empty()) return *this;

       if (redraw) {

         const unsigned int bufsize = width*height*4;

         void *odata = std::malloc(bufsize);

         std::memcpy(odata,data,bufsize);

         assign(width,height,title,normalization,!is_fullscreen,false);

         std::memcpy(data,odata,bufsize);

         std::free(odata);

         return paint();

       }

       return assign(width,height,title,normalization,!is_fullscreen,false);

     }


     static OSStatus CarbonEventHandler(EventHandlerCallRef myHandler, EventRef theEvent, void* userData) {

       OSStatus result = eventNotHandledErr;

       CImgDisplay* disp = (CImgDisplay*) userData;

       (void)myHandler; // Avoid "unused parameter"

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       // Gets the associated display

       if (disp) {

         // Window events are always handled

         if (GetEventClass(theEvent)==kEventClassWindow) switch (GetEventKind (theEvent)) {

         case kEventWindowClose :

           disp->mouse_x = disp->mouse_y = -1;

           disp->window_x = disp->window_y = 0;

           if (disp->button) {

             std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

             disp->button = 0;

           }

           if (disp->key) {

             std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1);

             disp->key = 0;

           }

           if (disp->released_key) { std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1); disp->released_key = 0; }

           disp->is_closed = true;

           HideWindow(disp->carbonWindow);

           disp->is_event = true;

           MPSignalSemaphore(c.wait_event);

           result = noErr;

           break;

           // There is a lot of case where we have to redraw our window

         case kEventWindowBoundsChanging :

         case kEventWindowResizeStarted :

         case kEventWindowCollapsed : //Not sure it's really needed :-)

           break;

         case kEventWindowZoomed :

         case kEventWindowExpanded :

         case kEventWindowResizeCompleted : {

           MPEnterCriticalRegion(disp->paintCriticalRegion, kDurationForever);

           // Now we retrieve the new size of the window

           Rect newContentRect;

           GetWindowBounds(disp->carbonWindow,kWindowContentRgn,&newContentRect);

           const unsigned int

             nw = (unsigned int)(newContentRect.right - newContentRect.left),

             nh = (unsigned int)(newContentRect.bottom - newContentRect.top);


           // Then we update CImg internal settings

           if (nw && nh && (nw!=disp->width || nh!=disp->height)) {

             disp->window_width = nw;

             disp->window_height = nh;

             disp->mouse_x = disp->mouse_y = -1;

             disp->is_resized = true;

           }

           disp->is_event = true;

           MPExitCriticalRegion(disp->paintCriticalRegion);

           disp->paint(); // Coords changed, must update the screen

           MPSignalSemaphore(c.wait_event);

           result = noErr;

         } break;

         case kEventWindowDragStarted :

         case kEventWindowDragCompleted : {

           MPEnterCriticalRegion(disp->paintCriticalRegion, kDurationForever);

           // Now we retrieve the new size of the window

           Rect newContentRect ;

           GetWindowBounds(disp->carbonWindow,kWindowStructureRgn,&newContentRect);

           const int nx = (int)(newContentRect.left), ny = (int)(newContentRect.top);

           // Then we update CImg internal settings

           if (nx!=disp->window_x || ny!=disp->window_y) {

             disp->window_x = nx;

             disp->window_y = ny;

             disp->is_moved = true;

           }

           disp->is_event = true;

           MPExitCriticalRegion(disp->paintCriticalRegion);

           disp->paint(); // Coords changed, must update the screen

           MPSignalSemaphore(c.wait_event);

           result = noErr;

         } break;

           case kEventWindowPaint :

           disp->paint();

           break;

           }


         switch (GetEventClass(theEvent)) {

         case kEventClassKeyboard : {

           if (GetEventKind(theEvent)==kEventRawKeyModifiersChanged) {

             // Apple has special keys named "notifiers", we have to convert this (exotic ?) key handling into the regular CImg processing.

             UInt32 newModifiers;

             if (GetEventParameter(theEvent,kEventParamKeyModifiers,typeUInt32,0,sizeof(UInt32),0,&newModifiers)==noErr) {

               int newKeyCode = -1;

               UInt32 changed = disp->lastKeyModifiers^newModifiers;

               // Find what changed here

               if ((changed & rightShiftKey)!=0) newKeyCode = cimg::keySHIFTRIGHT;

               if ((changed & shiftKey)!=0) newKeyCode = cimg::keySHIFTLEFT;


               // On the Mac, the "option" key = the ALT key

               if ((changed & (optionKey | rightOptionKey))!=0) newKeyCode = cimg::keyALTGR;

               if ((changed & controlKey)!=0) newKeyCode = cimg::keyCTRLLEFT;

               if ((changed & rightControlKey)!=0) newKeyCode = cimg::keyCTRLRIGHT;

               if ((changed & cmdKey)!=0) newKeyCode = cimg::keyAPPLEFT;

               if ((changed & alphaLock)!=0) newKeyCode = cimg::keyCAPSLOCK;

               if (newKeyCode != -1) { // Simulate keystroke

                 if (disp->key) std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1);

                 disp->key = (int)newKeyCode;

               }

               disp->lastKeyModifiers = newModifiers; // Save current state

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

           }

           if (GetEventKind(theEvent)==kEventRawKeyDown || GetEventKind(theEvent)==kEventRawKeyRepeat) {

             char keyCode;

             if (GetEventParameter(theEvent,kEventParamKeyMacCharCodes,typeChar,0,sizeof(keyCode),0,&keyCode)==noErr) {

               disp->_update_iskey((unsigned int)keyCode,true);

               if (disp->key) std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1);

               disp->key = (unsigned int)keyCode;

               if (disp->released_key) { std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1); disp->released_key = 0; }

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

           }

         } break;


         case kEventClassMouse :

           switch (GetEventKind(theEvent)) {

           case kEventMouseDragged :

             //  When you push the main button on the Apple mouse while moving it, you got NO kEventMouseMoved msg,

             //  but a kEventMouseDragged one. So we merge them here.

           case kEventMouseMoved :

             HIPoint point;

             if (GetEventParameter(theEvent,kEventParamMouseLocation,typeHIPoint,0,sizeof(point),0,&point)==noErr) {

               if (_CbToLocalPointFromMouseEvent(theEvent,disp->carbonWindow,&point)) {

                 disp->mouse_x = (int)point.x;

                 disp->mouse_y = (int)point.y;

                 if (disp->mouse_x<0 || disp->mouse_y<0 || disp->mouse_x>=disp->dimx() || disp->mouse_y>=disp->dimy())

                   disp->mouse_x = disp->mouse_y = -1;

               } else disp->mouse_x = disp->mouse_y = -1;

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

             break;

           case kEventMouseDown :

             UInt16 btn;

             if (GetEventParameter(theEvent,kEventParamMouseButton,typeMouseButton,0,sizeof(btn),0,&btn)==noErr) {

               std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

               if (btn==kEventMouseButtonPrimary) disp->button|=1U;

               // For those who don't have a multi-mouse button (as me), I think it's better to allow the user

               // to emulate a right click by using the Control key

               if ((disp->lastKeyModifiers & (controlKey | rightControlKey))!=0)

                 cimg::warn("CImgDisplay::CarbonEventHandler() : Will emulate right click now [Down]");

               if (btn==kEventMouseButtonSecondary || ((disp->lastKeyModifiers & (controlKey | rightControlKey))!=0)) disp->button|=2U;

               if (btn==kEventMouseButtonTertiary) disp->button|=4U;

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

             break;

           case kEventMouseWheelMoved :

             EventMouseWheelAxis wheelax;

             SInt32 delta;

             if (GetEventParameter(theEvent,kEventParamMouseWheelAxis,typeMouseWheelAxis,0,sizeof(wheelax),0,&wheelax)==noErr)

               if (wheelax==kEventMouseWheelAxisY) {

                 if (GetEventParameter(theEvent,kEventParamMouseWheelDelta,typeLongInteger,0,sizeof(delta),0,&delta)==noErr)

                   if (delta>0) disp->wheel+=delta/120; //FIXME: why 120 ?

                 disp->is_event = true;

                 MPSignalSemaphore(c.wait_event);

               }

             break;

           }

         }


         switch (GetEventClass(theEvent)) {

         case kEventClassKeyboard :

           if (GetEventKind(theEvent)==kEventRawKeyUp) {

             UInt32 keyCode;

             if (GetEventParameter(theEvent,kEventParamKeyCode,typeUInt32,0,sizeof(keyCode),0,&keyCode)==noErr) {

               disp->_update_iskey((unsigned int)keyCode,false);

               if (disp->key) { std::memmove((void*)(disp->keys+1),(void*)disp->keys,512-1); disp->key = 0; }

               if (disp->released_key) std::memmove((void*)(disp->released_keys+1),(void*)disp->released_keys,512-1);

               disp->released_key = (int)keyCode;

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

           }

           break;


         case kEventClassMouse :

           switch (GetEventKind(theEvent)) {

           case kEventMouseUp :

             UInt16 btn;

             if (GetEventParameter(theEvent,kEventParamMouseButton,typeMouseButton,0,sizeof(btn),0,&btn)==noErr) {

               std::memmove((void*)(disp->buttons+1),(void*)disp->buttons,512-1);

               if (btn==kEventMouseButtonPrimary) disp->button&=~1U;

               // See note in kEventMouseDown handler.

               if ((disp->lastKeyModifiers & (controlKey | rightControlKey))!=0)

                 cimg::warn("CImgDisplay::CarbonEventHandler() : Will emulate right click now [Up]");

               if (btn==kEventMouseButtonSecondary || ((disp->lastKeyModifiers & (controlKey | rightControlKey))!=0)) disp->button&=~2U;

               if (btn==kEventMouseButtonTertiary) disp->button&=~2U;

             }

             disp->is_event = true;

             MPSignalSemaphore(c.wait_event);

             break;

           }

         }

       }

       return (result);

     }


     static void* _events_thread(void* args) {

       (void)args;      // Make the compiler happy

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,0);

       pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);

       MPSignalSemaphore(c.sync_event);  // Notify the caller that all goes fine

       EventRef theEvent;

       EventTargetRef theTarget;

       OSStatus err;

       CbSerializedQuery* query;

       theTarget = GetEventDispatcherTarget();


       // Enter in the main loop

       while (true) {

         pthread_testcancel(); /* Check if cancelation happens */

         err = ReceiveNextEvent(0,0,kDurationImmediate,true,&theEvent); // Fetch new events

         if (err==noErr) { // Received a carbon event, so process it !

           SendEventToEventTarget (theEvent, theTarget);

           ReleaseEvent(theEvent);

         } else if (err == eventLoopTimedOutErr) { // There is no event to process, so check if there is new messages to process

           OSStatus r =MPWaitOnQueue(c.com_queue,(void**)&query,0,0,10*kDurationMillisecond);

           if (r!=noErr) continue; //nothing in the queue or an error.., bye

           // If we're here, we've something to do now.

           if (query) {

             switch (query->kind) {

             case COM_SETMOUSEPOS : { // change the cursor position

               query->success = CGDisplayMoveCursorToPoint(kCGDirectMainDisplay,CGPointMake(query->sender->window_x+query->x,query->sender->window_y+query->y))

                 == kCGErrorSuccess;

               if (query->success) {

                 query->sender->mouse_x = query->x;

                 query->sender->mouse_y = query->y;

               } else cimg::warn("CImgDisplay::_events_thread() : CGDisplayMoveCursorToPoint failed.");

             } break;

             case COM_SETTITLE : { // change the title bar caption

               CFStringRef windowTitle = CFStringCreateWithCString(0,query->c,kCFStringEncodingMacRoman);

               query->success = SetWindowTitleWithCFString(query->sender->carbonWindow,windowTitle)==noErr;

               if (!query->success)

                 cimg::warn("CImgDisplay::_events_thread() : SetWindowTitleWithCFString failed.");

               CFRelease(windowTitle);

             } break;

             case COM_RESIZEWINDOW : { // Resize a window

               SizeWindow(query->sender->carbonWindow,query->x,query->y,query->update);

               // If the window has been resized successfully, update display informations

               query->sender->window_width = query->x;

               query->sender->window_height = query->y;

               query->success = true;

             } break;

             case COM_MOVEWINDOW : { // Move a window

               MoveWindow(query->sender->carbonWindow,query->x,query->y,false);

               query->sender->window_x = query->x;

               query->sender->window_y = query->y;

               query->sender->is_moved = false;

               query->success = true;

             } break;

             case COM_SHOWMOUSE : { // Show the mouse

               query->success = CGDisplayShowCursor(kCGDirectMainDisplay)==noErr;

               if (!query->success)

                 cimg::warn("CImgDisplay::_events_thread() : CGDisplayShowCursor failed.");

             } break;

             case COM_HIDEMOUSE : { // Hide the mouse

               query->success = CGDisplayHideCursor(kCGDirectMainDisplay)==noErr;

               if (!query->success)

                 cimg::warn("CImgDisplay::_events_thread() : CGDisplayHideCursor failed.");

             } break;

             case COM_SHOWWINDOW : { // We've to show a window

               ShowWindow(query->sender->carbonWindow);

               query->success = true;

               query->sender->is_closed = false;

             } break;

             case COM_HIDEWINDOW : { // We've to show a window

               HideWindow(query->sender->carbonWindow);

               query->sender->is_closed = true;

               query->sender->window_x = query->sender->window_y = 0;

               query->success = true;

             } break;

             case COM_RELEASEWINDOW : { // We have to release a given window handle

               query->success = true;

               CFRelease(query->sender->carbonWindow);

             } break;

             case COM_CREATEWINDOW : { // We have to create a window

               query->success = true;

               WindowAttributes  windowAttrs;

               Rect              contentRect;

               if (query->createFullScreenWindow) {

                 // To simulate a "true" full screen, we remove menus and close boxes

                 windowAttrs = (1L << 9); //Why ? kWindowNoTitleBarAttribute seems to be not defined on 10.3

                 // Define a full screen bound rect

                 SetRect(&contentRect,0,0,CGDisplayPixelsWide(kCGDirectMainDisplay),CGDisplayPixelsHigh(kCGDirectMainDisplay));

               } else { // Set the window size

                 SetRect(&contentRect,0,0,query->sender->width,query->sender->height); // Window will be centered with RepositionWindow.

                 // Use default attributes

                 windowAttrs = kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute | kWindowInWindowMenuAttribute | kWindowLiveResizeAttribute;

               }

               // Update window position

               if (query->createClosedWindow) query->sender->window_x = query->sender->window_y = 0;

               else {

                 query->sender->window_x = contentRect.left;

                 query->sender->window_y = contentRect.top;

               }

               // Update window flags

               query->sender->window_width = query->sender->width;

               query->sender->window_height = query->sender->height;

               query->sender->flush();

               // Create the window

               if (CreateNewWindow(kDocumentWindowClass,windowAttrs,&contentRect,&query->sender->carbonWindow)!=noErr) {

                 query->success = false;

                 cimg::warn("CImgDisplay::_events_thread() : CreateNewWindow() failed.");

               }

               // Send it to the foreground

               if (RepositionWindow(query->sender->carbonWindow,0,kWindowCenterOnMainScreen)!=noErr) query->success = false;

               // Show it, if needed

               if (!query->createClosedWindow) ShowWindow(query->sender->carbonWindow);


               // Associate a valid event handler

               EventTypeSpec eventList[] = {

                 { kEventClassWindow, kEventWindowClose },

                 { kEventClassWindow, kEventWindowResizeStarted },

                 { kEventClassWindow, kEventWindowResizeCompleted },

                 { kEventClassWindow, kEventWindowDragStarted},

                 { kEventClassWindow, kEventWindowDragCompleted },

                 { kEventClassWindow, kEventWindowPaint },

                 { kEventClassWindow, kEventWindowBoundsChanging },

                 { kEventClassWindow, kEventWindowCollapsed },

                 { kEventClassWindow, kEventWindowExpanded },

                 { kEventClassWindow, kEventWindowZoomed },

                 { kEventClassKeyboard, kEventRawKeyDown },

                 { kEventClassKeyboard, kEventRawKeyUp },

                 { kEventClassKeyboard, kEventRawKeyRepeat },

                 { kEventClassKeyboard, kEventRawKeyModifiersChanged },

                 { kEventClassMouse, kEventMouseMoved },

                 { kEventClassMouse, kEventMouseDown },

                 { kEventClassMouse, kEventMouseUp },

                 { kEventClassMouse, kEventMouseDragged }

               };


               // Set up the handler

               if (InstallWindowEventHandler(query->sender->carbonWindow,NewEventHandlerUPP(CarbonEventHandler),GetEventTypeCount(eventList),

                                             eventList,(void*)query->sender,0)!=noErr) {

                 query->success = false;

                 cimg::warn("CImgDisplay::_events_thread() : InstallWindowEventHandler failed.");

               }


               // Paint

               query->sender->paint();

             } break;

             default :

               cimg::warn("CImgDisplay::_events_thread() : Received unknow code %d.",query->kind);

             }

             // Signal that the message has been processed

             MPSignalSemaphore(c.sync_event);

           }

         }

       }

       // If we are here, the application is now finished

       pthread_exit(0);

     }


     CImgDisplay& assign() {

       if (is_empty()) return *this;

       cimg::CarbonInfo& c = cimg::CarbonAttr();

       // Destroy the window associated to the display

       _CbFreeAttachedWindow(c);

       // Don't destroy the background thread here.

       // If you check whether _CbFreeAttachedWindow() returned true,

       //   - saying that there were no window left on screen - and

       //   you destroy the background thread here, ReceiveNextEvent won't

       //   work anymore if you create a new window after. So the

       //  background thread must be killed (pthread_cancel() + pthread_join())

       //   only on the application shutdown.


       // Finalize graphics

       _CbFinalizeGraphics();


       // Do some cleanup

       if (data) delete[] data;

       if (title) delete[] title;

       width = height = normalization = window_width = window_height = 0;

       window_x = window_y = 0;

       is_fullscreen = false;

       is_closed = true;

       min = max = 0;

       title = 0;

       flush();

       if (MPDeleteCriticalRegion(paintCriticalRegion)!=noErr)

         throw CImgDisplayException("CImgDisplay()::assign() : MPDeleteCriticalRegion failed.");

       return *this;

     }


     CImgDisplay& _assign(const unsigned int dimw, const unsigned int dimh, const char *const ptitle=0,

                          const unsigned int normalization_type=3,

                          const bool fullscreen_flag=false, const bool closed_flag=false) {

       cimg::CarbonInfo& c = cimg::CarbonAttr();


       // Allocate space for window title

       const char *const nptitle = ptitle?ptitle:"";

       const unsigned int s = std::strlen(nptitle) + 1;

       char *tmp_title = s?new char[s]:0;

       if (s) std::memcpy(tmp_title,nptitle,s*sizeof(char));


       // Destroy previous window if existing

       if (!is_empty()) assign();


       // Set display variables

       width = cimg::min(dimw,(unsigned int)screen_dimx());

       height = cimg::min(dimh,(unsigned int)screen_dimy());

       normalization = normalization_type<4?normalization_type:3;

       is_fullscreen = fullscreen_flag;

       is_closed = closed_flag;

       lastKeyModifiers = 0;

       title = tmp_title;

       flush();


       // Create the paint CR

       if (MPCreateCriticalRegion(&paintCriticalRegion) != noErr)

         throw CImgDisplayException("CImgDisplay::_assign() : MPCreateCriticalRegion() failed.");


       // Create the thread if it's not already created

       if (c.event_thread==0) {

         // Background thread does not exists, so create it !

         if (pthread_create(&c.event_thread,0,_events_thread,0)!=0)

           throw CImgDisplayException("CImgDisplay::_assign() : pthread_create() failed.");

         // Wait for thread initialization

         MPWaitOnSemaphore(c.sync_event, kDurationForever);

       }


       // Init disp. graphics

       data = new unsigned int[width*height];

       _CbInitializeGraphics();


       // Now ask the thread to create the window

       _CbCreateAttachedWindow(c,nptitle,fullscreen_flag,closed_flag);

       return *this;

     }


 #endif


   };


   /*

    #--------------------------------------

    #

    #

    #

    # Definition of the CImg<T> structure

    #

    #

    #

    #--------------------------------------

    */


   template<typename T>

   struct CImg {


     unsigned int width;


     unsigned int height;


     unsigned int depth;


     unsigned int dim;


     bool is_shared;


     T *data;


     typedef T* iterator;


     typedef const T* const_iterator;


     typedef T value_type;


     // Define common T-dependant types.

     typedef typename cimg::superset<T,bool>::type Tbool;

     typedef typename cimg::superset<T,unsigned char>::type Tuchar;

     typedef typename cimg::superset<T,char>::type Tchar;

     typedef typename cimg::superset<T,unsigned short>::type Tushort;

     typedef typename cimg::superset<T,short>::type Tshort;

     typedef typename cimg::superset<T,unsigned int>::type Tuint;

     typedef typename cimg::superset<T,int>::type Tint;

     typedef typename cimg::superset<T,unsigned long>::type Tulong;

     typedef typename cimg::superset<T,long>::type Tlong;

     typedef typename cimg::superset<T,float>::type Tfloat;

     typedef typename cimg::superset<T,double>::type Tdouble;

     typedef typename cimg::last<T,bool>::type boolT;

     typedef typename cimg::last<T,unsigned char>::type ucharT;

     typedef typename cimg::last<T,char>::type charT;

     typedef typename cimg::last<T,unsigned short>::type ushortT;

     typedef typename cimg::last<T,short>::type shortT;

     typedef typename cimg::last<T,unsigned int>::type uintT;

     typedef typename cimg::last<T,int>::type intT;

     typedef typename cimg::last<T,unsigned long>::type ulongT;

     typedef typename cimg::last<T,long>::type longT;

     typedef typename cimg::last<T,float>::type floatT;

     typedef typename cimg::last<T,double>::type doubleT;


     //---------------------------

     //


     //---------------------------

 #ifdef cimg_plugin

 #include cimg_plugin

 #endif

 #ifdef cimg_plugin1

 #include cimg_plugin1

 #endif

 #ifdef cimg_plugin2

 #include cimg_plugin2

 #endif

 #ifdef cimg_plugin3

 #include cimg_plugin3

 #endif

 #ifdef cimg_plugin4

 #include cimg_plugin4

 #endif

 #ifdef cimg_plugin5

 #include cimg_plugin5

 #endif

 #ifdef cimg_plugin6

 #include cimg_plugin6

 #endif

 #ifdef cimg_plugin7

 #include cimg_plugin7

 #endif

 #ifdef cimg_plugin8

 #include cimg_plugin8

 #endif


     //---------------------------------------------------------

     //


     //---------------------------------------------------------


     ~CImg() {

       if (data && !is_shared) delete[] data;

     }


     CImg():width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {}


     explicit CImg(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1):

       is_shared(false) {

       const unsigned int siz = dx*dy*dz*dv;

       if (siz) { width = dx; height = dy; depth = dz; dim = dv; data = new T[siz]; }

       else { width = height = depth = dim = 0; data = 0; }

     }


     CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const T val):

       is_shared(false) {

       const unsigned int siz = dx*dy*dz*dv;

       if (siz) { width = dx; height = dy; depth = dz; dim = dv; data = new T[siz]; fill(val); }

       else { width = height = depth = dim = 0; data = 0; }

     }


     CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

          const int val0, const int val1, ...):width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

 #define _CImg_stdarg(img,a0,a1,N,t) { \

         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); \

         }}

       assign(dx,dy,dz,dv);

       _CImg_stdarg(*this,val0,val1,dx*dy*dz*dv,int);

     }


     CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

          const double val0, const double val1, ...):width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       assign(dx,dy,dz,dv);

       _CImg_stdarg(*this,val0,val1,dx*dy*dz*dv,double);

     }


     CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

          const char *const values, const bool repeat_values):is_shared(false) {

       const unsigned int siz = dx*dy*dz*dv;

       if (siz) { width = dx; height = dy; depth = dz; dim = dv; data = new T[siz]; fill(values,repeat_values); }

       else { width = height = depth = dim = 0; data = 0; }

     }


     template<typename t>

     CImg(const t *const data_buffer, const unsigned int dx, const unsigned int dy=1,

          const unsigned int dz=1, const unsigned int dv=1, const bool shared=false):is_shared(false) {

       if (shared)

         throw CImgArgumentException("CImg<%s>::CImg() : Cannot construct a shared instance image from a (%s*) buffer "

                                     "(different pixel types).",

                                     pixel_type(),CImg<t>::pixel_type());

       const unsigned int siz = dx*dy*dz*dv;

       if (data_buffer && siz) {

         width = dx; height = dy; depth = dz; dim = dv; data = new T[siz];

         const t *ptrs = data_buffer + siz; cimg_for(*this,ptrd,T) *ptrd = (T)*(--ptrs);

       } else { width = height = depth = dim = 0; data = 0; }

     }


     CImg(const T *const data_buffer, const unsigned int dx, const unsigned int dy=1,

          const unsigned int dz=1, const unsigned int dv=1, const bool shared=false) {

       const unsigned int siz = dx*dy*dz*dv;

       if (data_buffer && siz) {

         width = dx; height = dy; depth = dz; dim = dv; is_shared = shared;

         if (is_shared) data = const_cast<T*>(data_buffer);

         else { data = new T[siz]; std::memcpy(data,data_buffer,siz*sizeof(T)); }

       } else { width = height = depth = dim = 0; is_shared = false; data = 0; }

     }


     explicit CImg(const char *const filename):width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       assign(filename);

     }


     template<typename t>

     CImg(const CImg<t>& img):is_shared(false) {

       const unsigned int siz = img.size();

       if (img.data && siz) {

         width = img.width; height = img.height; depth = img.depth; dim = img.dim; data = new T[siz];

         const t *ptrs = img.data + siz; cimg_for(*this,ptrd,T) *ptrd = (T)*(--ptrs);

       } else { width = height = depth = dim = 0; data = 0; }

     }


     CImg(const CImg<T>& img) {

       const unsigned int siz = img.size();

       if (img.data && siz) {

         width = img.width; height = img.height; depth = img.depth; dim = img.dim; is_shared = img.is_shared;

         if (is_shared) data = const_cast<T*>(img.data);

         else { data = new T[siz]; std::memcpy(data,img.data,siz*sizeof(T)); }

       } else { width = height = depth = dim = 0; is_shared = false; data = 0; }

     }


     template<typename t>

     CImg(const CImg<t>& img, const bool shared):is_shared(false) {

       if (shared)

         throw CImgArgumentException("CImg<%s>::CImg() : Cannot construct a shared instance image from a CImg<%s> instance "

                                     "(different pixel types).",

                                     pixel_type(),CImg<t>::pixel_type());

       const unsigned int siz = img.size();

       if (img.data && siz) {

         width = img.width; height = img.height; depth = img.depth; dim = img.dim; data = new T[siz];

         const t *ptrs = img.data + siz; cimg_for(*this,ptrd,T) *ptrd = (T)*(--ptrs);

       } else { width = height = depth = dim = 0; data = 0; }

     }


     CImg(const CImg<T>& img, const bool shared) {

       const unsigned int siz = img.size();

       if (img.data && siz) {

         width = img.width; height = img.height; depth = img.depth; dim = img.dim; is_shared = shared;

         if (is_shared) data = const_cast<T*>(img.data);

         else { data = new T[siz]; std::memcpy(data,img.data,siz*sizeof(T)); }

       } else { width = height = depth = dim = 0; is_shared = false; data = 0; }

     }


     template<typename t>

     CImg(const CImg<t>& img, const char *const dimensions):width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       assign(img,dimensions);

     }


     template<typename t>

     CImg(const CImg<t>& img, const char *const dimensions, const T val):

       width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       assign(img,dimensions).fill(val);

     }


     template<typename t>

     CImg(const CImg<t>& img, const char *const dimensions, const char *const values, const bool repeat_values):

       width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       assign(img,dimensions).fill(values,repeat_values);

     }


     explicit CImg(const CImgDisplay &disp):width(0),height(0),depth(0),dim(0),is_shared(false),data(0) {

       disp.snapshot(*this);

     }


     CImg<T> get_shared() {

       return CImg<T>(data,width,height,depth,dim,true);

     }


     const CImg<T> get_shared() const {

       return CImg<T>(data,width,height,depth,dim,true);

     }


     CImg<T>& clear() {

       return assign();

     }


     CImg<T>& assign() {

       if (data && !is_shared) delete[] data;

       width = height = depth = dim = 0; is_shared = false; data = 0;

       return *this;

     }


     CImg<T>& assign(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1) {

       const unsigned int siz = dx*dy*dz*dv;

       if (!siz) return assign();

       const unsigned int curr_siz = size();

       if (siz!=curr_siz) {

         if (is_shared)

           throw CImgArgumentException("CImg<%s>::assign() : Cannot assign image (%u,%u,%u,%u) to shared instance image (%u,%u,%u,%u,%p).",

                                       pixel_type(),dx,dy,dz,dv,width,height,depth,dim,data);

         else { if (data) delete[] data; data = new T[siz]; }

       }

       width = dx; height = dy; depth = dz; dim = dv;

       return *this;

     }


     CImg<T>& assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const T val) {

       return assign(dx,dy,dz,dv).fill(val);

     }


     CImg<T>& assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

                     const int val0, const int val1, ...) {

       assign(dx,dy,dz,dv);

       _CImg_stdarg(*this,val0,val1,dx*dy*dz*dv,int);

       return *this;

     }


     CImg<T>& assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

                     const double val0, const double val1, ...) {

       assign(dx,dy,dz,dv);

       _CImg_stdarg(*this,val0,val1,dx*dy*dz*dv,double);

       return *this;

     }


     CImg<T>& assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv,

                     const char *const values, const bool repeat_values) {

       return assign(dx,dy,dz,dv).fill(values,repeat_values);

     }


     template<typename t>

     CImg<T>& assign(const t *const data_buffer, const unsigned int dx, const unsigned int dy=1,

                     const unsigned int dz=1, const unsigned int dv=1) {

       const unsigned int siz = dx*dy*dz*dv;

       if (!data_buffer || !siz) return assign();

       assign(dx,dy,dz,dv);

       const t *ptrs = data_buffer + siz; cimg_for(*this,ptrd,T) *ptrd = (T)*(--ptrs);

       return *this;

     }


     CImg<T>& assign(const T *const data_buffer, const unsigned int dx, const unsigned int dy=1,

                     const unsigned int dz=1, const unsigned int dv=1) {

       const unsigned int siz = dx*dy*dz*dv;

       if (!data_buffer || !siz) return assign();

       const unsigned int curr_siz = size();

       if (data_buffer==data && siz==curr_siz) return assign(dx,dy,dz,dv);

       if (is_shared || data_buffer+siz<data || data_buffer>=data+size()) {

         assign(dx,dy,dz,dv);

         if (is_shared) std::memmove(data,data_buffer,siz*sizeof(T));

         else std::memcpy(data,data_buffer,siz*sizeof(T));

       } else {

         T *new_data = new T[siz];

         std::memcpy(new_data,data_buffer,siz*sizeof(T));

         delete[] data; data = new_data; width = dx; height = dy; depth = dz; dim = dv;

       }

       return *this;

     }


     template<typename t>

     CImg<T>& assign(const t *const data_buffer, const unsigned int dx, const unsigned int dy,

                     const unsigned int dz, const unsigned int dv, const bool shared) {

       if (shared)

         throw CImgArgumentException("CImg<%s>::assign() : Cannot assign buffer (%s*) to shared instance image (%u,%u,%u,%u,%p)"

                                     "(different pixel types).",

                                     pixel_type(),CImg<t>::pixel_type(),width,height,depth,dim,data);

       return assign(data_buffer,dx,dy,dz,dv);

     }


     CImg<T>& assign(const T *const data_buffer, const unsigned int dx, const unsigned int dy,

                     const unsigned int dz, const unsigned int dv, const bool shared) {

       const unsigned int siz = dx*dy*dz*dv;

       if (!data_buffer || !siz) return assign();

       if (!shared) { if (is_shared) assign(); assign(data_buffer,dx,dy,dz,dv); }

       else {

         if (!is_shared) {

           if (data_buffer+siz<data || data_buffer>=data+size()) assign();

           else cimg::warn("CImg<%s>::assign() : Shared instance image has overlapping memory !",

                           pixel_type());

         }

         width = dx; height = dy; depth = dz; dim = dv; is_shared = true;

         data = const_cast<T*>(data_buffer);

       }

       return *this;

     }


     CImg<T>& assign(const char *const filename) {

       return load(filename);

     }


     template<typename t>

     CImg<T>& assign(const CImg<t>& img) {

       return assign(img.data,img.width,img.height,img.depth,img.dim);

     }


     template<typename t>

     CImg<T>& assign(const CImg<t>& img, const bool shared) {

       return assign(img.data,img.width,img.height,img.depth,img.dim,shared);

     }


     template<typename t>

     CImg<T>& assign(const CImg<t>& img, const char *const dimensions) {

       if (!dimensions || !*dimensions) return assign(img.width,img.height,img.depth,img.dim);

       unsigned int siz[4] = { 0,1,1,1 }, k = 0;

       for (const char *s = dimensions; *s && k<4; ++k) {

         char item[256] = { 0 };

         if (std::sscanf(s,"%255[^0-9%xyzvwhdcXYZVWHDC]",item)>0) s+=std::strlen(item);

         if (*s) {

           unsigned int val = 0; char sep = 0;

           if (std::sscanf(s,"%u%c",&val,&sep)>0) {

             if (sep=='%') siz[k] = val*(k==0?width:k==1?height:k==2?depth:dim)/100;

             else siz[k] = val;

             while (*s>='0' && *s<='9') ++s; if (sep=='%') ++s;

           } else switch (cimg::uncase(*s)) {

           case 'x' : case 'w' : siz[k] = img.width; ++s; break;

           case 'y' : case 'h' : siz[k] = img.height; ++s; break;

           case 'z' : case 'd' : siz[k] = img.depth; ++s; break;

           case 'v' : case 'c' : siz[k] = img.dim; ++s; break;

           default :

             throw CImgArgumentException("CImg<%s>::assign() : Misplaced character '%c' in input dimension string '%s'.",

                                         pixel_type(),*s,dimensions);

           }

         }

       }

       return assign(siz[0],siz[1],siz[2],siz[3]);

     }


     template<typename t>

     CImg<T>& assign(const CImg<t>& img, const char *const dimensions, const T val) {

       return assign(img,dimensions).fill(val);

     }


     template<typename t>

     CImg<T>& assign(const CImg<t>& img, const char *const dimensions, const char *const values, const bool repeat_values) {

       return assign(img,dimensions).fill(values,repeat_values);

     }


     CImg<T>& assign(const CImgDisplay &disp) {

       disp.snapshot(*this);

       return *this;

     }


     template<typename t>

     CImg<t>& transfer_to(CImg<t>& img) {

       img.assign(*this);

       assign();

       return img;

     }


     CImg<T>& transfer_to(CImg<T>& img) {

       if (is_shared || img.is_shared) { img.assign(*this); assign(); } else { img.assign(); swap(img); }

       return img;

     }


     template<typename t>

     CImgList<t>& transfer_to(CImgList<t>& list, const unsigned int pos=~0U) {

       const unsigned int npos = pos>list.width?list.width:pos;

       transfer_to(list.insert(1,npos)[npos]);

       return list;

     }


     static CImg<T>& empty() {

       static CImg<T> _empty;

       return _empty.assign();

     }


     CImg<T>& swap(CImg<T>& img) {

       cimg::swap(width,img.width);

       cimg::swap(height,img.height);

       cimg::swap(depth,img.depth);

       cimg::swap(dim,img.dim);

       cimg::swap(data,img.data);

       cimg::swap(is_shared,img.is_shared);

       return img;

     }


     //------------------------------------------

     //


     //------------------------------------------


 #if cimg_debug>=3

     T& operator[](const unsigned int off) {

       if (!data || off>=size()) {

         cimg::warn("CImg<%s>::operator[] : Pixel access requested at offset=%u "

                    "outside the image range (%u,%u,%u,%u) (size=%u)",

                    pixel_type(),off,width,height,depth,dim,size());

         return *data;

       }

       else return data[off];

     }


     const T& operator[](const unsigned int off) const {

       return const_cast<CImg<T>*>(this)->operator[](off);

     }

 #else

     T& operator[](const unsigned int off) {

       return data[off];

     }


     const T& operator[](const unsigned int off) const {

       return data[off];

     }

 #endif


 #if cimg_debug>=3

     T& operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) {

       const unsigned int off = (unsigned int)offset(x,y,z,v);

       if (!data || off>=size()) {

         cimg::warn("CImg<%s>::operator() : Pixel access requested at (%u,%u,%u,%u) (offset=%u) "

                    "outside the image range (%u,%u,%u,%u) (size=%u)",

                    pixel_type(),x,y,z,v,off,width,height,depth,dim,size());

         return *data;

       }

       else return data[off];

     }


     const T& operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const {

       return const_cast<CImg<T>*>(this)->operator()(x,y,z,v);

     }

 #else

     T& operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) {

       return data[x + y*width + z*width*height + v*width*height*depth];

     }


     const T& operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const {

       return data[x + y*width + z*width*height + v*width*height*depth];

     }

 #endif


     operator bool() const {

       return data && width && height && depth && dim;

     }


     CImg<T>& operator=(const T val) {

       return fill(val);

     }


     CImg<T>& operator=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         fill(expression,true);

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         load(expression);

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator=(const CImg<t>& img) {

       return assign(img);

     }


     CImg<T>& operator=(const CImg<T>& img) {

       return assign(img);

     }


     CImg<T>& operator=(const CImgDisplay& disp) {

       disp.snapshot(*this);

       return *this;

     }


     template<typename t>

     CImg<T>& operator+=(const t val) {

       cimg_for(*this,ptr,T) (*ptr) = (T)((*ptr) + val);

       return *this;

     }


     CImg<T>& operator+=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator+=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)(*ptrd + mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this+=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator+=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this+=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)(*ptrd + *(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)(*ptrd + *(ptrs++));

       }

       return *this;

     }


     CImg<T>& operator++() {

       cimg_for(*this,ptr,T) ++(*ptr);

       return *this;

     }


     CImg<T> operator++(int) {

       const CImg<T> copy(*this,false);

       ++*this;

       return copy;

     }


     CImg<T> operator+() const {

       return CImg<T>(*this,false);

     }


     template<typename t>

     CImg<_cimg_Tt> operator+(const t val) const {

       return CImg<_cimg_Tt>(*this,false)+=val;

     }


     CImg<Tfloat> operator+(const char *const expression) const {

       return CImg<Tfloat>(*this,false)+=expression;

     }


     template<typename t>

     CImg<_cimg_Tt> operator+(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false)+=img;

     }


     template<typename t>

     CImg<T>& operator-=(const t val) {

       cimg_for(*this,ptr,T) (*ptr) = (T)((*ptr)-val);

       return *this;

     }


     CImg<T>& operator-=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator-=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)(*ptrd - mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this-=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator-=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this-=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)(*ptrd - *(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)(*ptrd - *(ptrs++));

       }

       return *this;

     }


     CImg<T>& operator--() {

       cimg_for(*this,ptr,T) *ptr = *ptr-(T)1;

       return *this;

     }


     CImg<T> operator--(int) {

       const CImg<T> copy(*this,false);

       --*this;

       return copy;

     }


     CImg<T> operator-() const {

       return CImg<T>(width,height,depth,dim,(T)0)-=*this;

     }


     template<typename t>

     CImg<_cimg_Tt> operator-(const t val) const {

       return CImg<_cimg_Tt>(*this,false)-=val;

     }


     CImg<Tfloat> operator-(const char *const expression) const {

       return CImg<Tfloat>(*this,false)-=expression;

     }


     template<typename t>

     CImg<_cimg_Tt> operator-(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false)-=img;

     }


     template<typename t>

     CImg<T>& operator*=(const t val) {

       cimg_for(*this,ptr,T) (*ptr) = (T)((*ptr)*val);

       return *this;

     }


     CImg<T>& operator*=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator*=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)(*ptrd * mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<Tfloat> values(width,height,depth,dim);

         values = expression;

         *this*=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator*=(const CImg<t>& img) {

       return ((*this)*img).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Tt> operator*(const t val) const {

       return CImg<_cimg_Tt>(*this,false)*=val;

     }


     CImg<Tfloat> operator*(const char *const expression) const {

       return CImg<Tfloat>(*this,false)*=expression;

     }


     template<typename t>

     CImg<_cimg_Tt> operator*(const CImg<t>& img) const {

       if (width!=img.height || depth!=1 || dim!=1)

         throw CImgArgumentException("operator*() : can't multiply a matrix image (%u,%u,%u,%u) by a matrix image (%u,%u,%u,%u)",

                                     width,height,depth,dim,img.width,img.height,img.depth,img.dim);

       CImg<_cimg_Tt> res(img.width,height);

       _cimg_Tt val;

 #ifdef cimg_use_openmp

 #pragma omp parallel for if (size()>=1000 && img.size()>=1000) private(val)

 #endif

       cimg_forXY(res,i,j) { val = 0; cimg_forX(*this,k) val+=(*this)(k,j)*img(i,k); res(i,j) = val; }

       return res;

     }


     template<typename t>

     CImg<T>& operator/=(const t val) {

       cimg_for(*this,ptr,T) (*ptr) = (T)((*ptr)/val);

       return *this;

     }


     CImg<T>& operator/=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator/=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)(*ptrd / mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<Tfloat> values(width,height,depth,dim);

         values = expression;

         *this/=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator/=(const CImg<t>& img) {

       return (*this*img.get_invert()).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Tt> operator/(const t val) const {

       return CImg<_cimg_Tt>(*this,false)/=val;

     }


     CImg<Tfloat> operator/(const char *const expression) const {

       return CImg<Tfloat>(*this,false)/=expression;

     }


     template<typename t>

     CImg<_cimg_Tt> operator/(const CImg<t>& img) const {

       return (*this)*img.get_invert();

     }


     template<typename t>

     CImg<T>& operator%=(const t val) {

       cimg_for(*this,ptr,T) (*ptr) = (T)cimg::mod(*ptr,(T)val);

       return *this;

     }


     CImg<T>& operator%=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator%=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)cimg::mod(*ptrd,(T)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this%=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator%=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this%=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = cimg::mod(*ptrd,(T)*(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = cimg::mod(*ptrd,(T)*(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> operator%(const t val) const {

       return CImg<_cimg_Tt>(*this,false)%=val;

     }


     CImg<Tfloat> operator%(const char *const expression) const {

       return CImg<Tfloat>(*this,false)%=expression;

     }


     template<typename t>

     CImg<_cimg_Tt> operator%(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false)%=img;

     }


     template<typename t>

     CImg<T>& operator&=(const t val) {

       cimg_for(*this,ptr,T) *ptr = (T)((unsigned long)*ptr & (unsigned long)val);

       return *this;

     }


     CImg<T>& operator&=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator&=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)((unsigned long)*ptrd & (unsigned long)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this&=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator&=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this&=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd & (unsigned long)*(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd & (unsigned long)*(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<T> operator&(const t val) const {

       return (+*this)&=val;

     }


     template<typename t>

     CImg<T>& operator|=(const t val) {

       cimg_for(*this,ptr,T) *ptr = (T)((unsigned long)*ptr | (unsigned long)val);

       return *this;

     }


     CImg<T>& operator|=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator|=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)((unsigned long)*ptrd | (unsigned long)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this|=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator|=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this|=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd | (unsigned long)*(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd | (unsigned long)*(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<T> operator|(const t val) const {

       return (+*this)|=val;

     }


     template<typename t>

     CImg<T>& operator^=(const t val) {

       cimg_for(*this,ptr,T) *ptr = (T)((unsigned long)*ptr ^ (unsigned long)val);

       return *this;

     }


     CImg<T>& operator^=(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"operator^=");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)((unsigned long)*ptrd ^ (unsigned long)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         cimg::exception_mode() = omode;

         CImg<T> values(width,height,depth,dim);

         values = expression;

         *this^=values;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     template<typename t>

     CImg<T>& operator^=(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return *this^=+img;

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd ^ (unsigned long)*(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)((unsigned long)*ptrd ^ (unsigned long)*(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<T> operator^(const t val) const {

       return (+*this)^=val;

     }


     CImg<T> operator~() const {

       CImg<T> res(width,height,depth,dim);

       const T *ptrs = end();

       cimg_for(res,ptrd,T) { const unsigned long val = (unsigned long)*(--ptrs); *ptrd = (T)~val; }

       return res;

     }


     CImg<T>& operator<<=(const int n) {

       cimg_for(*this,ptr,T) *ptr = (T)(((long)*ptr)<<n);

       return *this;

     }


     CImg<T> operator<<(const int n) const {

       return (+*this)<<=n;

     }


     CImg<T>& operator>>=(const int n) {

       cimg_for(*this,ptr,T) *ptr = (T)(((long)*ptr)>>n);

       return *this;

     }


     CImg<T> operator>>(const int n) const {

       return (+*this)>>=n;

     }


     template<typename t>

     bool operator==(const CImg<t>& img) const {

       const unsigned int siz = size();

       bool vequal = true;

       if (siz!=img.size()) return false;

       t *ptrs = img.data + siz;

       for (T *ptrd = data + siz; vequal && ptrd>data; vequal = vequal && ((*(--ptrd))==(*(--ptrs)))) {}

       return vequal;

     }


     template<typename t>

     bool operator!=(const CImg<t>& img) const {

       return !((*this)==img);

     }


     template<typename t>

     CImgList<_cimg_Tt> operator,(const CImg<t>& img) const {

       return CImgList<_cimg_Tt>(*this,img);

     }


     template<typename t>

     CImgList<_cimg_Tt> operator,(CImgList<t>& list) const {

       return CImgList<_cimg_Tt>(list).insert(*this,0);

     }


     CImgList<T> operator<(const char axis) const {

       return get_split(axis);

     }


     //-------------------------------------

     //


     //-------------------------------------


     static const char* pixel_type() {

       return cimg::type<T>::string();

     }


     int dimx() const {

       return (int)width;

     }


     int dimy() const {

       return (int)height;

     }


     int dimz() const {

       return (int)depth;

     }


     int dimv() const {

       return (int)dim;

     }


     unsigned int size() const {

       return width*height*depth*dim;

     }


     T* ptr() {

       return data;

     }


     const T* ptr() const {

       return data;

     }


 #if cimg_debug>=3

     T *ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) {

       const unsigned int off = (unsigned int)offset(x,y,z,v);

       if (off>=size()) {

         cimg::warn("CImg<%s>::ptr() : Asked for a pointer at coordinates (%u,%u,%u,%u) (offset=%u), "

                    "outside image range (%u,%u,%u,%u) (size=%u)",

                    pixel_type(),x,y,z,v,off,width,height,depth,dim,size());

         return data;

       }

       return data + off;

     }


     const T* ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const {

       return const_cast<CImg<T>*>(this)->ptr(x,y,z,v);

     }

 #else

     T* ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) {

       return data + x + y*width + z*width*height + v*width*height*depth;

     }


     const T* ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const {

       return data + x + y*width + z*width*height + v*width*height*depth;

     }

 #endif


     int offset(const int x, const int y=0, const int z=0, const int v=0) const {

       return x + y*width + z*width*height + v*width*height*depth;

     }


     iterator begin() {

       return data;

     }


     const_iterator begin() const {

       return data;

     }


     iterator end() {

       return data + size();

     }


     const_iterator end() const {

       return data + size();

     }


     const T& front() const {

       return *data;

     }


     T& front() {

       return *data;

     }


     const T& back() const {

       return *(data + size() - 1);

     }


     T& back() {

       return *(data + size() - 1);

     }


     T& at(const int off, const T out_val) {

       return (off<0 || off>=(int)size())?(cimg::temporary(out_val)=out_val):(*this)[off];

     }


     T at(const int off, const T out_val) const {

       return (off<0 || off>=(int)size())?out_val:(*this)[off];

     }


     T& at(const int off) {

       if (!size())

         throw CImgInstanceException("CImg<%s>::at() : Instance image is empty.",

                                     pixel_type());

       return _at(off);

     }


     T at(const int off) const {

       if (!size())

         throw CImgInstanceException("CImg<%s>::at() : Instance image is empty.",

                                     pixel_type());

       return _at(off);

     }


     T& _at(const int off) {

       const unsigned int siz = (unsigned int)size();

       return (*this)[off<0?0:(unsigned int)off>=siz?siz-1:off];

     }


     T _at(const int off) const {

       const unsigned int siz = (unsigned int)size();

       return (*this)[off<0?0:(unsigned int)off>=siz?siz-1:off];

     }


     T& atXYZV(const int x, const int y, const int z, const int v, const T out_val) {

       return (x<0 || y<0 || z<0 || v<0 || x>=dimx() || y>=dimy() || z>=dimz() || v>=dimv())?

         (cimg::temporary(out_val)=out_val):(*this)(x,y,z,v);

     }


     T atXYZV(const int x, const int y, const int z, const int v, const T out_val) const {

       return (x<0 || y<0 || z<0 || v<0 || x>=dimx() || y>=dimy() || z>=dimz() || v>=dimv())?out_val:(*this)(x,y,z,v);

     }


     T& atXYZV(const int x, const int y, const int z, const int v) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXYZV() : Instance image is empty.",

                                     pixel_type());

       return _atXYZV(x,y,z,v);

     }


     T atXYZV(const int x, const int y, const int z, const int v) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXYZV() : Instance image is empty.",

                                     pixel_type());

       return _atXYZV(x,y,z,v);

     }


     T& _atXYZV(const int x, const int y, const int z, const int v) {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x), y<0?0:(y>=dimy()?dimy()-1:y),

                      z<0?0:(z>=dimz()?dimz()-1:z), v<0?0:(v>=dimv()?dimv()-1:v));

     }


     T _atXYZV(const int x, const int y, const int z, const int v) const {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x), y<0?0:(y>=dimy()?dimy()-1:y),

                      z<0?0:(z>=dimz()?dimz()-1:z), v<0?0:(v>=dimv()?dimv()-1:v));

     }


     T& atXYZ(const int x, const int y, const int z, const int v, const T out_val) {

       return (x<0 || y<0 || z<0 || x>=dimx() || y>=dimy() || z>=dimz())?

         (cimg::temporary(out_val)=out_val):(*this)(x,y,z,v);

     }


     T atXYZ(const int x, const int y, const int z, const int v, const T out_val) const {

       return (x<0 || y<0 || z<0 || x>=dimx() || y>=dimy() || z>=dimz())?out_val:(*this)(x,y,z,v);

     }


     T& atXYZ(const int x, const int y, const int z, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXYZ() : Instance image is empty.",

                                     pixel_type());

       return _atXYZ(x,y,z,v);

     }


     T atXYZ(const int x, const int y, const int z, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXYZ() : Instance image is empty.",

                                     pixel_type());

       return _atXYZ(x,y,z,v);

     }


     T& _atXYZ(const int x, const int y, const int z, const int v=0) {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x),y<0?0:(y>=dimy()?dimy()-1:y),

                      z<0?0:(z>=dimz()?dimz()-1:z),v);

     }


     T _atXYZ(const int x, const int y, const int z, const int v=0) const {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x),y<0?0:(y>=dimy()?dimy()-1:y),

                      z<0?0:(z>=dimz()?dimz()-1:z),v);

     }


     T& atXY(const int x, const int y, const int z, const int v, const T out_val) {

       return (x<0 || y<0 || x>=dimx() || y>=dimy())?(cimg::temporary(out_val)=out_val):(*this)(x,y,z,v);

     }


     T atXY(const int x, const int y, const int z, const int v, const T out_val) const {

       return (x<0 || y<0 || x>=dimx() || y>=dimy())?out_val:(*this)(x,y,z,v);

     }


     T& atXY(const int x, const int y, const int z=0, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXY() : Instance image is empty.",

                                     pixel_type());

       return _atXY(x,y,z,v);

     }


     T atXY(const int x, const int y, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atXY() : Instance image is empty.",

                                     pixel_type());

       return _atXY(x,y,z,v);

     }


     T& _atXY(const int x, const int y, const int z=0, const int v=0) {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x), y<0?0:(y>=dimy()?dimy()-1:y),z,v);

     }


     T _atXY(const int x, const int y, const int z=0, const int v=0) const {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x), y<0?0:(y>=dimy()?dimy()-1:y),z,v);

     }


     T& atX(const int x, const int y, const int z, const int v, const T out_val) {

       return (x<0 || x>=dimx())?(cimg::temporary(out_val)=out_val):(*this)(x,y,z,v);

     }


     T atX(const int x, const int y, const int z, const int v, const T out_val) const {

       return (x<0 || x>=dimx())?out_val:(*this)(x,y,z,v);

     }


     T& atX(const int x, const int y=0, const int z=0, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atX() : Instance image is empty.",

                                     pixel_type());

       return _atX(x,y,z,v);

     }


     T atX(const int x, const int y=0, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::atX() : Instance image is empty.",

                                     pixel_type());

       return _atX(x,y,z,v);

     }


     T& _atX(const int x, const int y=0, const int z=0, const int v=0) {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x),y,z,v);

     }


     T _atX(const int x, const int y=0, const int z=0, const int v=0) const {

       return (*this)(x<0?0:(x>=dimx()?dimx()-1:x),y,z,v);

     }


     Tfloat linear_atXYZV(const float fx, const float fy, const float fz, const float fv, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1,

         y = (int)fy-(fy>=0?0:1), ny = y+1,

         z = (int)fz-(fz>=0?0:1), nz = z+1,

         v = (int)fv-(fv>=0?0:1), nv = v+1;

       const float

         dx = fx-x,

         dy = fy-y,

         dz = fz-z,

         dv = fv-v;

       const Tfloat

         Icccc = (Tfloat)atXYZV(x,y,z,v,out_val), Inccc = (Tfloat)atXYZV(nx,y,z,v,out_val),

         Icncc = (Tfloat)atXYZV(x,ny,z,v,out_val), Inncc = (Tfloat)atXYZV(nx,ny,z,v,out_val),

         Iccnc = (Tfloat)atXYZV(x,y,nz,v,out_val), Incnc = (Tfloat)atXYZV(nx,y,nz,v,out_val),

         Icnnc = (Tfloat)atXYZV(x,ny,nz,v,out_val), Innnc = (Tfloat)atXYZV(nx,ny,nz,v,out_val),

         Icccn = (Tfloat)atXYZV(x,y,z,nv,out_val), Inccn = (Tfloat)atXYZV(nx,y,z,nv,out_val),

         Icncn = (Tfloat)atXYZV(x,ny,z,nv,out_val), Inncn = (Tfloat)atXYZV(nx,ny,z,nv,out_val),

         Iccnn = (Tfloat)atXYZV(x,y,nz,nv,out_val), Incnn = (Tfloat)atXYZV(nx,y,nz,nv,out_val),

         Icnnn = (Tfloat)atXYZV(x,ny,nz,nv,out_val), Innnn = (Tfloat)atXYZV(nx,ny,nz,nv,out_val);

       return Icccc +

         dx*(Inccc-Icccc +

             dy*(Icccc+Inncc-Icncc-Inccc +

                 dz*(Iccnc+Innnc+Icncc+Inccc-Icnnc-Incnc-Icccc-Inncc +

                     dv*(Iccnn+Innnn+Icncn+Inccn+Icnnc+Incnc+Icccc+Inncc-Icnnn-Incnn-Icccn-Inncn-Iccnc-Innnc-Icncc-Inccc)) +

                 dv*(Icccn+Inncn+Icncc+Inccc-Icncn-Inccn-Icccc-Inncc)) +

             dz*(Icccc+Incnc-Iccnc-Inccc +

                 dv*(Icccn+Incnn+Iccnc+Inccc-Iccnn-Inccn-Icccc-Incnc)) +

             dv*(Icccc+Inccn-Inccc-Icccn)) +

         dy*(Icncc-Icccc +

             dz*(Icccc+Icnnc-Iccnc-Icncc +

                 dv*(Icccn+Icnnn+Iccnc+Icncc-Iccnn-Icncn-Icccc-Icnnc)) +

             dv*(Icccc+Icncn-Icncc-Icccn)) +

         dz*(Iccnc-Icccc +

             dv*(Icccc+Iccnn-Iccnc-Icccn)) +

         dv*(Icccn-Icccc);

     }


     Tfloat linear_atXYZV(const float fx, const float fy=0, const float fz=0, const float fv=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::linear_atXYZV() : Instance image is empty.",

                                     pixel_type());

       return _linear_atXYZV(fx,fy,fz,fv);

     }


     Tfloat _linear_atXYZV(const float fx, const float fy=0, const float fz=0, const float fv=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx),

         nfy = fy<0?0:(fy>height-1?height-1:fy),

         nfz = fz<0?0:(fz>depth-1?depth-1:fz),

         nfv = fv<0?0:(fv>dim-1?dim-1:fv);

       const unsigned int

         x = (unsigned int)nfx,

         y = (unsigned int)nfy,

         z = (unsigned int)nfz,

         v = (unsigned int)nfv;

       const float

         dx = nfx-x,

         dy = nfy-y,

         dz = nfz-z,

         dv = nfv-v;

       const unsigned int

         nx = dx>0?x+1:x,

         ny = dy>0?y+1:y,

         nz = dz>0?z+1:z,

         nv = dv>0?v+1:v;

       const Tfloat

         Icccc = (Tfloat)(*this)(x,y,z,v), Inccc = (Tfloat)(*this)(nx,y,z,v),

         Icncc = (Tfloat)(*this)(x,ny,z,v), Inncc = (Tfloat)(*this)(nx,ny,z,v),

         Iccnc = (Tfloat)(*this)(x,y,nz,v), Incnc = (Tfloat)(*this)(nx,y,nz,v),

         Icnnc = (Tfloat)(*this)(x,ny,nz,v), Innnc = (Tfloat)(*this)(nx,ny,nz,v),

         Icccn = (Tfloat)(*this)(x,y,z,nv), Inccn = (Tfloat)(*this)(nx,y,z,nv),

         Icncn = (Tfloat)(*this)(x,ny,z,nv), Inncn = (Tfloat)(*this)(nx,ny,z,nv),

         Iccnn = (Tfloat)(*this)(x,y,nz,nv), Incnn = (Tfloat)(*this)(nx,y,nz,nv),

         Icnnn = (Tfloat)(*this)(x,ny,nz,nv), Innnn = (Tfloat)(*this)(nx,ny,nz,nv);

       return Icccc +

         dx*(Inccc-Icccc +

             dy*(Icccc+Inncc-Icncc-Inccc +

                 dz*(Iccnc+Innnc+Icncc+Inccc-Icnnc-Incnc-Icccc-Inncc +

                     dv*(Iccnn+Innnn+Icncn+Inccn+Icnnc+Incnc+Icccc+Inncc-Icnnn-Incnn-Icccn-Inncn-Iccnc-Innnc-Icncc-Inccc)) +

                 dv*(Icccn+Inncn+Icncc+Inccc-Icncn-Inccn-Icccc-Inncc)) +

             dz*(Icccc+Incnc-Iccnc-Inccc +

                 dv*(Icccn+Incnn+Iccnc+Inccc-Iccnn-Inccn-Icccc-Incnc)) +

             dv*(Icccc+Inccn-Inccc-Icccn)) +

         dy*(Icncc-Icccc +

             dz*(Icccc+Icnnc-Iccnc-Icncc +

                 dv*(Icccn+Icnnn+Iccnc+Icncc-Iccnn-Icncn-Icccc-Icnnc)) +

             dv*(Icccc+Icncn-Icncc-Icccn)) +

         dz*(Iccnc-Icccc +

             dv*(Icccc+Iccnn-Iccnc-Icccn)) +

         dv*(Icccn-Icccc);

     }


     Tfloat linear_atXYZ(const float fx, const float fy, const float fz, const int v, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1,

         y = (int)fy-(fy>=0?0:1), ny = y+1,

         z = (int)fz-(fz>=0?0:1), nz = z+1;

       const float

         dx = fx-x,

         dy = fy-y,

         dz = fz-z;

       const Tfloat

         Iccc = (Tfloat)atXYZ(x,y,z,v,out_val), Incc = (Tfloat)atXYZ(nx,y,z,v,out_val),

         Icnc = (Tfloat)atXYZ(x,ny,z,v,out_val), Innc = (Tfloat)atXYZ(nx,ny,z,v,out_val),

         Iccn = (Tfloat)atXYZ(x,y,nz,v,out_val), Incn = (Tfloat)atXYZ(nx,y,nz,v,out_val),

         Icnn = (Tfloat)atXYZ(x,ny,nz,v,out_val), Innn = (Tfloat)atXYZ(nx,ny,nz,v,out_val);

       return Iccc +

         dx*(Incc-Iccc +

             dy*(Iccc+Innc-Icnc-Incc +

                 dz*(Iccn+Innn+Icnc+Incc-Icnn-Incn-Iccc-Innc)) +

             dz*(Iccc+Incn-Iccn-Incc)) +

         dy*(Icnc-Iccc +

             dz*(Iccc+Icnn-Iccn-Icnc)) +

         dz*(Iccn-Iccc);

     }


     Tfloat linear_atXYZ(const float fx, const float fy=0, const float fz=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::linear_atXYZ() : Instance image is empty.",

                                     pixel_type());

       return _linear_atXYZ(fx,fy,fz,v);

     }


     Tfloat _linear_atXYZ(const float fx, const float fy=0, const float fz=0, const int v=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx),

         nfy = fy<0?0:(fy>height-1?height-1:fy),

         nfz = fz<0?0:(fz>depth-1?depth-1:fz);

       const unsigned int

         x = (unsigned int)nfx,

         y = (unsigned int)nfy,

         z = (unsigned int)nfz;

       const float

         dx = nfx-x,

         dy = nfy-y,

         dz = nfz-z;

       const unsigned int

         nx = dx>0?x+1:x,

         ny = dy>0?y+1:y,

         nz = dz>0?z+1:z;

       const Tfloat

         Iccc = (Tfloat)(*this)(x,y,z,v), Incc = (Tfloat)(*this)(nx,y,z,v),

         Icnc = (Tfloat)(*this)(x,ny,z,v), Innc = (Tfloat)(*this)(nx,ny,z,v),

         Iccn = (Tfloat)(*this)(x,y,nz,v), Incn = (Tfloat)(*this)(nx,y,nz,v),

         Icnn = (Tfloat)(*this)(x,ny,nz,v), Innn = (Tfloat)(*this)(nx,ny,nz,v);

       return Iccc +

         dx*(Incc-Iccc +

             dy*(Iccc+Innc-Icnc-Incc +

                 dz*(Iccn+Innn+Icnc+Incc-Icnn-Incn-Iccc-Innc)) +

             dz*(Iccc+Incn-Iccn-Incc)) +

         dy*(Icnc-Iccc +

             dz*(Iccc+Icnn-Iccn-Icnc)) +

         dz*(Iccn-Iccc);

     }


     Tfloat linear_atXY(const float fx, const float fy, const int z, const int v, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1,

         y = (int)fy-(fy>=0?0:1), ny = y+1;

       const float

         dx = fx-x,

         dy = fy-y;

       const Tfloat

         Icc = (Tfloat)atXY(x,y,z,v,out_val),  Inc = (Tfloat)atXY(nx,y,z,v,out_val),

         Icn = (Tfloat)atXY(x,ny,z,v,out_val), Inn = (Tfloat)atXY(nx,ny,z,v,out_val);

       return Icc + dx*(Inc-Icc + dy*(Icc+Inn-Icn-Inc)) + dy*(Icn-Icc);

     }


     Tfloat linear_atXY(const float fx, const float fy, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::linear_atXY() : Instance image is empty.",

                                     pixel_type());

       return _linear_atXY(fx,fy,z,v);

     }


     Tfloat _linear_atXY(const float fx, const float fy, const int z=0, const int v=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx),

         nfy = fy<0?0:(fy>height-1?height-1:fy);

       const unsigned int

         x = (unsigned int)nfx,

         y = (unsigned int)nfy;

       const float

         dx = nfx-x,

         dy = nfy-y;

       const unsigned int

         nx = dx>0?x+1:x,

         ny = dy>0?y+1:y;

       const Tfloat

         Icc = (Tfloat)(*this)(x,y,z,v),  Inc = (Tfloat)(*this)(nx,y,z,v),

         Icn = (Tfloat)(*this)(x,ny,z,v), Inn = (Tfloat)(*this)(nx,ny,z,v);

       return Icc + dx*(Inc-Icc + dy*(Icc+Inn-Icn-Inc)) + dy*(Icn-Icc);

     }


     Tfloat linear_atX(const float fx, const int y, const int z, const int v, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1;

       const float

         dx = fx-x;

       const Tfloat

         Ic = (Tfloat)atX(x,y,z,v,out_val), In = (Tfloat)atXY(nx,y,z,v,out_val);

       return Ic + dx*(In-Ic);

     }


     Tfloat linear_atX(const float fx, const int y=0, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::linear_atX() : Instance image is empty.",

                                     pixel_type());

       return _linear_atX(fx,y,z,v);

     }


     Tfloat _linear_atX(const float fx, const int y=0, const int z=0, const int v=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx);

       const unsigned int

         x = (unsigned int)nfx;

       const float

         dx = nfx-x;

       const unsigned int

         nx = dx>0?x+1:x;

       const Tfloat

         Ic = (Tfloat)(*this)(x,y,z,v), In = (Tfloat)(*this)(nx,y,z,v);

       return Ic + dx*(In-Ic);

     }


     Tfloat cubic_atXY(const float fx, const float fy, const int z, const int v, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), px = x-1, nx = x+1, ax = x+2,

         y = (int)fy-(fy>=0?0:1), py = y-1, ny = y+1, ay = y+2;

       const float

         dx = fx-x, dx2 = dx*dx, dx3 = dx2*dx,

         dy = fy-y;

       const Tfloat

         Ipp = (Tfloat)atXY(px,py,z,v,out_val), Icp = (Tfloat)atXY(x,py,z,v,out_val),

         Inp = (Tfloat)atXY(nx,py,z,v,out_val), Iap = (Tfloat)atXY(ax,py,z,v,out_val),

         Ipc = (Tfloat)atXY(px,y,z,v,out_val),  Icc = (Tfloat)atXY(x,y,z,v,out_val),

         Inc = (Tfloat)atXY(nx,y,z,v,out_val),  Iac = (Tfloat)atXY(ax,y,z,v,out_val),

         Ipn = (Tfloat)atXY(px,ny,z,v,out_val), Icn = (Tfloat)atXY(x,ny,z,v,out_val),

         Inn = (Tfloat)atXY(nx,ny,z,v,out_val), Ian = (Tfloat)atXY(ax,ny,z,v,out_val),

         Ipa = (Tfloat)atXY(px,ay,z,v,out_val), Ica = (Tfloat)atXY(x,ay,z,v,out_val),

         Ina = (Tfloat)atXY(nx,ay,z,v,out_val), Iaa = (Tfloat)atXY(ax,ay,z,v,out_val),

         valm = cimg::min(cimg::min(Ipp,Icp,Inp,Iap),cimg::min(Ipc,Icc,Inc,Iac),cimg::min(Ipn,Icn,Inn,Ian),cimg::min(Ipa,Ica,Ina,Iaa)),

         valM = cimg::max(cimg::max(Ipp,Icp,Inp,Iap),cimg::max(Ipc,Icc,Inc,Iac),cimg::max(Ipn,Icn,Inn,Ian),cimg::max(Ipa,Ica,Ina,Iaa)),

         u0p = Icp - Ipp,

         u1p = Iap - Inp,

         ap = 2*(Icp-Inp) + u0p + u1p,

         bp = 3*(Inp-Icp) - 2*u0p - u1p,

         u0c = Icc - Ipc,

         u1c = Iac - Inc,

         ac = 2*(Icc-Inc) + u0c + u1c,

         bc = 3*(Inc-Icc) - 2*u0c - u1c,

         u0n = Icn - Ipn,

         u1n = Ian - Inn,

         an = 2*(Icn-Inn) + u0n + u1n,

         bn = 3*(Inn-Icn) - 2*u0n - u1n,

         u0a = Ica - Ipa,

         u1a = Iaa - Ina,

         aa = 2*(Ica-Ina) + u0a + u1a,

         ba = 3*(Ina-Ica) - 2*u0a - u1a,

         valp = ap*dx3 + bp*dx2 + u0p*dx + Icp,

         valc = ac*dx3 + bc*dx2 + u0c*dx + Icc,

         valn = an*dx3 + bn*dx2 + u0n*dx + Icn,

         vala = aa*dx3 + ba*dx2 + u0a*dx + Ica,

         u0 = valc - valp,

         u1 = vala - valn,

         a = 2*(valc-valn) + u0 + u1,

         b = 3*(valn-valc) - 2*u0 - u1,

         val = a*dy*dy*dy + b*dy*dy + u0*dy + valc;

       return val<valm?valm:(val>valM?valM:val);

     }


     Tfloat cubic_atXY(const float fx, const float fy, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::cubic_atXY() : Instance image is empty.",

                                     pixel_type());

       return _cubic_atXY(fx,fy,z,v);

     }


     Tfloat _cubic_atXY(const float fx, const float fy, const int z=0, const int v=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx),

         nfy = fy<0?0:(fy>height-1?height-1:fy);

       const int

         x = (int)nfx,

         y = (int)nfy;

       const float

         dx = nfx-x, dx2 = dx*dx, dx3 = dx2*dx,

         dy = nfy-y;

       const int

         px = x-1<0?0:x-1, nx = dx>0?x+1:x, ax = x+2>=dimx()?dimx()-1:x+2,

         py = y-1<0?0:y-1, ny = dy>0?y+1:y, ay = y+2>=dimy()?dimy()-1:y+2;

       const Tfloat

         Ipp = (Tfloat)(*this)(px,py,z,v), Icp = (Tfloat)(*this)(x,py,z,v),

         Inp = (Tfloat)(*this)(nx,py,z,v), Iap = (Tfloat)(*this)(ax,py,z,v),

         Ipc = (Tfloat)(*this)(px,y,z,v),  Icc = (Tfloat)(*this)(x,y,z,v),

         Inc = (Tfloat)(*this)(nx,y,z,v),  Iac = (Tfloat)(*this)(ax,y,z,v),

         Ipn = (Tfloat)(*this)(px,ny,z,v), Icn = (Tfloat)(*this)(x,ny,z,v),

         Inn = (Tfloat)(*this)(nx,ny,z,v), Ian = (Tfloat)(*this)(ax,ny,z,v),

         Ipa = (Tfloat)(*this)(px,ay,z,v), Ica = (Tfloat)(*this)(x,ay,z,v),

         Ina = (Tfloat)(*this)(nx,ay,z,v), Iaa = (Tfloat)(*this)(ax,ay,z,v),

         valm = cimg::min(cimg::min(Ipp,Icp,Inp,Iap),cimg::min(Ipc,Icc,Inc,Iac),cimg::min(Ipn,Icn,Inn,Ian),cimg::min(Ipa,Ica,Ina,Iaa)),

         valM = cimg::max(cimg::max(Ipp,Icp,Inp,Iap),cimg::max(Ipc,Icc,Inc,Iac),cimg::max(Ipn,Icn,Inn,Ian),cimg::max(Ipa,Ica,Ina,Iaa)),

         u0p = Icp - Ipp,

         u1p = Iap - Inp,

         ap = 2*(Icp-Inp) + u0p + u1p,

         bp = 3*(Inp-Icp) - 2*u0p - u1p,

         u0c = Icc - Ipc,

         u1c = Iac - Inc,

         ac = 2*(Icc-Inc) + u0c + u1c,

         bc = 3*(Inc-Icc) - 2*u0c - u1c,

         u0n = Icn - Ipn,

         u1n = Ian - Inn,

         an = 2*(Icn-Inn) + u0n + u1n,

         bn = 3*(Inn-Icn) - 2*u0n - u1n,

         u0a = Ica - Ipa,

         u1a = Iaa - Ina,

         aa = 2*(Ica-Ina) + u0a + u1a,

         ba = 3*(Ina-Ica) - 2*u0a - u1a,

         valp = ap*dx3 + bp*dx2 + u0p*dx + Icp,

         valc = ac*dx3 + bc*dx2 + u0c*dx + Icc,

         valn = an*dx3 + bn*dx2 + u0n*dx + Icn,

         vala = aa*dx3 + ba*dx2 + u0a*dx + Ica,

         u0 = valc - valp,

         u1 = vala - valn,

         a = 2*(valc-valn) + u0 + u1,

         b = 3*(valn-valc) - 2*u0 - u1,

         val = a*dy*dy*dy + b*dy*dy + u0*dy + valc;

       return val<valm?valm:(val>valM?valM:val);

     }


     Tfloat cubic_atX(const float fx, const int y, const int z, const int v, const T out_val) const {

       const int

         x = (int)fx-(fx>=0?0:1), px = x-1, nx = x+1, ax = x+2;

       const float

         dx = fx-x;

       const Tfloat

         Ip = (Tfloat)atX(px,y,z,v,out_val), Ic = (Tfloat)atX(x,y,z,v,out_val),

         In = (Tfloat)atX(nx,y,z,v,out_val), Ia = (Tfloat)atX(ax,y,z,v,out_val),

         valm = cimg::min(Ip,In,Ic,Ia), valM = cimg::max(Ip,In,Ic,Ia),

         u0 = Ic - Ip,

         u1 = Ia - In,

         a = 2*(Ic-In) + u0 + u1,

         b = 3*(In-Ic) - 2*u0 - u1,

         val = a*dx*dx*dx + b*dx*dx + u0*dx + Ic;

       return val<valm?valm:(val>valM?valM:val);

     }


     Tfloat cubic_atX(const float fx, const int y=0, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::cubic_atX() : Instance image is empty.",

                                     pixel_type());

       return _cubic_atX(fx,y,z,v);

     }


     Tfloat _cubic_atX(const float fx, const int y=0, const int z=0, const int v=0) const {

       const float

         nfx = fx<0?0:(fx>width-1?width-1:fx);

       const int

         x = (int)nfx;

       const float

         dx = nfx-x;

       const int

         px = x-1<0?0:x-1, nx = dx>0?x+1:x, ax = x+2>=dimx()?dimx()-1:x+2;

       const Tfloat

         Ip = (Tfloat)(*this)(px,y,z,v), Ic = (Tfloat)(*this)(x,y,z,v),

         In = (Tfloat)(*this)(nx,y,z,v), Ia = (Tfloat)(*this)(ax,y,z,v),

         valm = cimg::min(Ip,In,Ic,Ia), valM = cimg::max(Ip,In,Ic,Ia),

         u0 = Ic - Ip,

         u1 = Ia - In,

         a = 2*(Ic-In) + u0 + u1,

         b = 3*(In-Ic) - 2*u0 - u1,

         val = a*dx*dx*dx + b*dx*dx + u0*dx + Ic;

       return val<valm?valm:(val>valM?valM:val);

     }


     CImg& set_linear_atXYZ(const T& val, const float fx, const float fy=0, const float fz=0, const int v=0,

                            const bool add=false) {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1,

         y = (int)fy-(fy>=0?0:1), ny = y+1,

         z = (int)fz-(fz>=0?0:1), nz = z+1;

       const float

         dx = fx-x,

         dy = fy-y,

         dz = fz-z;

       if (v>=0 && v<dimv()) {

         if (z>=0 && z<dimz()) {

           if (y>=0 && y<dimy()) {

             if (x>=0 && x<dimx()) {

               const float w1 = (1-dx)*(1-dy)*(1-dz), w2 = add?1:(1-w1);

               (*this)(x,y,z,v) = (T)(w1*val + w2*(*this)(x,y,z,v));

             }

             if (nx>=0 && nx<dimx()) {

               const float w1 = dx*(1-dy)*(1-dz), w2 = add?1:(1-w1);

               (*this)(nx,y,z,v) = (T)(w1*val + w2*(*this)(nx,y,z,v));

             }

           }

           if (ny>=0 && ny<dimy()) {

             if (x>=0 && x<dimx()) {

               const float w1 = (1-dx)*dy*(1-dz), w2 = add?1:(1-w1);

               (*this)(x,ny,z,v) = (T)(w1*val + w2*(*this)(x,ny,z,v));

             }

             if (nx>=0 && nx<dimx()) {

               const float w1 = dx*dy*(1-dz), w2 = add?1:(1-w1);

               (*this)(nx,ny,z,v) = (T)(w1*val + w2*(*this)(nx,ny,z,v));

             }

           }

         }

         if (nz>=0 && nz<dimz()) {

           if (y>=0 && y<dimy()) {

             if (x>=0 && x<dimx()) {

               const float w1 = (1-dx)*(1-dy), w2 = add?1:(1-w1);

               (*this)(x,y,nz,v) = (T)(w1*val + w2*(*this)(x,y,nz,v));

             }

             if (nx>=0 && nx<dimx()) {

               const float w1 = dx*(1-dy), w2 = add?1:(1-w1);

               (*this)(nx,y,nz,v) = (T)(w1*val + w2*(*this)(nx,y,nz,v));

             }

           }

           if (ny>=0 && ny<dimy()) {

             if (x>=0 && x<dimx()) {

               const float w1 = (1-dx)*dy, w2 = add?1:(1-w1);

               (*this)(x,ny,nz,v) = (T)(w1*val + w2*(*this)(x,ny,nz,v));

             }

             if (nx>=0 && nx<dimx()) {

               const float w1 = dx*dy, w2 = add?1:(1-w1);

               (*this)(nx,ny,nz,v) = (T)(w1*val + w2*(*this)(nx,ny,nz,v));

             }

           }

         }

       }

       return *this;

     }


     CImg& set_linear_atXY(const T& val, const float fx, const float fy=0, const int z=0, const int v=0,

                           const bool add=false) {

       const int

         x = (int)fx-(fx>=0?0:1), nx = x+1,

         y = (int)fy-(fy>=0?0:1), ny = y+1;

       const float

         dx = fx-x,

         dy = fy-y;

       if (z>=0 && z<dimz() && v>=0 && v<dimv()) {

         if (y>=0 && y<dimy()) {

           if (x>=0 && x<dimx()) {

             const float w1 = (1-dx)*(1-dy), w2 = add?1:(1-w1);

             (*this)(x,y,z,v) = (T)(w1*val + w2*(*this)(x,y,z,v));

           }

           if (nx>=0 && nx<dimx()) {

             const float w1 = dx*(1-dy), w2 = add?1:(1-w1);

             (*this)(nx,y,z,v) = (T)(w1*val + w2*(*this)(nx,y,z,v));

           }

         }

         if (ny>=0 && ny<dimy()) {

           if (x>=0 && x<dimx()) {

             const float w1 = (1-dx)*dy, w2 = add?1:(1-w1);

             (*this)(x,ny,z,v) = (T)(w1*val + w2*(*this)(x,ny,z,v));

           }

           if (nx>=0 && nx<dimx()) {

             const float w1 = dx*dy, w2 = add?1:(1-w1);

             (*this)(nx,ny,z,v) = (T)(w1*val + w2*(*this)(nx,ny,z,v));

           }

         }

       }

       return *this;

     }


     CImg<charT> value_string(const char separator=',', const unsigned int max_size=0) const {

       if (is_empty()) return CImg<charT>(1,1,1,1,0);

       const unsigned int siz = (unsigned int)size();

       CImgList<charT> items;

       char item[256] = { 0 };

       const T *ptrs = ptr();

       for (unsigned int off = 0; off<siz-1; ++off) {

         std::sprintf(item,cimg::type<T>::format(),cimg::type<T>::format(*(ptrs++)));

         const unsigned int l = std::strlen(item);

         CImg<charT>(item,l+1).transfer_to(items).back()[l] = separator;

       }

       std::sprintf(item,cimg::type<T>::format(),cimg::type<T>::format(*ptrs));

       CImg<charT>(item,std::strlen(item)+1).transfer_to(items);

       CImg<ucharT> res; (items>'x').transfer_to(res);

       if (max_size) { res.crop(0,max_size); res(max_size) = 0; }

       return res;

     }


     //-------------------------------------

     //


     //-------------------------------------


     bool is_empty() const {

       return !(data && width && height && depth && dim);

     }


     bool is_sameX(const unsigned int dx) const {

       return (width==dx);

     }


     template<typename t>

     bool is_sameX(const CImg<t>& img) const {

       return is_sameX(img.width);

     }


     bool is_sameX(const CImgDisplay& disp) const {

       return is_sameX(disp.width);

     }


     bool is_sameY(const unsigned int dy) const {

       return (height==dy);

     }


     template<typename t>

     bool is_sameY(const CImg<t>& img) const {

       return is_sameY(img.height);

     }


     bool is_sameY(const CImgDisplay& disp) const {

       return is_sameY(disp.height);

     }


     bool is_sameZ(const unsigned int dz) const {

       return (depth==dz);

     }


     template<typename t>

     bool is_sameZ(const CImg<t>& img) const {

       return is_sameZ(img.depth);

     }


     bool is_sameV(const unsigned int dv) const {

       return (dim==dv);

     }


     template<typename t>

     bool is_sameV(const CImg<t>& img) const {

       return is_sameV(img.dim);

     }


     bool is_sameXY(const unsigned int dx, const unsigned int dy) const {

       return (is_sameX(dx) && is_sameY(dy));

     }


     template<typename t>

     bool is_sameXY(const CImg<t>& img) const {

       return (is_sameX(img) && is_sameY(img));

     }


     bool is_sameXY(const CImgDisplay& disp) const {

       return (is_sameX(disp) && is_sameY(disp));

     }


     bool is_sameXZ(const unsigned int dx, const unsigned int dz) const {

       return (is_sameX(dx) && is_sameZ(dz));

     }


     template<typename t>

     bool is_sameXZ(const CImg<t>& img) const {

       return (is_sameX(img) && is_sameZ(img));

     }


     bool is_sameXV(const unsigned int dx, const unsigned int dv) const {

       return (is_sameX(dx) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameXV(const CImg<t>& img) const {

       return (is_sameX(img) && is_sameV(img));

     }


     bool is_sameYZ(const unsigned int dy, const unsigned int dz) const {

       return (is_sameY(dy) && is_sameZ(dz));

     }


     template<typename t>

     bool is_sameYZ(const CImg<t>& img) const {

       return (is_sameY(img) && is_sameZ(img));

     }


     bool is_sameYV(const unsigned int dy, const unsigned int dv) const {

       return (is_sameY(dy) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameYV(const CImg<t>& img) const {

       return (is_sameY(img) && is_sameV(img));

     }


     bool is_sameZV(const unsigned int dz, const unsigned int dv) const {

       return (is_sameZ(dz) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameZV(const CImg<t>& img) const {

       return (is_sameZ(img) && is_sameV(img));

     }


     bool is_sameXYZ(const unsigned int dx, const unsigned int dy, const unsigned int dz) const {

       return (is_sameXY(dx,dy) && is_sameZ(dz));

     }


     template<typename t>

     bool is_sameXYZ(const CImg<t>& img) const {

       return (is_sameXY(img) && is_sameZ(img));

     }


     bool is_sameXYV(const unsigned int dx, const unsigned int dy, const unsigned int dv) const {

       return (is_sameXY(dx,dy) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameXYV(const CImg<t>& img) const {

       return (is_sameXY(img) && is_sameV(img));

     }


     bool is_sameXZV(const unsigned int dx, const unsigned int dz, const unsigned int dv) const {

       return (is_sameXZ(dx,dz) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameXZV(const CImg<t>& img) const {

       return (is_sameXZ(img) && is_sameV(img));

     }


     bool is_sameYZV(const unsigned int dy, const unsigned int dz, const unsigned int dv) const {

       return (is_sameYZ(dy,dz) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameYZV(const CImg<t>& img) const {

       return (is_sameYZ(img) && is_sameV(img));

     }


     bool is_sameXYZV(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const {

       return (is_sameXYZ(dx,dy,dz) && is_sameV(dv));

     }


     template<typename t>

     bool is_sameXYZV(const CImg<t>& img) const {

       return (is_sameXYZ(img) && is_sameV(img));

     }


     bool containsXYZV(const int x, const int y=0, const int z=0, const int v=0) const {

       return !is_empty() && x>=0 && x<dimx() && y>=0 && y<dimy() && z>=0 && z<dimz() && v>=0 && v<dimv();

     }


     template<typename t>

     bool contains(const T& pixel, t& x, t& y, t& z, t& v) const {

       const unsigned int wh = width*height, whz = wh*depth, siz = whz*dim;

       const T *const ppixel = &pixel;

       if (is_empty() || ppixel<data || ppixel>=data+siz) return false;

       unsigned int off = (unsigned int)(ppixel - data);

       const unsigned int nv = off/whz;

       off%=whz;

       const unsigned int nz = off/wh;

       off%=wh;

       const unsigned int ny = off/width, nx = off%width;

       x = (t)nx; y = (t)ny; z = (t)nz; v = (t)nv;

       return true;

     }


     template<typename t>

     bool contains(const T& pixel, t& x, t& y, t& z) const {

       const unsigned int wh = width*height, whz = wh*depth, siz = whz*dim;

       const T *const ppixel = &pixel;

       if (is_empty() || ppixel<data || ppixel>=data+siz) return false;

       unsigned int off = ((unsigned int)(ppixel - data))%whz;

       const unsigned int nz = off/wh;

       off%=wh;

       const unsigned int ny = off/width, nx = off%width;

       x = (t)nx; y = (t)ny; z = (t)nz;

       return true;

     }


     template<typename t>

     bool contains(const T& pixel, t& x, t& y) const {

       const unsigned int wh = width*height, siz = wh*depth*dim;

       const T *const ppixel = &pixel;

       if (is_empty() || ppixel<data || ppixel>=data+siz) return false;

       unsigned int off = ((unsigned int)(ppixel - data))%wh;

       const unsigned int ny = off/width, nx = off%width;

       x = (t)nx; y = (t)ny;

       return true;

     }


     template<typename t>

     bool contains(const T& pixel, t& x) const {

       const T *const ppixel = &pixel;

       if (is_empty() || ppixel<data || ppixel>=data+size()) return false;

       x = (t)(((unsigned int)(ppixel - data))%width);

       return true;

     }


     bool contains(const T& pixel) const {

       const T *const ppixel = &pixel;

       return !is_empty() && ppixel>=data && ppixel<data+size();

     }


     template<typename t>

     bool is_overlapped(const CImg<t>& img) const {

       const unsigned int csiz = size(), isiz = img.size();

       return !((void*)(data+csiz)<=(void*)img.data || (void*)data>=(void*)(img.data+isiz));

     }


     template<typename tf>

     bool is_object3d(const CImgList<tf>& primitives, const bool check_primitives=true,

                      const bool throw_exception=false, const char *const calling_function=0) const {

       const char *const ncall = calling_function?calling_function:"is_object3d";

       if (is_empty()) { // Check for empty object.

         if (primitives) {

           if (throw_exception)

             throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, %u primitives defined for 0 vertices.",

                                         pixel_type(),ncall,primitives.width);

           return false;

         }

         return true;

       }

       if (height!=3 || depth>1 || dim>1) { // Check vertices dimensions.

         if (throw_exception)

           throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                       pixel_type(),ncall,width,height,depth,dim,data);

         return false;

       }

       if (check_primitives) cimglist_for(primitives,l) {

         const CImg<tf>& primitive = primitives[l];

         const unsigned int psiz = primitive.size();

         switch (psiz) {

         case 1 : { // Point.

           const unsigned int i0 = (unsigned int)primitive[0];

           if (i0>=width) {

             if (throw_exception)

               throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, primitive %u = point(%u) references invalid vertice "

                                           "(%u vertices available).",pixel_type(),ncall,l,i0,width);

             return false;

           }

         } break;

         case 5 : { // Sphere.

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2);

           if (i0>=width || (!i2 && i1>=width)) {

             if (throw_exception)

               throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, primitive %u = sphere(%u,%u,%u) references invalid vertice "

                                           "(%u vertices available).",pixel_type(),ncall,l,i0,i1,i2,width);

             return false;

           }

         } break;

         case 2 : // Segment.

         case 6 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1);

           if (i0>=width || i1>=width) {

             if (throw_exception)

               throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, primitive %u = segment(%u,%u) references invalid vertice "

                                           "(%u vertices available).",pixel_type(),ncall,l,i0,i1,width);

             return false;

           }

         } break;

         case 3 : // Triangle.

         case 9 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2);

           if (i0>=width || i1>=width || i2>=width) {

             if (throw_exception)

               throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, primitive %u = triangle(%u,%u,%u) references invalid vertice "

                                           "(%u vertices available).",pixel_type(),ncall,l,i0,i1,i2,width);

             return false;

           }

         } break;

         case 4 : // Rectangle

         case 12 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2),

             i3 = (unsigned int)primitive(3);

           if (i0>=width || i1>=width || i2>=width || i3>=width) {

             if (throw_exception)

               throw CImgArgumentException("CImg<%s>::%s() : Invalid 3D object, primitive %u = rectangle(%u,%u,%u,%u) references invalid vertice "

                                           "(%u vertices available).",pixel_type(),ncall,l,i0,i1,i2,i3,width);

             return false;

           }

         } break;

         default : return false;

         }

       }

       return true;

     }


     //-------------------------------------

     //


     //-------------------------------------


     // Define the math formula parser/compiler and evaluator.

     struct _cimg_math_parser {

       CImgList<uintT> code;

       CImg<doubleT> mem;

       unsigned int mempos, *level, result;

       const char *calling_function;

       char *expr;

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

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

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

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

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

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


       // Constructor - Destructor.

       _cimg_math_parser(const char *const expression, const char *const funcname=0):level(0),calling_function(funcname),expr(0) {

         static const char *const funcname0 = "cimg_math_parser";

         if (!funcname) calling_function = funcname0;

         if (!expression) return;

         unsigned int l0 = std::strlen(expression);

         expr = new char[l0+1];

         std::strcpy(expr,expression);

         cimg::strclean(expr);

         if (!*expr) return;

         char *d = expr; for (const char *s = expr; *s || (bool)(*d=0); ++s) if (*s!=' ') *(d++) = *s;

         const unsigned int l = d - expr;

         if (!l) return;

         cimg::uncase(expr);

         int lv = 0; // Count parenthesis level of expression.

         unsigned int *pd = level = new unsigned int[l];

         for (const char *ps = expr; *ps && lv>=0; ++ps) *(pd++) = (unsigned int)(*ps=='('?lv++:*ps==')'?--lv:lv);

         if (lv!=0) throw CImgArgumentException("CImg<%s>::%s() : Unbalanced parenthesis, in formula '%s'.",

                                                pixel_type(),calling_function,expr);

         mem.assign(1024); // Compile formula into serie of opcodes.

         mem[8] = cimg::valuePI; mem[9] = std::exp(1.0); mem[10] = 0; mempos = 11;

         result = compile(expr,expr+l);

       }

       ~_cimg_math_parser() { if (level) delete[] level; if (expr) delete[] expr; }


       // Insert code instruction.

       unsigned int opcode(const char op, const unsigned int arg1=0, const unsigned int arg2=0,

                           const unsigned int arg3=0, const unsigned int arg4=0, const unsigned int arg5=0) {

         if (mempos>=mem.size()) mem.resize(-200,1,1,1,0);

         const unsigned int pos = mempos++;

         CImg<uintT>::vector(op,pos,arg1,arg2,arg3,arg4,arg5).transfer_to(code);

         return pos;

       }


       // Compilation procedure.

       unsigned int compile(char *const ss, char *const se) {

         if (!ss || se<=ss || !*ss) throw CImgArgumentException("CImg<%s>::%s() : Missing item, in formula '%s'.",

                                                                pixel_type(),calling_function,expr);

         char

           *const se1 = se-1, *const se2 = se-2, *const se3 = se-3, *const se4 = se-4,

           *const ss1 = ss+1, *const ss2 = ss+2, *const ss3 = ss+3, *const ss4 = ss+4, *const ss5 = ss+5, *const ss6 = ss+6;

         const char saved_char = *se; *se = 0;

         const unsigned int clevel = level[ss-expr], clevel1 = clevel+1;


         // Look for a single value, variable or reccurent expression.

         char end = 0; double val = 0;

         if (std::sscanf(ss,"%lf%c",&val,&end)==1) {

           const unsigned int i = mempos++;

           mem[i] = val;

           _cimg_freturn(i);

         }

         if (ss1==se) switch (*ss) {

         case 'x' : _cimg_freturn(0); case 'y' : _cimg_freturn(1); case 'z' : _cimg_freturn(2); case 'v' : _cimg_freturn(3);

         case 'w' : _cimg_freturn(4); case 'h' : _cimg_freturn(5); case 'd' : _cimg_freturn(6); case 'c' : _cimg_freturn(7);

         case 'e' : _cimg_freturn(9);

         case 'u' : _cimg_fopcode0('U');

         case 'g' : _cimg_fopcode0('G');

         case 'i' : _cimg_fopcode0('I');

         }

         if (ss1==se1 && *ss=='p' && *ss1=='i') _cimg_freturn(8); // pi-value

         if (ss3==se) {

           if (*ss=='x' && *ss1=='/' && *ss2=='w') _cimg_fopcode0('0');

           if (*ss=='y' && *ss1=='/' && *ss2=='h') _cimg_fopcode0('1');

           if (*ss=='z' && *ss1=='/' && *ss2=='d') _cimg_fopcode0('2');

           if (*ss=='v' && *ss1=='/' && *ss2=='c') _cimg_fopcode0('3');

         }


         // Look for a unary of binary operators.

         for (char *s = ss1, *ns = 0; s<se3 && (ns=std::strstr(s,"and")) && ns<se3; s=ns+3)

           if (level[ns-expr]==clevel) _cimg_fopcode2('A',compile(ss,ns),compile(ns+3,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"&&")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('A',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se3 && (ns=std::strstr(s,"xor")) && ns<se3; s=ns+3)

           if (level[ns-expr]==clevel) _cimg_fopcode2('X',compile(ss,ns),compile(ns+3,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"or")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('O',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"||")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('O',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"<=")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('l',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,">=")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('g',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"!=")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('!',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se2 && (ns=std::strstr(s,"==")) && ns<se2; s=ns+2)

           if (level[ns-expr]==clevel) _cimg_fopcode2('=',compile(ss,ns),compile(ns+2,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,">")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('>',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"<")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('<',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"+")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('+',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"-")) && ns<se1; s=ns+1) {

           const char ps = *(ns-1);

           if (ps!='*' && ps!='/' && ps!='%' && ps!='^' && ps!='&' && ps!='|' && ps!='^' &&

               level[ns-expr]==clevel) _cimg_fopcode2('-',compile(ss,ns),compile(ns+1,se));

         }

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"*")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('*',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"/")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('/',compile(ss,ns),compile(ns+1,se));

         if (ss<se1) {

           if (*ss=='-') _cimg_fopcode1('o',compile(ss1,se));

           if (*ss=='+') _cimg_fopcode1('p',compile(ss1,se));

           if (*ss=='!') _cimg_fopcode1('n',compile(ss1,se));

           if (*ss=='~') _cimg_fopcode1('~',compile(ss1,se));

         }

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"%")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('%',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se3 && (ns=std::strstr(s,"mod")) && ns<se3; s=ns+3)

           if (level[ns-expr]==clevel) _cimg_fopcode2('%',compile(ss,ns),compile(ns+3,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"&")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('&',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"|")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('|',compile(ss,ns),compile(ns+1,se));

         for (char *s = ss1, *ns = 0; s<se1 && (ns=std::strstr(s,"^")) && ns<se1; s=ns+1)

           if (level[ns-expr]==clevel) _cimg_fopcode2('^',compile(ss,ns),compile(ns+1,se));


         // Look for a function call or a parenthesis.

         if (*se1==')') {

           if (*ss=='(') _cimg_freturn(compile(ss1,se1));

           if (!std::strncmp(ss,"sin(",4)) _cimg_fopcode1('s',compile(ss4,se1));

           if (!std::strncmp(ss,"cos(",4)) _cimg_fopcode1('c',compile(ss4,se1));

           if (!std::strncmp(ss,"tan(",4)) _cimg_fopcode1('t',compile(ss4,se1));

           if (!std::strncmp(ss,"asin(",5)) _cimg_fopcode1('S',compile(ss5,se1));

           if (!std::strncmp(ss,"acos(",5)) _cimg_fopcode1('C',compile(ss5,se1));

           if (!std::strncmp(ss,"atan(",5)) _cimg_fopcode1('T',compile(ss5,se1));

           if (!std::strncmp(ss,"sinh(",5)) _cimg_fopcode1('.',compile(ss5,se1));

           if (!std::strncmp(ss,"cosh(",5)) _cimg_fopcode1(',',compile(ss5,se1));

           if (!std::strncmp(ss,"tanh(",5)) _cimg_fopcode1(';',compile(ss5,se1));

           if (!std::strncmp(ss,"log10(",6)) _cimg_fopcode1('Q',compile(ss6,se1));

           if (!std::strncmp(ss,"log(",4)) _cimg_fopcode1('q',compile(ss4,se1));

           if (!std::strncmp(ss,"ln(",3)) _cimg_fopcode1('q',compile(ss3,se1));

           if (!std::strncmp(ss,"exp(",4)) _cimg_fopcode1('e',compile(ss4,se1));

           if (!std::strncmp(ss,"sqrt(",5)) _cimg_fopcode1('r',compile(ss5,se1));

           if (!std::strncmp(ss,"sign(",5)) _cimg_fopcode1('\\',compile(ss5,se1));

           if (!std::strncmp(ss,"rint(",5)) _cimg_fopcode1('i',compile(ss5,se1));

           if (!std::strncmp(ss,"abs(",4)) _cimg_fopcode1(':',compile(ss4,se1));

           if (!std::strncmp(ss,"atan2(",6)) {

             char *s1 = ss6; while (s1<se2 && (*s1!=',' || level[s1-expr]!=clevel1)) ++s1;

             _cimg_fopcode2('#',compile(ss6,s1),compile(s1+1,se1));

           }

           if (!std::strncmp(ss,"if(",3)) {

             char *s1 = ss3; while (s1<se4 && (*s1!=',' || level[s1-expr]!=clevel1)) ++s1;

             char *s2 = s1+1; while (s2<se2 && (*s2!=',' || level[s2-expr]!=clevel1)) ++s2;

             _cimg_fopcode3('?',compile(ss3,s1),compile(s1+1,s2),compile(s2+1,se1));

           }

           if (!std::strncmp(ss,"i(",2)) {

             unsigned int indx = 0, indy = 1, indz = 2, indv = 3, borders = 10;

             if (ss2!=se1) {

               char *s1 = ss2; while (s1<se2 && (*s1!=',' || level[s1-expr]!=clevel1)) ++s1;

               indx = compile(ss2,s1==se2?++s1:s1);

               if (s1<se1) {

                 char *s2 = s1+1; while (s2<se2 && (*s2!=',' || level[s2-expr]!=clevel1)) ++s2;

                 indy = compile(s1+1,s2==se2?++s2:s2);

                 if (s2<se1) {

                   char *s3 = s2+1; while (s3<se2 && (*s3!=',' || level[s3-expr]!=clevel1)) ++s3;

                   indz = compile(s2+1,s3==se2?++s3:s3);

                   if (s3<se1) {

                     char *s4 = s3+1; while (s4<se2 && (*s4!=',' || level[s4-expr]!=clevel1)) ++s4;

                     indv = compile(s3+1,s4==se2?++s4:s4);

                     if (s4<se1) borders = compile(s4+1,se1);

                   }

                 }

               }

             }

             _cimg_fopcode5('(',indx,indy,indz,indv,borders);

           }

           if (!std::strncmp(ss,"min(",4) || !std::strncmp(ss,"max(",4)) {

             CImgList<uintT> opcode;

             if (mempos>=mem.size()) mem.resize(-200,1,1,1,0); const unsigned int pos = mempos++;

             CImg<uintT>::vector(ss[1]=='i'?'m':'M',pos).transfer_to(opcode);

             for (char *s = ss4; s<se; ++s) {

               char *ns = s; while (ns<se && (*ns!=',' || level[ns-expr]!=clevel1) && (*ns!=')' || level[ns-expr]!=clevel)) ++ns;

               CImg<uintT>::vector(compile(s,ns)).transfer_to(opcode);

               s = ns;

             }

             (opcode>'y').transfer_to(code);

             _cimg_freturn(pos);

           }

         }

         // No known item found.

         char *item = new char[std::strlen(ss)];

         std::strcpy(item,ss);

         *se = saved_char;

         throw CImgArgumentException("CImg<%s>::%s() : Invalid item '%s', in expression '%s'.",

                                     pixel_type(),calling_function,item,expr);

         return 0;

       }


       // Evaluation procedure, with image data.

       template<typename t>

       double eval(const CImg<t>& img, const double x, const double y, const double z, const double v) {

         if (!mem) return 0;

         mem[0] = x; mem[1] = y; mem[2] = z; mem[3] = v;

         mem[4] = img.dimx(); mem[5] = img.dimy(); mem[6] = img.dimz(); mem[7] = img.dimv();

         cimglist_for(code,l) {

           const CImg<uintT> &opcode = code[l];

           double &res = mem[opcode(1)];

           switch (opcode(0)) {

           case 'U' : res = cimg::rand(); break;

           case 'G' : res = cimg::grand(); break;

           case 'I' : res = (double)img.atXYZV((int)x,(int)y,(int)z,(int)v,0); break;

           case '0' : res = x/img.dimx(); break;

           case '1' : res = y/img.dimy(); break;

           case '2' : res = z/img.dimz(); break;

           case '3' : res = v/img.dimv(); break;

           case 'A' : res = (bool)mem[opcode(2)] && (bool)mem[opcode(3)]; break;

           case 'X' : res = (bool)mem[opcode(2)] ^ (bool)mem[opcode(3)]; break;

           case 'O' : res = (bool)mem[opcode(2)] || (bool)mem[opcode(3)]; break;

           case 'l' : res = (mem[opcode(2)] <= mem[opcode(3)]); break;

           case 'g' : res = (mem[opcode(2)] >= mem[opcode(3)]); break;

           case '!' : res = (mem[opcode(2)] != mem[opcode(3)]); break;

           case '=' : res = (mem[opcode(2)] == mem[opcode(3)]); break;

           case '>' : res = (mem[opcode(2)] > mem[opcode(3)]); break;

           case '<' : res = (mem[opcode(2)] < mem[opcode(3)]); break;

           case '+' : res = (mem[opcode(2)] + mem[opcode(3)]); break;

           case '-' : res = (mem[opcode(2)] - mem[opcode(3)]); break;

           case '*' : res = (mem[opcode(2)] * mem[opcode(3)]); break;

           case '/' : res = (mem[opcode(2)] / mem[opcode(3)]); break;

           case 'o' : res = -mem[opcode(2)]; break;

           case 'p' : res = mem[opcode(2)]; break;

           case 'n' : res = !mem[opcode(2)]; break;

           case '~' : res = ~(unsigned long)mem[opcode(2)]; break;

           case '%' : res = cimg::mod(mem[opcode(2)],mem[opcode(3)]); break;

           case '&' : res = ((unsigned long)mem[opcode(2)] & (unsigned long)mem[opcode(3)]); break;

           case '|' : res = ((unsigned long)mem[opcode(2)] | (unsigned long)mem[opcode(3)]); break;

           case '^' : res = std::pow(mem[opcode(2)],mem[opcode(3)]); break;

           case 's' : res = std::sin(mem[opcode(2)]); break;

           case 'c' : res = std::cos(mem[opcode(2)]); break;

           case 't' : res = std::tan(mem[opcode(2)]); break;

           case 'S' : res = std::asin(mem[opcode(2)]); break;

           case 'C' : res = std::acos(mem[opcode(2)]); break;

           case 'T' : res = std::atan(mem[opcode(2)]); break;

           case '.' : res = std::sinh(mem[opcode(2)]); break;

           case ',' : res = std::cosh(mem[opcode(2)]); break;

           case ';' : res = std::tanh(mem[opcode(2)]); break;

           case 'Q' : res = std::log10(mem[opcode(2)]); break;

           case 'q' : res = std::log(mem[opcode(2)]); break;

           case 'e' : res = std::exp(mem[opcode(2)]); break;

           case 'r' : res = std::sqrt(mem[opcode(2)]); break;

           case '\\' : res = cimg::sign(mem[opcode(2)]); break;

           case 'i' : res = cimg::round(mem[opcode(2)],1); break;

           case '(' : {

             const int v = (int)mem[opcode(5)];

             switch ((int)mem[opcode(6)]) {

             case 0 : res = (double)img.linear_atXYZ((float)mem[opcode(2)],

                                                     (float)mem[opcode(3)],

                                                     (float)mem[opcode(4)],

                                                     v<0?0:v>=img.dimv()?img.dimv()-1:v,0); break;

             case 1 : res = (double)img.linear_atXYZ((float)mem[opcode(2)],

                                                     (float)mem[opcode(3)],

                                                     (float)mem[opcode(4)],

                                                     v<0?0:v>=img.dimv()?img.dimv()-1:v); break;

             default : res = (double)img.linear_atXYZ((float)cimg::mod(mem[opcode(2)],(double)img.dimx()),

                                                      (float)cimg::mod(mem[opcode(3)],(double)img.dimy()),

                                                      (float)cimg::mod(mem[opcode(4)],(double)img.dimz()),

                                                      v<0?0:v>=img.dimv()?img.dimv()-1:v); break;

             }

           } break;

           case ':' : res = cimg::abs(mem[opcode(2)]); break;

           case '#' : res = std::atan2(mem[opcode(2)],mem[opcode(3)]); break;

           case '?' : res = mem[opcode(2)]?mem[opcode(3)]:mem[opcode(4)]; break;

           case 'm' : {

             double val = mem[opcode(2)];

             for (unsigned int i = 3; i<opcode.height; ++i) val = cimg::min(val,mem[opcode(i)]);

             res = val;

           } break;

           case 'M' : {

             double val = mem[opcode(2)];

             for (unsigned int i = 3; i<opcode.height; ++i) val = cimg::max(val,mem[opcode(i)]);

             res = val;

           } break;

           default :

             throw CImgArgumentException("CImg<%s>::%s() : Invalid opcode %d.",pixel_type(),calling_function,opcode(0));

           }

         }

         return mem[result];

       }


       // Evaluation procedure, without image data.

       double eval(const double x, const double y, const double z, const double v) {

         static const CImg<T> empty;

         return eval(empty,x,y,z,v);

       }


     };


     CImg<T>& sqr() {

       cimg_for(*this,ptr,T) { const T val = *ptr; *ptr = (T)(val*val); };

       return *this;

     }


     CImg<Tfloat> get_sqr() const {

       return CImg<Tfloat>(*this,false).sqr();

     }


     CImg<T>& sqrt() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::sqrt((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_sqrt() const {

       return CImg<Tfloat>(*this,false).sqrt();

     }


     CImg<T>& exp() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::exp((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_exp() const {

       return CImg<Tfloat>(*this,false).exp();

     }


     CImg<T>& log() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::log((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_log() const {

       return CImg<Tfloat>(*this,false).log();

     }


     CImg<T>& log10() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::log10((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_log10() const {

       return CImg<Tfloat>(*this,false).log10();

     }


     CImg<T>& abs() {

       cimg_for(*this,ptr,T) (*ptr) = cimg::abs(*ptr);

       return *this;

     }


     CImg<Tfloat> get_abs() const {

       return CImg<Tfloat>(*this,false).abs();

     }


     CImg<T>& cos() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::cos((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_cos() const {

       return CImg<Tfloat>(*this,false).cos();

     }


     CImg<T>& sin() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::sin((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_sin() const {

       return CImg<Tfloat>(*this,false).sin();

     }


     CImg<T>& tan() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::tan((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_tan() const {

       return CImg<Tfloat>(*this,false).tan();

     }


     CImg<T>& cosh() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::cosh((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_cosh() const {

       return CImg<Tfloat>(*this,false).cosh();

     }


     CImg<T>& sinh() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::sinh((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_sinh() const {

       return CImg<Tfloat>(*this,false).sinh();

     }


     CImg<T>& tanh() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::tanh((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_tanh() const {

       return CImg<Tfloat>(*this,false).tanh();

     }


     CImg<T>& acos() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::acos((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_acos() const {

       return CImg<Tfloat>(*this,false).acos();

     }


     CImg<T>& asin() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::asin((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_asin() const {

       return CImg<Tfloat>(*this,false).asin();

     }


     CImg<T>& atan() {

       cimg_for(*this,ptr,T) (*ptr) = (T)std::atan((double)(*ptr));

       return *this;

     }


     CImg<Tfloat> get_atan() const {

       return CImg<Tfloat>(*this,false).atan();

     }


     template<typename t>

     CImg<T>& atan2(const CImg<t>& img) {

       const unsigned int smin = cimg::min(size(),img.size());

       t *ptrs = img.data + smin;

       for (T *ptrd = data + smin; ptrd>data; --ptrd, *ptrd = (T)std::atan2((double)*ptrd,(double)*(--ptrs))) {}

       return *this;

     }


     template<typename t>

     CImg<Tfloat> get_atan2(const CImg<t>& img) const {

       return CImg<Tfloat>(*this,false).atan2(img);

     }


     template<typename t>

     CImg<T>& mul(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return mul(+img);

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)(*ptrd * *(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)(*ptrd * *(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> get_mul(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false).mul(img);

     }


     template<typename t>

     CImg<T>& div(const CImg<t>& img) {

       const unsigned int siz = size(), isiz = img.size();

       if (siz && isiz) {

         if (is_overlapped(img)) return div(+img);

         T *ptrd = data, *const ptrd_end = data + siz;

         if (siz>isiz) for (unsigned int n = siz/isiz; n; --n)

           for (const t *ptrs = img.data, *ptrs_end = ptrs + isiz; ptrs<ptrs_end; ++ptrd) *ptrd = (T)(*ptrd / *(ptrs++));

         for (const t *ptrs = img.data; ptrd<ptrd_end; ++ptrd) *ptrd = (T)(*ptrd / *(ptrs++));

       }

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> get_div(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false).div(img);

     }


     CImg<T>& pow(const double p) {

       if (p==0) return fill(1);

       if (p==0.5) { cimg_for(*this,ptr,T) { const T val = *ptr; *ptr = (T)std::sqrt((double)val); } return *this; }

       if (p==1) return *this;

       if (p==2) { cimg_for(*this,ptr,T) { const T val = *ptr; *ptr = val*val; } return *this; }

       if (p==3) { cimg_for(*this,ptr,T) { const T val = *ptr; *ptr = val*val*val; } return *this; }

       if (p==4) { cimg_for(*this,ptr,T) { const T val = *ptr; *ptr = val*val*val*val; } return *this; }

       cimg_for(*this,ptr,T) (*ptr) = (T)std::pow((double)(*ptr),p);

       return *this;

     }


     CImg<Tfloat> get_pow(const double p) const {

       return CImg<Tfloat>(*this,false).pow(p);

     }


     template<typename t>

     CImg<T>& pow(const CImg<t>& img) {

       if (is_overlapped(img)) return pow(+img);

       t *ptrs = img.data;

       T *ptrf = data + cimg::min(size(),img.size());

       for (T* ptrd = data; ptrd<ptrf; ++ptrd) (*ptrd) = (T)std::pow((double)*ptrd,(double)(*(ptrs++)));

       return *this;

     }


     template<typename t>

     CImg<Tfloat> get_pow(const CImg<t>& img) const {

       return CImg<Tfloat>(*this,false).pow(img);

     }


     CImg<T>& pow(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"pow");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)std::pow((double)*ptrd,mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         CImg<Tfloat> values(width,height,depth,dim);

         try {

           values.fill(expression,true);

         } catch (CImgException&) {

           cimg::exception_mode() = omode;

           values.load(expression);

         }

         pow(values);

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     CImg<Tfloat> get_pow(const char *const expression) const {

       return CImg<Tfloat>(*this,false).pow(expression);

     }


     CImg<T>& min(const T val) {

       cimg_for(*this,ptr,T) (*ptr) = cimg::min(*ptr,val);

       return *this;

     }


     CImg<T> get_min(const T val) const {

       return (+*this).min(val);

     }


     template<typename t>

     CImg<T>& min(const CImg<t>& img) {

       if (is_overlapped(img)) return min(+img);

       t *ptrs = img.data;

       T *ptrf = data + cimg::min(size(),img.size());

       for (T* ptrd = data; ptrd<ptrf; ++ptrd) (*ptrd) = cimg::min((T)*(ptrs++),*ptrd);

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> get_min(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false).min(img);

     }


     CImg<T>& min(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"min");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)cimg::min(*ptrd,(T)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         CImg<T> values(width,height,depth,dim);

         try {

           values.fill(expression,true);

         } catch (CImgException&) {

           cimg::exception_mode() = omode;

           values.load(expression);

         }

         min(values);

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     CImg<Tfloat> get_min(const char *const expression) const {

       return CImg<Tfloat>(*this,false).min(expression);

     }


     CImg<T>& max(const T val) {

       cimg_for(*this,ptr,T) (*ptr) = cimg::max(*ptr,val);

       return *this;

     }


     CImg<T> get_max(const T val) const {

       return (+*this).max(val);

     }


     template<typename t>

     CImg<T>& max(const CImg<t>& img) {

       if (is_overlapped(img)) return max(+img);

       t *ptrs = img.data;

       T *ptrf = data + cimg::min(size(),img.size());

       for (T* ptrd = data; ptrd<ptrf; ++ptrd) (*ptrd) = cimg::max((T)*(ptrs++),*ptrd);

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> get_max(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this,false).max(img);

     }


     CImg<T>& max(const char *const expression) {

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try {

         _cimg_math_parser mp(expression,"max");

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) { *ptrd = (T)cimg::max(*ptrd,(T)mp.eval(*this,x,y,z,v)); ++ptrd; }

       } catch (CImgException&) {

         CImg<T> values(width,height,depth,dim);

         try {

           values.fill(expression,true);

         } catch (CImgException&) {

           cimg::exception_mode() = omode;

           values.load(expression);

         }

         max(values);

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     CImg<Tfloat> get_max(const char *const expression) const {

       return CImg<Tfloat>(*this,false).max(expression);

     }


     T& min() {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::min() : Instance image is empty.",pixel_type());

       T *ptrmin = data;

       T min_value = *ptrmin;

       cimg_for(*this,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);

       return *ptrmin;

     }


     const T& min() const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::min() : Instance image is empty.",pixel_type());

       const T *ptrmin = data;

       T min_value = *ptrmin;

       cimg_for(*this,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);

       return *ptrmin;

     }


     T& max() {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::max() : Instance image is empty.",pixel_type());

       T *ptrmax = data;

       T max_value = *ptrmax;

       cimg_for(*this,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);

       return *ptrmax;

     }


     const T& max() const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::max() : Instance image is empty.",pixel_type());

       const T *ptrmax = data;

       T max_value = *ptrmax;

       cimg_for(*this,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);

       return *ptrmax;

     }


     template<typename t>

     T& minmax(t& max_val) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::minmax() : Instance image is empty.",pixel_type());

       T *ptrmin = data;

       T min_value = *ptrmin, max_value = min_value;

       cimg_for(*this,ptr,T) {

         const T val = *ptr;

         if (val<min_value) { min_value = val; ptrmin = ptr; }

         if (val>max_value) max_value = val;

       }

       max_val = (t)max_value;

       return *ptrmin;

     }


     template<typename t>

     const T& minmax(t& max_val) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::minmax() : Instance image is empty.",pixel_type());

       const T *ptrmin = data;

       T min_value = *ptrmin, max_value = min_value;

       cimg_for(*this,ptr,T) {

         const T val = *ptr;

         if (val<min_value) { min_value = val; ptrmin = ptr; }

         if (val>max_value) max_value = val;

       }

       max_val = (t)max_value;

       return *ptrmin;

     }


     template<typename t>

     T& maxmin(t& min_val) {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::maxmin() : Instance image is empty.",pixel_type());

       T *ptrmax = data;

       T max_value = *ptrmax, min_value = max_value;

       cimg_for(*this,ptr,T) {

         const T val = *ptr;

         if (val>max_value) { max_value = val; ptrmax = ptr; }

         if (val<min_value) min_value = val;

       }

       min_val = (t)min_value;

       return *ptrmax;

     }


     template<typename t>

     const T& maxmin(t& min_val) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::maxmin() : Instance image is empty.",pixel_type());

       const T *ptrmax = data;

       T max_value = *ptrmax, min_value = max_value;

       cimg_for(*this,ptr,T) {

         const T val = *ptr;

         if (val>max_value) { max_value = val; ptrmax = ptr; }

         if (val<min_value) min_value = val;

       }

       min_val = (t)min_value;

       return *ptrmax;

     }


     T kth_smallest(const unsigned int k) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::kth_smallest() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       CImg<T> arr(*this);

       unsigned int l = 0, ir = size() - 1;

       for (;;) {

         if (ir<=l+1) {

           if (ir==l+1 && arr[ir]<arr[l]) cimg::swap(arr[l],arr[ir]);

           return arr[k];

         } else {

           const unsigned int mid = (l + ir)>>1;

           cimg::swap(arr[mid],arr[l+1]);

           if (arr[l]>arr[ir]) cimg::swap(arr[l],arr[ir]);

           if (arr[l+1]>arr[ir]) cimg::swap(arr[l+1],arr[ir]);

           if (arr[l]>arr[l+1]) cimg::swap(arr[l],arr[l+1]);

           unsigned int i = l + 1, j = ir;

           const T pivot = arr[l+1];

           for (;;) {

             do ++i; while (arr[i]<pivot);

             do --j; while (arr[j]>pivot);

             if (j<i) break;

             cimg::swap(arr[i],arr[j]);

           }

           arr[l+1] = arr[j];

           arr[j] = pivot;

           if (j>=k) ir = j - 1;

           if (j<=k) l = i;

         }

       }

       return 0;

     }


     T median() const {

       const unsigned int s = size();

       const T res = kth_smallest(s>>1);

       return (s%2)?res:((res+kth_smallest((s>>1)-1))/2);

     }


     Tfloat sum() const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::sum() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       Tfloat res = 0;

       cimg_for(*this,ptr,T) res+=*ptr;

       return res;

     }


     Tfloat mean() const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::mean() : Instance image is empty.",pixel_type());

       Tfloat val = 0;

       cimg_for(*this,ptr,T) val+=*ptr;

       return val/size();

     }


     Tfloat variance(const unsigned int variance_method=1) const {

       Tfloat foo;

       return variancemean(variance_method,foo);

     }


     template<typename t>

     Tfloat variancemean(const unsigned int variance_method, t& mean) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::variance() : Instance image is empty.",pixel_type());

       Tfloat variance = 0, average = 0;

       const unsigned int siz = size();

       switch (variance_method) {

       case 3 : { // Least trimmed of Squares

         CImg<Tfloat> buf(*this);

         const unsigned int siz2 = siz>>1;

         cimg_for(buf,ptrs,Tfloat) { const Tfloat val = *ptrs; (*ptrs)*=val; average+=val; }

         buf.sort();

         Tfloat a = 0;

         const Tfloat *ptrs = buf.ptr();

         for (unsigned int j = 0; j<siz2; ++j) a+=*(ptrs++);

         const Tfloat sig = (Tfloat)(2.6477*std::sqrt(a/siz2));

         variance = sig*sig;

       } break;

       case 2 : { // Least Median of Squares (MAD)

         CImg<Tfloat> buf(*this);

         buf.sort();

         const unsigned int siz2 = siz>>1;

         const Tfloat med_i = buf[siz2];

         cimg_for(buf,ptrs,Tfloat) { const Tfloat val = *ptrs; *ptrs = cimg::abs(val - med_i); average+=val; }

         buf.sort();

         const Tfloat sig = (Tfloat)(1.4828*buf[siz2]);

         variance = sig*sig;

       } break;

       case 1 : { // Least mean square (robust definition)

         Tfloat S = 0, S2 = 0;

         cimg_for(*this,ptr,T) { const Tfloat val = (Tfloat)*ptr; S+=val;  S2+=val*val; }

         variance = siz>1?(S2 - S*S/siz)/(siz - 1):0;

         average = S;

       } break;

       case 0 :{ // Least mean square (standard definition)

         Tfloat S = 0, S2 = 0;

         cimg_for(*this,ptr,T) { const Tfloat val = (Tfloat)*ptr; S+=val;  S2+=val*val; }

         variance = (S2 - S*S/siz)/siz;

         average = S;

       } break;

       default :

         throw CImgArgumentException("CImg<%s>::variancemean() : Incorrect parameter 'variance_method = %d' (correct values are 0,1,2 or 3).",

                                     pixel_type(),variance_method);

       }

       mean = (t)(average/siz);

       return variance>0?variance:0;

     }


     template<typename t>

     Tfloat MSE(const CImg<t>& img) const {

       if (img.size()!=size())

         throw CImgArgumentException("CImg<%s>::MSE() : Instance image (%u,%u,%u,%u) and given image (%u,%u,%u,%u) have different dimensions.",

                                     pixel_type(),width,height,depth,dim,img.width,img.height,img.depth,img.dim);


       Tfloat vMSE = 0;

       const t* ptr2 = img.end();

       cimg_for(*this,ptr1,T) {

         const Tfloat diff = (Tfloat)*ptr1 - (Tfloat)*(--ptr2);

         vMSE += diff*diff;

       }

       vMSE/=img.size();

       return vMSE;

     }


     template<typename t>

     Tfloat PSNR(const CImg<t>& img, const Tfloat valmax=(Tfloat)255) const {

       const Tfloat vMSE = (Tfloat)std::sqrt(MSE(img));

       return (vMSE!=0)?(Tfloat)(20*std::log10(valmax/vMSE)):(Tfloat)(cimg::type<Tfloat>::max());

     }


     double eval(const char *const expression, const double x=0, const double y=0, const double z=0, const double v=0) const {

       static _cimg_math_parser *mp = 0;

       if (expression) { if (mp) delete mp; mp = new _cimg_math_parser(expression,"eval"); }

       if (!mp) throw CImgArgumentException("CImg<%s>::eval() : No expression has been previously defined.",pixel_type());

       return mp->eval(*this,x,y,z,v);

     }


     CImg<T>& stats(const unsigned int variance_method=1) {

       return get_stats(variance_method).transfer_to(*this);

     }


     CImg<Tfloat> get_stats(const unsigned int variance_method=1) const {

       if (is_empty()) return CImg<Tfloat>();

       const unsigned int siz = size();

       const T *const odata = data;

       const T *pm = odata, *pM = odata;

       Tfloat S = 0, S2 = 0;

       T m = *pm, M = m;

       cimg_for(*this,ptr,T) {

         const T val = *ptr;

         const Tfloat fval = (Tfloat)val;

         if (val<m) { m = val; pm = ptr; }

         if (val>M) { M = val; pM = ptr; }

         S+=fval;

         S2+=fval*fval;

       }

       const Tfloat

         mean_value = S/siz,

         _variance_value = variance_method==0?(S2 - S*S/siz)/siz:

         (variance_method==1?(siz>1?(S2 - S*S/siz)/(siz - 1):0):

          variance(variance_method)),

         variance_value = _variance_value>0?_variance_value:0;

       int

         xm = 0, ym = 0, zm = 0, vm = 0,

         xM = 0, yM = 0, zM = 0, vM = 0;

       contains(*pm,xm,ym,zm,vm);

       contains(*pM,xM,yM,zM,vM);

       return CImg<Tfloat>(1,12).fill((Tfloat)m,(Tfloat)M,mean_value,variance_value,

                                      (Tfloat)xm,(Tfloat)ym,(Tfloat)zm,(Tfloat)vm,

                                      (Tfloat)xM,(Tfloat)yM,(Tfloat)zM,(Tfloat)vM);

     }


     //-------------------------------------

     //


     //-------------------------------------


     Tfloat magnitude(const int magnitude_type=2) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::magnitude() : Instance object (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       Tfloat res = 0;

       switch (magnitude_type) {

       case -1 : {

         cimg_foroff(*this,off) {

           const Tfloat tmp = cimg::abs((Tfloat)data[off]);

           if (tmp>res) res = tmp;

         }

         return res;

       } break;

       case 1 : {

         cimg_foroff(*this,off) res+=cimg::abs((Tfloat)data[off]);

         return res;

       } break;

       case 2 : return (Tfloat)std::sqrt(dot(*this)); break;

       default :

         throw CImgArgumentException("CImg<%s>::magnitude() : Incorrect parameter 'magnitude_type=%d' (correct values are -1,1 or 2).",

                                     pixel_type(),magnitude_type);

       }

       return 0;

     }


     Tfloat trace() const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::trace() : Instance matrix (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       Tfloat res = 0;

       cimg_forX(*this,k) res+=(*this)(k,k);

       return res;

     }


     Tfloat det() const {

       if (is_empty() || width!=height || depth!=1 || dim!=1)

         throw CImgInstanceException("CImg<%s>::det() : Instance matrix (%u,%u,%u,%u,%p) is not square or is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       switch (width) {

       case 1 : return (Tfloat)((*this)(0,0));

       case 2 : return (Tfloat)((*this)(0,0))*(Tfloat)((*this)(1,1)) - (Tfloat)((*this)(0,1))*(Tfloat)((*this)(1,0));

       case 3 : {

         const Tfloat

           a = (Tfloat)data[0], d = (Tfloat)data[1], g = (Tfloat)data[2],

           b = (Tfloat)data[3], e = (Tfloat)data[4], h = (Tfloat)data[5],

           c = (Tfloat)data[6], f = (Tfloat)data[7], i = (Tfloat)data[8];

         return i*a*e - a*h*f - i*b*d + b*g*f + c*d*h - c*g*e;

       }

       default : {

         CImg<Tfloat> lu(*this);

         CImg<uintT> indx;

         bool d;

         lu._LU(indx,d);

         Tfloat res = d?(Tfloat)1:(Tfloat)-1;

         cimg_forX(lu,i) res*=lu(i,i);

         return res;

       }

       }

       return 0;

     }


     template<typename t>

     Tfloat dot(const CImg<t>& img) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::dot() : Instance object (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       if (!img)

         throw CImgArgumentException("CImg<%s>::trace() : Specified argument (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),img.width,img.height,img.depth,img.dim,img.data);

       const unsigned int nb = cimg::min(size(),img.size());

       Tfloat res = 0;

       for (unsigned int off = 0; off<nb; ++off) res+=(Tfloat)data[off]*(Tfloat)img[off];

       return res;

     }


     CImg<T> get_vector_at(const unsigned int x, const unsigned int y=0, const unsigned int z=0) const {

       static CImg<T> dest;

       if (dest.height!=dim) dest.assign(1,dim);

       const unsigned int whz = width*height*depth;

       const T *ptrs = ptr(x,y,z);

       T *ptrd = dest.data;

       cimg_forV(*this,k) { *(ptrd++) = *ptrs; ptrs+=whz; }

       return dest;

     }


     CImg<T> get_matrix_at(const unsigned int x=0, const unsigned int y=0, const unsigned int z=0) const {

       const int n = (int)std::sqrt((double)dim);

       CImg<T> dest(n,n);

       cimg_forV(*this,k) dest[k]=(*this)(x,y,z,k);

       return dest;

     }


     CImg<T> get_tensor_at(const unsigned int x, const unsigned int y=0, const unsigned int z=0) const {

       if (dim==6) return tensor((*this)(x,y,z,0),(*this)(x,y,z,1),(*this)(x,y,z,2),

                                 (*this)(x,y,z,3),(*this)(x,y,z,4),(*this)(x,y,z,5));

       if (dim==3) return tensor((*this)(x,y,z,0),(*this)(x,y,z,1),(*this)(x,y,z,2));

       return tensor((*this)(x,y,z,0));

     }


     template<typename t>

     CImg<T>& set_vector_at(const CImg<t>& vec, const unsigned int x, const unsigned int y=0, const unsigned int z=0) {

       if (x<width && y<height && z<depth) {

         const unsigned int whz = width*height*depth;

         const t *ptrs = vec.data;

         T *ptrd = ptr(x,y,z);

         for (unsigned int k=cimg::min((unsigned int)vec.size(),dim); k; --k) { *ptrd = (T)*(ptrs++); ptrd+=whz; }

       }

       return *this;

     }


     template<typename t>

     CImg<T>& set_matrix_at(const CImg<t>& mat, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0) {

       return set_vector_at(mat,x,y,z);

     }


     template<typename t>

     CImg<T>& set_tensor_at(const CImg<t>& ten, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0) {

       if (ten.height==2) {

         (*this)(x,y,z,0) = (T)ten[0];

         (*this)(x,y,z,1) = (T)ten[1];

         (*this)(x,y,z,2) = (T)ten[3];

       }

       else {

         (*this)(x,y,z,0) = (T)ten[0];

         (*this)(x,y,z,1) = (T)ten[1];

         (*this)(x,y,z,2) = (T)ten[2];

         (*this)(x,y,z,3) = (T)ten[4];

         (*this)(x,y,z,4) = (T)ten[5];

         (*this)(x,y,z,5) = (T)ten[8];

       }

       return *this;

     }


     CImg<T>& vector() {

       return unroll('y');

     }


     CImg<T> get_vector() const {

       return get_unroll('y');

     }


     CImg<T>& matrix() {

       const unsigned int siz = size();

       switch (siz) {

       case 1 : break;

       case 4 : width = height = 2; break;

       case 9 : width = height = 3; break;

       case 16 : width = height = 4; break;

       case 25 : width = height = 5; break;

       case 36 : width = height = 6; break;

       case 49 : width = height = 7; break;

       case 64 : width = height = 8; break;

       case 81 : width = height = 9; break;

       case 100 : width = height = 10; break;

       default : {

         unsigned int i = 11, i2 = i*i;

         while (i2<siz) { i2+=2*i+1; ++i; }

         if (i2==siz) width = height = i;

         else throw CImgInstanceException("CImg<%s>::matrix() : Image size = %u is not a square number",

                                          pixel_type(),siz);

       }

       }

       return *this;

     }


     CImg<T> get_matrix() const {

       return (+*this).matrix();

     }


     CImg<T>& tensor() {

       return get_tensor().transfer_to(*this);

     }


     CImg<T> get_tensor() const {

       CImg<T> res;

       const unsigned int siz = size();

       switch (siz) {

       case 1 : break;

       case 3 :

         res.assign(2,2);

         res(0,0) = (*this)(0);

         res(1,0) = res(0,1) = (*this)(1);

         res(1,1) = (*this)(2);

         break;

       case 6 :

         res.assign(3,3);

         res(0,0) = (*this)(0);

         res(1,0) = res(0,1) = (*this)(1);

         res(2,0) = res(0,2) = (*this)(2);

         res(1,1) = (*this)(3);

         res(2,1) = res(1,2) = (*this)(4);

         res(2,2) = (*this)(5);

         break;

       default :

         throw CImgInstanceException("CImg<%s>::tensor() : Wrong vector dimension = %u in instance image.",

                                     pixel_type(), dim);

       }

       return res;

     }


     CImg<T>& diagonal() {

       return get_diagonal().transfer_to(*this);

     }


     CImg<T> get_diagonal() const {

       if (is_empty()) return *this;

       CImg<T> res(size(),size(),1,1,0);

       cimg_foroff(*this,off) res(off,off) = (*this)(off);

       return res;

     }


     CImg<T>& identity_matrix() {

       return identity_matrix(cimg::max(width,height)).transfer_to(*this);

     }


     CImg<T> get_identity_matrix() const {

       return identity_matrix(cimg::max(width,height));

     }


     CImg<T>& sequence(const T a0, const T a1) {

       if (is_empty()) return *this;

       const unsigned int siz = size() - 1;

       T* ptr = data;

       if (siz) {

         const Tfloat delta = (Tfloat)a1 - a0;

         cimg_foroff(*this,l) *(ptr++) = (T)(a0 + delta*l/siz);

       } else *ptr = a0;

       return *this;

     }


     CImg<T> get_sequence(const T a0, const T a1) const {

       return (+*this).sequence(a0,a1);

     }


     CImg<T>& transpose() {

       if (width==1) { width=height; height=1; return *this; }

       if (height==1) { height=width; width=1; return *this; }

       if (width==height) {

         cimg_forYZV(*this,y,z,v) for (int x=y; x<dimx(); ++x) cimg::swap((*this)(x,y,z,v),(*this)(y,x,z,v));

         return *this;

       }

       return get_transpose().transfer_to(*this);

     }


     CImg<T> get_transpose() const {

       return get_permute_axes("yxzv");

     }


     template<typename t>

     CImg<T>& cross(const CImg<t>& img) {

       if (width!=1 || height<3 || img.width!=1 || img.height<3)

         throw CImgInstanceException("CImg<%s>::cross() : Arguments (%u,%u,%u,%u,%p) and (%u,%u,%u,%u,%p) must be both 3d vectors.",

                                     pixel_type(),width,height,depth,dim,data,img.width,img.height,img.depth,img.dim,img.data);

       const T x = (*this)[0], y = (*this)[1], z = (*this)[2];

       (*this)[0] = (T)(y*img[2]-z*img[1]);

       (*this)[1] = (T)(z*img[0]-x*img[2]);

       (*this)[2] = (T)(x*img[1]-y*img[0]);

       return *this;

     }


     template<typename t>

     CImg<_cimg_Tt> get_cross(const CImg<t>& img) const {

       return CImg<_cimg_Tt>(*this).cross(img);

     }


     CImg<T>& invert(const bool use_LU=true) {

       if (!is_empty()) {

         if (width!=height || depth!=1 || dim!=1)

           throw CImgInstanceException("CImg<%s>::invert() : Instance matrix (%u,%u,%u,%u,%p) is not square.",

                                       pixel_type(),width,height,depth,dim,data);

 #ifdef cimg_use_lapack

         int INFO = (int)use_LU, N = width, LWORK = 4*N, *IPIV = new int[N];

         Tfloat

           *lapA = new Tfloat[N*N],

           *WORK = new Tfloat[LWORK];

         cimg_forXY(*this,k,l) lapA[k*N+l] = (Tfloat)((*this)(k,l));

         cimg::getrf(N,lapA,IPIV,INFO);

         if (INFO)

           cimg::warn("CImg<%s>::invert() : LAPACK library function dgetrf_() returned error code %d.",

                      pixel_type(),INFO);

         else {

           cimg::getri(N,lapA,IPIV,WORK,LWORK,INFO);

           if (INFO)

             cimg::warn("CImg<%s>::invert() : LAPACK library function dgetri_() returned Error code %d",

                        pixel_type(),INFO);

         }

         if (!INFO) cimg_forXY(*this,k,l) (*this)(k,l) = (T)(lapA[k*N+l]); else fill(0);

         delete[] IPIV; delete[] lapA; delete[] WORK;

 #else

         const double dete = width>3?-1.0:det();

         if (dete!=0.0 && width==2) {

           const double

             a = data[0], c = data[1],

             b = data[2], d = data[3];

           data[0] = (T)(d/dete); data[1] = (T)(-c/dete);

           data[2] = (T)(-b/dete); data[3] = (T)(a/dete);

         } else if (dete!=0.0 && width==3) {

           const double

             a = data[0], d = data[1], g = data[2],

             b = data[3], e = data[4], h = data[5],

             c = data[6], f = data[7], i = data[8];

           data[0] = (T)((i*e-f*h)/dete), data[1] = (T)((g*f-i*d)/dete), data[2] = (T)((d*h-g*e)/dete);

           data[3] = (T)((h*c-i*b)/dete), data[4] = (T)((i*a-c*g)/dete), data[5] = (T)((g*b-a*h)/dete);

           data[6] = (T)((b*f-e*c)/dete), data[7] = (T)((d*c-a*f)/dete), data[8] = (T)((a*e-d*b)/dete);

         } else {

           if (use_LU) { // LU-based inverse computation

             CImg<Tfloat> A(*this), indx, col(1,width);

             bool d;

             A._LU(indx,d);

             cimg_forX(*this,j) {

               col.fill(0);

               col(j) = 1;

               col._solve(A,indx);

               cimg_forX(*this,i) (*this)(j,i) = (T)col(i);

             }

           } else { // SVD-based inverse computation

             CImg<Tfloat> U(width,width), S(1,width), V(width,width);

             SVD(U,S,V,false);

             U.transpose();

             cimg_forY(S,k) if (S[k]!=0) S[k]=1/S[k];

             S.diagonal();

             *this = V*S*U;

           }

         }

 #endif

       }

       return *this;

     }


     CImg<Tfloat> get_invert(const bool use_LU=true) const {

       return CImg<Tfloat>(*this,false).invert(use_LU);

     }


     CImg<T>& pseudoinvert() {

       return get_pseudoinvert().transfer_to(*this);

     }


     CImg<Tfloat> get_pseudoinvert() const {

       CImg<Tfloat> U, S, V;

       SVD(U,S,V);

       cimg_forX(V,x) {

         const Tfloat s = S(x), invs = s!=0?1/s:(Tfloat)0;

         cimg_forY(V,y) V(x,y)*=invs;

       }

       return V*U.transpose();

     }


     template<typename t>

     CImg<T>& solve(const CImg<t>& A) {

       if (width!=1 || depth!=1 || dim!=1 || height!=A.height || A.depth!=1 || A.dim!=1)

         throw CImgArgumentException("CImg<%s>::solve() : Instance matrix size is (%u,%u,%u,%u) while "

                                     "size of given matrix A is (%u,%u,%u,%u).",

                                     pixel_type(),width,height,depth,dim,A.width,A.height,A.depth,A.dim);


       typedef _cimg_Ttfloat Ttfloat;

       if (A.width==A.height) {

 #ifdef cimg_use_lapack

         char TRANS='N';

         int INFO, N = height, LWORK = 4*N, one = 1, *IPIV = new int[N];

         Ttfloat

           *lapA = new Ttfloat[N*N],

           *lapB = new Ttfloat[N],

           *WORK = new Ttfloat[LWORK];

         cimg_forXY(A,k,l) lapA[k*N+l] = (Ttfloat)(A(k,l));

         cimg_forY(*this,i) lapB[i] = (Ttfloat)((*this)(i));

         cimg::getrf(N,lapA,IPIV,INFO);

         if (INFO)

           cimg::warn("CImg<%s>::solve() : LAPACK library function dgetrf_() returned error code %d.",

                      pixel_type(),INFO);

         if (!INFO) {

           cimg::getrs(TRANS,N,lapA,IPIV,lapB,INFO);

           if (INFO)

             cimg::warn("CImg<%s>::solve() : LAPACK library function dgetrs_() returned Error code %d",

                        pixel_type(),INFO);

         }

         if (!INFO) cimg_forY(*this,i) (*this)(i) = (T)(lapB[i]); else fill(0);

         delete[] IPIV; delete[] lapA; delete[] lapB; delete[] WORK;

 #else

         CImg<Ttfloat> lu(A);

         CImg<Ttfloat> indx;

         bool d;

         lu._LU(indx,d);

         _solve(lu,indx);

 #endif

       } else assign(A.get_pseudoinvert()*(*this));

       return *this;

     }


     template<typename t>

     CImg<_cimg_Ttfloat> get_solve(const CImg<t>& A) const {

       return CImg<_cimg_Ttfloat>(*this,false).solve(A);

     }


     template<typename t, typename ti>

     CImg<T>& _solve(const CImg<t>& A, const CImg<ti>& indx) {

       typedef _cimg_Ttfloat Ttfloat;

       const int N = size();

       int ii = -1;

       Ttfloat sum;

       for (int i = 0; i<N; ++i) {

         const int ip = (int)indx[i];

         Ttfloat sum = (*this)(ip);

         (*this)(ip) = (*this)(i);

         if (ii>=0) for (int j = ii; j<=i-1; ++j) sum-=A(j,i)*(*this)(j);

         else if (sum!=0) ii=i;

         (*this)(i) = (T)sum;

       }

       for (int i = N-1; i>=0; --i) {

         sum = (*this)(i);

         for (int j = i+1; j<N; ++j) sum-=A(j,i)*(*this)(j);

         (*this)(i) = (T)(sum/A(i,i));

       }

       return *this;

     }


     // (Use the Thomas Algorithm).

     template<typename t>

     CImg<T>& solve_tridiagonal(const CImg<t>& a, const CImg<t>& b, const CImg<t>& c) {

       const int siz = (int)size();

       if ((int)a.size()!=siz || (int)b.size()!=siz || (int)c.size()!=siz)

         throw CImgArgumentException("CImg<%s>::solve_tridiagonal() : arrays of triagonal coefficients have different size.",pixel_type);

       typedef _cimg_Ttfloat Ttfloat;

       CImg<Ttfloat> nc(siz);

       const T *ptra = a.data, *ptrb = b.data, *ptrc = c.data;

       T *ptrnc = nc.data, *ptrd = data;

       const Ttfloat valb0 = (Ttfloat)*(ptrb++);

       *ptrnc = *(ptrc++)/valb0;

       Ttfloat vald = (Ttfloat)(*(ptrd++)/=valb0);

       for (int i = 1; i<siz; ++i) {

         const Ttfloat

           vala = (Tfloat)*(ptra++),

           id = 1/(*(ptrb++) - *(ptrnc++)*vala);

         *ptrnc = *(ptrc++)*id;

         vald = ((*ptrd-=vala*vald)*=id);

         ++ptrd;

       }

       vald = *(--ptrd);

       for (int i = siz-2; i>=0; --i) vald = (*(--ptrd)-=*(--ptrnc)*vald);

       return *this;

     }


     template<typename t>

     CImg<_cimg_Ttfloat> get_solve_tridiagonal(const CImg<t>& a, const CImg<t>& b, const CImg<t>& c) const {

       return CImg<_cimg_Ttfloat>(*this,false).solve_tridiagonal(a,b,c);

     }


     template<typename t>

     const CImg<T>& eigen(CImg<t>& val, CImg<t> &vec) const {

       if (is_empty()) { val.assign(); vec.assign(); }

       else {

         if (width!=height || depth>1 || dim>1)

           throw CImgInstanceException("CImg<%s>::eigen() : Instance object (%u,%u,%u,%u,%p) is empty.",

                                       pixel_type(),width,height,depth,dim,data);

         if (val.size()<width) val.assign(1,width);

         if (vec.size()<width*width) vec.assign(width,width);

         switch (width) {

         case 1 : { val[0]=(t)(*this)[0]; vec[0]=(t)1; } break;

         case 2 : {

           const double a = (*this)[0], b = (*this)[1], c = (*this)[2], d = (*this)[3], e = a+d;

           double f = e*e-4*(a*d-b*c);

           if (f<0)

             cimg::warn("CImg<%s>::eigen() : Complex eigenvalues",

                        pixel_type());

           f = std::sqrt(f);

           const double l1 = 0.5*(e-f), l2 = 0.5*(e+f);

           const double theta1 = std::atan2(l2-a,b), theta2 = std::atan2(l1-a,b);

           val[0]=(t)l2;

           val[1]=(t)l1;

           vec(0,0) = (t)std::cos(theta1);

           vec(0,1) = (t)std::sin(theta1);

           vec(1,0) = (t)std::cos(theta2);

           vec(1,1) = (t)std::sin(theta2);

         } break;

         default :

           throw CImgInstanceException("CImg<%s>::eigen() : Eigenvalues computation of general matrices is limited"

                                       "to 2x2 matrices (given is %ux%u)",

                                       pixel_type(),width,height);

         }

       }

       return *this;

     }


     CImgList<Tfloat> get_eigen() const {

       CImgList<Tfloat> res(2);

       eigen(res[0],res[1]);

       return res;

     }


     template<typename t>

     const CImg<T>& symmetric_eigen(CImg<t>& val, CImg<t>& vec) const {

       if (is_empty()) { val.assign(); vec.assign(); }

       else {

 #ifdef cimg_use_lapack

         char JOB = 'V', UPLO = 'U';

         int N = width, LWORK = 4*N, INFO;

         Tfloat

           *lapA = new Tfloat[N*N],

           *lapW = new Tfloat[N],

           *WORK = new Tfloat[LWORK];

         cimg_forXY(*this,k,l) lapA[k*N+l] = (Tfloat)((*this)(k,l));

         cimg::syev(JOB,UPLO,N,lapA,lapW,WORK,LWORK,INFO);

         if (INFO)

           cimg::warn("CImg<%s>::symmetric_eigen() : LAPACK library function dsyev_() returned error code %d.",

                      pixel_type(),INFO);

         val.assign(1,N);

         vec.assign(N,N);

         if (!INFO) {

           cimg_forY(val,i) val(i) = (T)lapW[N-1-i];

           cimg_forXY(vec,k,l) vec(k,l) = (T)(lapA[(N-1-k)*N+l]);

         } else { val.fill(0); vec.fill(0); }

         delete[] lapA; delete[] lapW; delete[] WORK;

 #else

         if (width!=height || depth>1 || dim>1)

           throw CImgInstanceException("CImg<%s>::eigen() : Instance object (%u,%u,%u,%u,%p) is empty.",

                                       pixel_type(),width,height,depth,dim,data);

         val.assign(1,width);

         if (vec.data) vec.assign(width,width);

         if (width<3) return eigen(val,vec);

         CImg<t> V(width,width);

         SVD(vec,val,V,false);

         bool ambiguous = false;

         float eig = 0;

         cimg_forY(val,p) {       // check for ambiguous cases.

           if (val[p]>eig) eig = (float)val[p];

           t scal = 0;

           cimg_forY(vec,y) scal+=vec(p,y)*V(p,y);

           if (cimg::abs(scal)<0.9f) ambiguous = true;

           if (scal<0) val[p] = -val[p];

         }

         if (ambiguous) {

           (eig*=2)++;

           SVD(vec,val,V,false,40,eig);

           val-=eig;

         }

         CImg<intT> permutations(width);  // sort eigenvalues in decreasing order

         CImg<t> tmp(width);

         val.sort(permutations,false);

         cimg_forY(vec,k) {

           cimg_forX(permutations,x) tmp(x) = vec(permutations(x),k);

           std::memcpy(vec.ptr(0,k),tmp.data,sizeof(t)*width);

         }

 #endif

       }

       return *this;

     }


     CImgList<Tfloat> get_symmetric_eigen() const {

       CImgList<Tfloat> res(2);

       symmetric_eigen(res[0],res[1]);

       return res;

     }


     template<typename t>

     CImg<T>& sort(CImg<t>& permutations, const bool increasing=true) {

       if (is_empty()) permutations.assign();

       else {

         if (permutations.size()!=size()) permutations.assign(size());

         cimg_foroff(permutations,off) permutations[off] = (t)off;

         _quicksort(0,size()-1,permutations,increasing);

       }

       return *this;

     }


     template<typename t>

     CImg<T> get_sort(CImg<t>& permutations, const bool increasing=true) const {

       return (+*this).sort(permutations,increasing);

     }


     CImg<T>& sort(const bool increasing=true) {

       CImg<T> foo;

       return sort(foo,increasing);

     }


     CImg<T> get_sort(const bool increasing=true) const {

       return (+*this).sort(increasing);

     }


     template<typename t>

     CImg<T>& _quicksort(const int min, const int max, CImg<t>& permutations, const bool increasing) {

       if (min<max) {

         const int mid = (min+max)/2;

         if (increasing) {

           if ((*this)[min]>(*this)[mid]) {

             cimg::swap((*this)[min],(*this)[mid]); cimg::swap(permutations[min],permutations[mid]); }

           if ((*this)[mid]>(*this)[max]) {

             cimg::swap((*this)[max],(*this)[mid]); cimg::swap(permutations[max],permutations[mid]); }

           if ((*this)[min]>(*this)[mid]) {

             cimg::swap((*this)[min],(*this)[mid]); cimg::swap(permutations[min],permutations[mid]); }

         } else {

           if ((*this)[min]<(*this)[mid]) {

             cimg::swap((*this)[min],(*this)[mid]); cimg::swap(permutations[min],permutations[mid]); }

           if ((*this)[mid]<(*this)[max]) {

             cimg::swap((*this)[max],(*this)[mid]); cimg::swap(permutations[max],permutations[mid]); }

           if ((*this)[min]<(*this)[mid]) {

             cimg::swap((*this)[min],(*this)[mid]); cimg::swap(permutations[min],permutations[mid]); }

         }

         if (max-min>=3) {

           const T pivot = (*this)[mid];

           int i = min, j = max;

           if (increasing) {

             do {

               while ((*this)[i]<pivot) ++i;

               while ((*this)[j]>pivot) --j;

               if (i<=j) {

                 cimg::swap((*this)[i],(*this)[j]);

                 cimg::swap(permutations[i++],permutations[j--]);

               }

             } while (i<=j);

           } else {

             do {

               while ((*this)[i]>pivot) ++i;

               while ((*this)[j]<pivot) --j;

               if (i<=j) {

                 cimg::swap((*this)[i],(*this)[j]);

                 cimg::swap(permutations[i++],permutations[j--]);

               }

             } while (i<=j);

           }

           if (min<j) _quicksort(min,j,permutations,increasing);

           if (i<max) _quicksort(i,max,permutations,increasing);

         }

       }

       return *this;

     }


     template<typename t>

     const CImg<T>& SVD(CImg<t>& U, CImg<t>& S, CImg<t>& V, const bool sorting=true,

                        const unsigned int max_iter=40, const float lambda=0) const {

       if (is_empty()) { U.assign(); S.assign(); V.assign(); }

       else {

         U = *this;

         if (lambda!=0) {

           const unsigned int delta = cimg::min(U.width,U.height);

           for (unsigned int i = 0; i<delta; ++i) U(i,i) = (t)(U(i,i) + lambda);

         }

         if (S.size()<width) S.assign(1,width);

         if (V.width<width || V.height<height) V.assign(width,width);

         CImg<t> rv1(width);

         t anorm = 0, c, f, g = 0, h, s, scale = 0;

         int l = 0, nm = 0;


         cimg_forX(U,i) {

           l = i+1; rv1[i] = scale*g; g = s = scale = 0;

           if (i<dimy()) {

             for (int k = i; k<dimy(); ++k) scale+= cimg::abs(U(i,k));

             if (scale) {

               for (int k = i; k<dimy(); ++k) { U(i,k)/=scale; s+= U(i,k)*U(i,k); }

               f = U(i,i); g = (t)((f>=0?-1:1)*std::sqrt(s)); h=f*g-s; U(i,i) = f-g;

               for (int j = l; j<dimx(); ++j) {

                 s = 0;

                 for (int k=i; k<dimy(); ++k) s+= U(i,k)*U(j,k);

                 f = s/h;

                 for (int k = i; k<dimy(); ++k) U(j,k)+= f*U(i,k);

               }

               for (int k = i; k<dimy(); ++k) U(i,k)*= scale;

             }

           }

           S[i]=scale*g;


           g = s = scale = 0;

           if (i<dimy() && i!=dimx()-1) {

             for (int k = l; k<dimx(); ++k) scale += cimg::abs(U(k,i));

             if (scale) {

               for (int k = l; k<dimx(); ++k) { U(k,i)/= scale; s+= U(k,i)*U(k,i); }

               f = U(l,i); g = (t)((f>=0?-1:1)*std::sqrt(s)); h = f*g-s; U(l,i) = f-g;

               for (int k = l; k<dimx(); ++k) rv1[k]=U(k,i)/h;

               for (int j = l; j<dimy(); ++j) {

                 s = 0;

                 for (int k = l; k<dimx(); ++k) s+= U(k,j)*U(k,i);

                 for (int k = l; k<dimx(); ++k) U(k,j)+= s*rv1[k];

               }

               for (int k = l; k<dimx(); ++k) U(k,i)*= scale;

             }

           }

           anorm = (t)cimg::max((float)anorm,(float)(cimg::abs(S[i])+cimg::abs(rv1[i])));

         }


         for (int i = dimx()-1; i>=0; --i) {

           if (i<dimx()-1) {

             if (g) {

               for (int j = l; j<dimx(); ++j) V(i,j) =(U(j,i)/U(l,i))/g;

               for (int j = l; j<dimx(); ++j) {

                 s = 0;

                 for (int k = l; k<dimx(); ++k) s+= U(k,i)*V(j,k);

                 for (int k = l; k<dimx(); ++k) V(j,k)+= s*V(i,k);

               }

             }

             for (int j = l; j<dimx(); ++j) V(j,i) = V(i,j) = (t)0.0;

           }

           V(i,i) = (t)1.0; g = rv1[i]; l = i;

         }


         for (int i = cimg::min(dimx(),dimy())-1; i>=0; --i) {

           l = i+1; g = S[i];

           for (int j = l; j<dimx(); ++j) U(j,i) = 0;

           if (g) {

             g = 1/g;

             for (int j = l; j<dimx(); ++j) {

               s = 0; for (int k = l; k<dimy(); ++k) s+= U(i,k)*U(j,k);

               f = (s/U(i,i))*g;

               for (int k = i; k<dimy(); ++k) U(j,k)+= f*U(i,k);

             }

             for (int j = i; j<dimy(); ++j) U(i,j)*= g;

           } else for (int j = i; j<dimy(); ++j) U(i,j) = 0;

           ++U(i,i);

         }


         for (int k = dimx()-1; k>=0; --k) {

           for (unsigned int its = 0; its<max_iter; ++its) {

             bool flag = true;

             for (l = k; l>=1; --l) {

               nm = l-1;

               if ((cimg::abs(rv1[l])+anorm)==anorm) { flag = false; break; }

               if ((cimg::abs(S[nm])+anorm)==anorm) break;

             }

             if (flag) {

               c = 0; s = 1;

               for (int i = l; i<=k; ++i) {

                 f = s*rv1[i]; rv1[i] = c*rv1[i];

                 if ((cimg::abs(f)+anorm)==anorm) break;

                 g = S[i]; h = (t)cimg::_pythagore(f,g); S[i] = h; h = 1/h; c = g*h; s = -f*h;

                 cimg_forY(U,j) { const t y = U(nm,j), z = U(i,j); U(nm,j) = y*c+z*s; U(i,j) = z*c-y*s; }

               }

             }

             const t z = S[k];

             if (l==k) { if (z<0) { S[k] = -z; cimg_forX(U,j) V(k,j) = -V(k,j); } break; }

             nm = k-1;

             t x = S[l], y = S[nm];

             g = rv1[nm]; h = rv1[k];

             f = ((y-z)*(y+z)+(g-h)*(g+h))/(2*h*y);

             g = (t)cimg::_pythagore(f,1.0);

             f = ((x-z)*(x+z)+h*((y/(f+ (f>=0?g:-g)))-h))/x;

             c = s = 1;

             for (int j = l; j<=nm; ++j) {

               const int i = j+1;

               g = rv1[i]; h = s*g; g = c*g;

               t y = S[i];

               t z = (t)cimg::_pythagore(f,h);

               rv1[j] = z; c = f/z; s = h/z;

               f = x*c+g*s; g = g*c-x*s; h = y*s; y*=c;

               cimg_forX(U,jj) { const t x = V(j,jj), z = V(i,jj); V(j,jj) = x*c+z*s; V(i,jj) = z*c-x*s; }

               z = (t)cimg::_pythagore(f,h); S[j] = z;

               if (z) { z = 1/z; c = f*z; s = h*z; }

               f = c*g+s*y; x = c*y-s*g;

               cimg_forY(U,jj) { const t y = U(j,jj); z = U(i,jj); U(j,jj) = y*c+z*s; U(i,jj) = z*c-y*s; }

             }

             rv1[l] = 0; rv1[k]=f; S[k]=x;

           }

         }


         if (sorting) {

           CImg<intT> permutations(width);

           CImg<t> tmp(width);

           S.sort(permutations,false);

           cimg_forY(U,k) {

             cimg_forX(permutations,x) tmp(x) = U(permutations(x),k);

             std::memcpy(U.ptr(0,k),tmp.data,sizeof(t)*width);

           }

           cimg_forY(V,k) {

             cimg_forX(permutations,x) tmp(x) = V(permutations(x),k);

             std::memcpy(V.ptr(0,k),tmp.data,sizeof(t)*width);

           }

         }

       }

       return *this;

     }


     CImgList<Tfloat> get_SVD(const bool sorting=true,

                              const unsigned int max_iter=40, const float lambda=0) const {

       CImgList<Tfloat> res(3);

       SVD(res[0],res[1],res[2],sorting,max_iter,lambda);

       return res;

     }


     // INNER ROUTINE : Compute the LU decomposition of a permuted matrix (c.f. numerical recipies)

     template<typename t>

     CImg<T>& _LU(CImg<t>& indx, bool& d) {

       const int N = dimx();

       int imax = 0;

       CImg<Tfloat> vv(N);

       indx.assign(N);

       d = true;

       cimg_forX(*this,i) {

         Tfloat vmax = 0;

         cimg_forX(*this,j) {

           const Tfloat tmp = cimg::abs((*this)(j,i));

           if (tmp>vmax) vmax = tmp;

         }

         if (vmax==0) { indx.fill(0); return fill(0); }

         vv[i] = 1/vmax;

       }

       cimg_forX(*this,j) {

         for (int i = 0; i<j; ++i) {

           Tfloat sum=(*this)(j,i);

           for (int k = 0; k<i; ++k) sum-=(*this)(k,i)*(*this)(j,k);

           (*this)(j,i) = (T)sum;

         }

         Tfloat vmax = 0;

         for (int i = j; i<dimx(); ++i) {

           Tfloat sum=(*this)(j,i);

           for (int k = 0; k<j; ++k) sum-=(*this)(k,i)*(*this)(j,k);

           (*this)(j,i) = (T)sum;

           const Tfloat tmp = vv[i]*cimg::abs(sum);

           if (tmp>=vmax) { vmax=tmp; imax=i; }

         }

         if (j!=imax) {

           cimg_forX(*this,k) cimg::swap((*this)(k,imax),(*this)(k,j));

           d =!d;

           vv[imax] = vv[j];

         }

         indx[j] = (t)imax;

         if ((*this)(j,j)==0) (*this)(j,j) = (T)1e-20;

         if (j<N) {

           const Tfloat tmp = 1/(Tfloat)(*this)(j,j);

           for (int i=j+1; i<N; ++i) (*this)(j,i) = (T)((*this)(j,i)*tmp);

         }

       }

       return *this;

     }


     template<typename tf, typename t>

     static CImg<T> dijkstra(const tf& distance, const unsigned int nb_nodes,

                             const unsigned int starting_node, const unsigned int ending_node,

                             CImg<t>& previous) {


       CImg<T> dist(1,nb_nodes,1,1,cimg::type<T>::max());

       dist(starting_node) = 0;

       previous.assign(1,nb_nodes,1,1,(t)-1);

       previous(starting_node) = (t)starting_node;

       CImg<uintT> Q(nb_nodes);

       cimg_forX(Q,u) Q(u) = u;

       cimg::swap(Q(starting_node),Q(0));

       unsigned int sizeQ = nb_nodes;

       while (sizeQ) {

         // Update neighbors from minimal vertex

         const unsigned int umin = Q(0);

         if (umin==ending_node) sizeQ = 0;

         else {

           const T dmin = dist(umin);

           const T infty = cimg::type<T>::max();

           for (unsigned int q=1; q<sizeQ; ++q) {

             const unsigned int v = Q(q);

             const T d = (T)distance(v,umin);

             if (d<infty) {

               const T alt = dmin + d;

               if (alt<dist(v)) {

                 dist(v) = alt;

                 previous(v) = (t)umin;

                 const T distpos = dist(Q(q));

                 for (unsigned int pos = q, par = 0; pos && distpos<dist(Q(par=(pos+1)/2-1)); pos=par) cimg::swap(Q(pos),Q(par));

               }

             }

           }

           // Remove minimal vertex from queue

           Q(0) = Q(--sizeQ);

           const T distpos = dist(Q(0));

           for (unsigned int pos = 0, left = 0, right = 0;

                ((right=2*(pos+1),(left=right-1))<sizeQ && distpos>dist(Q(left))) || (right<sizeQ && distpos>dist(Q(right)));) {

             if (right<sizeQ) {

               if (dist(Q(left))<dist(Q(right))) { cimg::swap(Q(pos),Q(left)); pos = left; }

               else { cimg::swap(Q(pos),Q(right)); pos = right; }

             } else { cimg::swap(Q(pos),Q(left)); pos = left; }

           }

         }

       }

       return dist;

     }


     template<typename tf, typename t>

     static CImg<T> dijkstra(const tf& distance, const unsigned int nb_nodes,

                             const unsigned int starting_node, const unsigned int ending_node=~0U) {

       CImg<uintT> foo;

       return dijkstra(distance,nb_nodes,starting_node,ending_node,foo);

     }


     template<typename t>

     CImg<T>& dijkstra(const unsigned int starting_node, const unsigned int ending_node, CImg<t>& previous) {

       return get_dijkstra(starting_node,ending_node,previous).transfer_to(*this);

     }


     template<typename t>

     CImg<T> get_dijkstra(const unsigned int starting_node, const unsigned int ending_node, CImg<t>& previous) const {

       if (width!=height || depth!=1 || dim!=1)

         throw CImgInstanceException("CImg<%s>::dijkstra() : Instance image (%u,%u,%u,%u,%p) is not a graph adjacency matrix",

                                     pixel_type(),width,height,depth,dim,data);

       return dijkstra(*this,width,starting_node,ending_node,previous);

     }


     CImg<T>& dijkstra(const unsigned int starting_node, const unsigned int ending_node=~0U) {

       return get_dijkstra(starting_node,ending_node).transfer_to(*this);

     }


     CImg<Tfloat> get_dijkstra(const unsigned int starting_node, const unsigned int ending_node=~0U) const {

       CImg<uintT> foo;

       return get_dijkstra(starting_node,ending_node,foo);

     }


     static CImg<T> vector(const T& a0) {

       static CImg<T> r(1,1); r[0] = a0;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1) {

       static CImg<T> r(1,2); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2) {

       static CImg<T> r(1,3); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3) {

       static CImg<T> r(1,4); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3, const T& a4) {

       static CImg<T> r(1,5); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3; *(ptr++) = a4;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3, const T& a4, const T& a5) {

       static CImg<T> r(1,6); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3; *(ptr++) = a4; *(ptr++) = a5;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6) {

       static CImg<T> r(1,7); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7) {

       static CImg<T> r(1,8); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8) {

       static CImg<T> r(1,9); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9) {

       static CImg<T> r(1,10); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10) {

       static CImg<T> r(1,11); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11) {

       static CImg<T> r(1,12); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11,

                           const T& a12) {

       static CImg<T> r(1,13); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       *(ptr++) = a12;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11,

                           const T& a12, const T& a13) {

       static CImg<T> r(1,14); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       *(ptr++) = a12; *(ptr++) = a13;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11,

                           const T& a12, const T& a13, const T& a14) {

       static CImg<T> r(1,15); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       *(ptr++) = a12; *(ptr++) = a13; *(ptr++) = a14;

       return r;

     }


     static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11,

                           const T& a12, const T& a13, const T& a14, const T& a15) {

       static CImg<T> r(1,16); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       *(ptr++) = a12; *(ptr++) = a13; *(ptr++) = a14; *(ptr++) = a15;

       return r;

     }


     static CImg<T> matrix(const T& a0) {

       return vector(a0);

     }


     static CImg<T> matrix(const T& a0, const T& a1,

                           const T& a2, const T& a3) {

       static CImg<T> r(2,2); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1;

       *(ptr++) = a2; *(ptr++) = a3;

       return r;

     }


     static CImg<T> matrix(const T& a0, const T& a1, const T& a2,

                           const T& a3, const T& a4, const T& a5,

                           const T& a6, const T& a7, const T& a8) {

       static CImg<T> r(3,3); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2;

       *(ptr++) = a3; *(ptr++) = a4; *(ptr++) = a5;

       *(ptr++) = a6; *(ptr++) = a7; *(ptr++) = a8;

       return r;

     }


     static CImg<T> matrix(const T& a0, const T& a1, const T& a2, const T& a3,

                           const T& a4, const T& a5, const T& a6, const T& a7,

                           const T& a8, const T& a9, const T& a10, const T& a11,

                           const T& a12, const T& a13, const T& a14, const T& a15) {

       static CImg<T> r(4,4); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;

       *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;

       *(ptr++) = a8; *(ptr++) = a9; *(ptr++) = a10; *(ptr++) = a11;

       *(ptr++) = a12; *(ptr++) = a13; *(ptr++) = a14; *(ptr++) = a15;

       return r;

     }


     static CImg<T> matrix(const T& a0, const T& a1, const T& a2, const T& a3, const T& a4,

                           const T& a5, const T& a6, const T& a7, const T& a8, const T& a9,

                           const T& a10, const T& a11, const T& a12, const T& a13, const T& a14,

                           const T& a15, const T& a16, const T& a17, const T& a18, const T& a19,

                           const T& a20, const T& a21, const T& a22, const T& a23, const T& a24) {

       static CImg<T> r(5,5); T *ptr = r.data;

       *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3; *(ptr++) = a4;

       *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7; *(ptr++) = a8; *(ptr++) = a9;

       *(ptr++) = a10; *(ptr++) = a11; *(ptr++) = a12; *(ptr++) = a13; *(ptr++) = a14;

       *(ptr++) = a15; *(ptr++) = a16; *(ptr++) = a17; *(ptr++) = a18; *(ptr++) = a19;

       *(ptr++) = a20; *(ptr++) = a21; *(ptr++) = a22; *(ptr++) = a23; *(ptr++) = a24;

       return r;

     }


     static CImg<T> tensor(const T& a1) {

       return matrix(a1);

     }


     static CImg<T> tensor(const T& a1, const T& a2, const T& a3) {

       return matrix(a1,a2,a2,a3);

     }


     static CImg<T> tensor(const T& a1, const T& a2, const T& a3, const T& a4, const T& a5, const T& a6) {

       return matrix(a1,a2,a3,a2,a4,a5,a3,a5,a6);

     }


     static CImg<T> diagonal(const T& a0) {

       return matrix(a0);

     }


     static CImg<T> diagonal(const T& a0, const T& a1) {

       return matrix(a0,0,0,a1);

     }


     static CImg<T> diagonal(const T& a0, const T& a1, const T& a2) {

       return matrix(a0,0,0,0,a1,0,0,0,a2);

     }


     static CImg<T> diagonal(const T& a0, const T& a1, const T& a2, const T& a3) {

       return matrix(a0,0,0,0,0,a1,0,0,0,0,a2,0,0,0,0,a3);

     }


     static CImg<T> diagonal(const T& a0, const T& a1, const T& a2, const T& a3, const T& a4) {

       return matrix(a0,0,0,0,0,0,a1,0,0,0,0,0,a2,0,0,0,0,0,a3,0,0,0,0,0,a4);

     }


     static CImg<T> identity_matrix(const unsigned int N) {

       CImg<T> res(N,N,1,1,0);

       cimg_forX(res,x) res(x,x) = 1;

       return res;

     }


     static CImg<T> sequence(const unsigned int N, const T a0, const T a1) {

       if (N) return CImg<T>(1,N).sequence(a0,a1);

       return CImg<T>();

     }


     static CImg<T> rotation_matrix(const float x, const float y, const float z, const float w, const bool quaternion_data=false) {

       float X,Y,Z,W;

       if (!quaternion_data) {

         const float norm = (float)std::sqrt(x*x + y*y + z*z),

           nx = norm>0?x/norm:0,

           ny = norm>0?y/norm:0,

           nz = norm>0?z/norm:1,

           nw = norm>0?w:0,

           sina = (float)std::sin(nw/2),

           cosa = (float)std::cos(nw/2);

         X = nx*sina;

         Y = ny*sina;

         Z = nz*sina;

         W = cosa;

       } else {

         const float norm = (float)std::sqrt(x*x + y*y + z*z + w*w);

         if (norm>0) { X = x/norm; Y = y/norm; Z = z/norm; W = w/norm; }

         else { X = Y = Z = 0; W = 1; }

       }

       const float xx = X*X, xy = X*Y, xz = X*Z, xw = X*W, yy = Y*Y, yz = Y*Z, yw = Y*W, zz = Z*Z, zw = Z*W;

       return CImg<T>::matrix((T)(1-2*(yy+zz)), (T)(2*(xy+zw)),   (T)(2*(xz-yw)),

                              (T)(2*(xy-zw)),   (T)(1-2*(xx+zz)), (T)(2*(yz+xw)),

                              (T)(2*(xz+yw)),   (T)(2*(yz-xw)),   (T)(1-2*(xx+yy)));

     }


     //-----------------------------------

     //


     //-----------------------------------


     CImg<T>& fill(const T val) {

       if (is_empty()) return *this;

       if (val && sizeof(T)!=1) cimg_for(*this,ptr,T) *ptr = val;

       else std::memset(data,(int)val,size()*sizeof(T));

       return *this;

     }


     CImg<T> get_fill(const T val) const {

       return CImg<T>(width,height,depth,dim).fill(val);

     }


     CImg<T>& fill(const T val0, const T val1) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-1;

       for (ptr = data; ptr<ptr_end; ) { *(ptr++) = val0; *(ptr++) = val1; }

       if (ptr!=ptr_end+1) *(ptr++) = val0;

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-2;

       for (ptr = data; ptr<ptr_end; ) { *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; }

       ptr_end+=2;

       switch (ptr_end-ptr) {

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1, const T val2) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2, const T val3) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-3;

       for (ptr = data; ptr<ptr_end; ) { *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; }

       ptr_end+=3;

       switch (ptr_end-ptr) {

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1, const T val2, const T val3) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2, const T val3, const T val4) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-4;

       for (ptr = data; ptr<ptr_end; ) { *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; }

       ptr_end+=4;

       switch (ptr_end-ptr) {

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1, const T val2, const T val3, const T val4) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-5;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

       }

       ptr_end+=5;

       switch (ptr_end-ptr) {

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-6;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5; *(ptr++) = val6;

       }

       ptr_end+=6;

       switch (ptr_end-ptr) {

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6);

     }


     CImg<T>& fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6,

                   const T val7) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-7;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3;

         *(ptr++) = val4; *(ptr++) = val5; *(ptr++) = val6; *(ptr++) = val7;

       }

       ptr_end+=7;

       switch (ptr_end-ptr) {

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-8;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2;

         *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8;

       }

       ptr_end+=8;

       switch (ptr_end-ptr) {

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-9;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4;

         *(ptr++) = val5; *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9;

       }

       ptr_end+=9;

       switch (ptr_end-ptr) {

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-10;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4;

         *(ptr++) = val5; *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9;

         *(ptr++) = val10;

       }

       ptr_end+=10;

       switch (ptr_end-ptr) {

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-11;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9; *(ptr++) = val10; *(ptr++) = val11;

       }

       ptr_end+=11;

       switch (ptr_end-ptr) {

       case 11 : *(--ptr_end) = val10;

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-12;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9; *(ptr++) = val10; *(ptr++) = val11;

         *(ptr++) = val12;

       }

       ptr_end+=12;

       switch (ptr_end-ptr) {

       case 12 : *(--ptr_end) = val11;

       case 11 : *(--ptr_end) = val10;

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-13;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9; *(ptr++) = val10; *(ptr++) = val11;

         *(ptr++) = val12; *(ptr++) = val13;

       }

       ptr_end+=13;

       switch (ptr_end-ptr) {

       case 13 : *(--ptr_end) = val12;

       case 12 : *(--ptr_end) = val11;

       case 11 : *(--ptr_end) = val10;

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,

                                                   val13);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-14;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9; *(ptr++) = val10; *(ptr++) = val11;

         *(ptr++) = val12; *(ptr++) = val13; *(ptr++) = val14;

       }

       ptr_end+=14;

       switch (ptr_end-ptr) {

       case 14 : *(--ptr_end) = val13;

       case 13 : *(--ptr_end) = val12;

       case 12 : *(--ptr_end) = val11;

       case 11 : *(--ptr_end) = val10;

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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 {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,

                                                   val13,val14);

     }


     CImg<T>& fill(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) {

       if (is_empty()) return *this;

       T *ptr, *ptr_end = end()-15;

       for (ptr = data; ptr<ptr_end; ) {

         *(ptr++) = val0; *(ptr++) = val1; *(ptr++) = val2; *(ptr++) = val3; *(ptr++) = val4; *(ptr++) = val5;

         *(ptr++) = val6; *(ptr++) = val7; *(ptr++) = val8; *(ptr++) = val9; *(ptr++) = val10; *(ptr++) = val11;

         *(ptr++) = val12; *(ptr++) = val13; *(ptr++) = val14; *(ptr++) = val15;

       }

       ptr_end+=15;

       switch (ptr_end-ptr) {

       case 15 : *(--ptr_end) = val14;

       case 14 : *(--ptr_end) = val13;

       case 13 : *(--ptr_end) = val12;

       case 12 : *(--ptr_end) = val11;

       case 11 : *(--ptr_end) = val10;

       case 10 : *(--ptr_end) = val9;

       case 9 : *(--ptr_end) = val8;

       case 8 : *(--ptr_end) = val7;

       case 7 : *(--ptr_end) = val6;

       case 6 : *(--ptr_end) = val5;

       case 5 : *(--ptr_end) = val4;

       case 4 : *(--ptr_end) = val3;

       case 3 : *(--ptr_end) = val2;

       case 2 : *(--ptr_end) = val1;

       case 1 : *(--ptr_end) = val0;

       }

       return *this;

     }


     CImg<T> get_fill(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) const {

       return CImg<T>(width,height,depth,dim).fill(val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,

                                                   val13,val14,val15);

     }


     CImg<T>& fill(const char *const expression, const bool repeat_flag) {

       if (is_empty() || !expression || !*expression) return *this;

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try { // Try to fill values according to a formula.

         _cimg_math_parser mp(expression,"fill");

         const CImg<T> _base = std::strstr(expression,"i(")?+*this:CImg<T>(), &base = _base?_base:*this;

         T *ptrd = data;

         cimg_forXYZV(*this,x,y,z,v) *(ptrd++) = (T)mp.eval(base,(double)x,(double)y,(double)z,(double)v);

       } catch (CImgException&) { // If failed, try to recognize a list of values.

         char item[16384] = { 0 }, sep = 0; const char *nexpression = expression;

         unsigned int nb = 0; const unsigned int siz = size();

         T *ptrd = data;

         for (double val = 0; *nexpression && nb<siz; ++nb) {

           const int err = std::sscanf(nexpression,"%4095[ \n\t0-9.e+-]%c",item,&sep);

           if (err>0 && std::sscanf(item,"%lf",&val)==1) {

             nexpression += std::strlen(item) + (err>1?1:0);

             *(ptrd++) = (T)val;

           } else break;

         }

         cimg::exception_mode() = omode;

         if (*nexpression)

           throw CImgArgumentException("CImg<%s>::fill() : Invalid expression '%s'.",pixel_type(),expression);

         if (repeat_flag && nb) for (T *ptrs = data, *const ptr_end = data + siz; ptrd<ptr_end; ++ptrs) *(ptrd++) = *ptrs;

       }

       cimg::exception_mode() = omode;

       return *this;

     }


     CImg<T> get_fill(const char *const values, const bool repeat_values) const {

       return (+*this).fill(values,repeat_values);

     }


     template<typename t>

     CImg<T>& fill(const CImg<t>& values, const bool repeat_values=true) {

       if (is_empty() || !values) return *this;

       T *ptrd = data, *ptrd_end = ptrd + size();

       for (t *ptrs = values.data, *ptrs_end = ptrs + values.size(); ptrs<ptrs_end && ptrd<ptrd_end; ++ptrs) *(ptrd++) = (T)*ptrs;

       if (repeat_values && ptrd<ptrd_end) for (T *ptrs = data; ptrd<ptrd_end; ++ptrs) *(ptrd++) = *ptrs;

       return *this;

     }


     template<typename t>

     CImg<T> get_fill(const CImg<t>& values, const bool repeat_values=true) const {

       return repeat_values?CImg<T>(width,height,depth,dim).fill(values,repeat_values):(+*this).fill(values,repeat_values);

     }


     CImg<T>& fillX(const unsigned int y, const unsigned int z, const unsigned int v, const int a0, ...) {

 #define _cimg_fill1(x,y,z,v,off,siz,t) { \

     va_list ap; va_start(ap,a0); T *ptrd = ptr(x,y,z,v); *ptrd = (T)a0; \

     for (unsigned int k = 1; k<siz; ++k) { ptrd+=off; *ptrd = (T)va_arg(ap,t); } \

     va_end(ap); }

       if (y<height && z<depth && v<dim) _cimg_fill1(0,y,z,v,1,width,int);

       return *this;

     }


     CImg<T>& fillX(const unsigned int y, const unsigned int z, const unsigned int v, const double a0, ...) {

       if (y<height && z<depth && v<dim) _cimg_fill1(0,y,z,v,1,width,double);

       return *this;

     }


     CImg<T>& fillY(const unsigned int x, const unsigned int z, const unsigned int v, const int a0, ...) {

       if (x<width && z<depth && v<dim) _cimg_fill1(x,0,z,v,width,height,int);

       return *this;

     }


     CImg<T>& fillY(const unsigned int x, const unsigned int z, const unsigned int v, const double a0, ...) {

       if (x<width && z<depth && v<dim) _cimg_fill1(x,0,z,v,width,height,double);

       return *this;

     }


     CImg<T>& fillZ(const unsigned int x, const unsigned int y, const unsigned int v, const int a0, ...) {

       const unsigned int wh = width*height;

       if (x<width && y<height && v<dim) _cimg_fill1(x,y,0,v,wh,depth,int);

       return *this;

     }


     CImg<T>& fillZ(const unsigned int x, const unsigned int y, const unsigned int v, const double a0, ...) {

       const unsigned int wh = width*height;

       if (x<width && y<height && v<dim) _cimg_fill1(x,y,0,v,wh,depth,double);

       return *this;

     }


     CImg<T>& fillV(const unsigned int x, const unsigned int y, const unsigned int z, const int a0, ...) {

       const unsigned int whz = width*height*depth;

       if (x<width && y<height && z<depth) _cimg_fill1(x,y,z,0,whz,dim,int);

       return *this;

     }


     CImg<T>& fillV(const unsigned int x, const unsigned int y, const unsigned int z, const double a0, ...) {

       const unsigned int whz = width*height*depth;

       if (x<width && y<height && z<depth) _cimg_fill1(x,y,z,0,whz,dim,double);

       return *this;

     }


     CImg<T>& invert_endianness() {

       cimg::invert_endianness(data,size());

       return *this;

     }


     CImg<T> get_invert_endianness() const {

       return (+*this).invert_endianness();

     }


     CImg<T>& rand(const T val_min, const T val_max) {

       const float delta = (float)val_max - (float)val_min;

       cimg_for(*this,ptr,T) *ptr = (T)(val_min + cimg::rand()*delta);

       return *this;

     }


     CImg<T> get_rand(const T val_min, const T val_max) const {

       return (+*this).rand(val_min,val_max);

     }


     CImg<T>& round(const float x, const int rounding_type=0) {

       cimg_for(*this,ptr,T) (*ptr) = (T)cimg::round(*ptr,x,rounding_type);

       return *this;

     }


     CImg<T> get_round(const float x, const unsigned int rounding_type=0) const {

       return (+*this).round(x,rounding_type);

     }


     CImg<T>& noise(const double sigma, const unsigned int noise_type=0) {

       if (!is_empty()) {

         double nsigma = sigma, max = (double)cimg::type<T>::max(), min = (double)cimg::type<T>::min();

         Tfloat m = 0, M = 0;

         if (nsigma==0 && noise_type!=3) return *this;

         if (nsigma<0 || noise_type==2) m = (Tfloat)minmax(M);

         if (nsigma<0) nsigma = -nsigma*(M-m)/100.0;

         switch (noise_type) {

         case 0 : { // Gaussian noise

           cimg_for(*this,ptr,T) {

             double val = *ptr + nsigma*cimg::grand();

             if (val>max) val = max;

             if (val<min) val = min;

             *ptr = (T)val;

           }

         } break;

         case 1 : { // Uniform noise

           cimg_for(*this,ptr,T) {

             double val = *ptr + nsigma*cimg::crand();

             if (val>max) val = max;

             if (val<min) val = min;

             *ptr = (T)val;

           }

         } break;

         case 2 : { // Salt & Pepper noise

           if (nsigma<0) nsigma = -nsigma;

           if (M==m) { m = 0; M = (float)(cimg::type<T>::is_float()?1:cimg::type<T>::max()); }

           cimg_for(*this,ptr,T) if (cimg::rand()*100<nsigma) *ptr = (T)(cimg::rand()<0.5?M:m);

         } break;


         case 3 : { // Poisson Noise

           cimg_for(*this,ptr,T) *ptr = (T)cimg::prand(*ptr);

         } break;


         case 4 : { // Rice noise

           const double sqrt2 = (double)std::sqrt(2.0);

           cimg_for(*this,ptr,T) {

             const double

               val0 = (double)*ptr/sqrt2,

               re = val0 + nsigma*cimg::grand(),

               im = val0 + nsigma*cimg::grand();

             double val = std::sqrt(re*re + im*im);

             if (val>max) val = max;

             if (val<min) val = min;

             *ptr = (T)val;

           }

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::noise() : Invalid noise type %d "

                                       "(should be {0=Gaussian, 1=Uniform, 2=Salt&Pepper, 3=Poisson}).",pixel_type(),noise_type);

         }

       }

       return *this;

     }


     CImg<T> get_noise(const double sigma, const unsigned int noise_type=0) const {

       return (+*this).noise(sigma,noise_type);

     }


     CImg<T>& normalize(const T value_min, const T value_max) {

       if (is_empty()) return *this;

       const T a = value_min<value_max?value_min:value_max, b = value_min<value_max?value_max:value_min;

       T m, M = maxmin(m);

       const Tfloat fm = (Tfloat)m, fM = (Tfloat)M;

       if (m==M) return fill(0);

       if (m!=a || M!=b) cimg_for(*this,ptr,T) *ptr = (T)((*ptr-fm)/(fM-fm)*(b-a)+a);

       return *this;

     }


     CImg<Tfloat> get_normalize(const T value_min, const T value_max) const {

       return CImg<Tfloat>(*this,false).normalize((Tfloat)value_min,(Tfloat)value_max);

     }


     CImg<T>& normalize() {

       cimg_forXYZ(*this,x,y,z) {

         float n = 0;

         cimg_forV(*this,v) n+=(float)((*this)(x,y,z,v)*(*this)(x,y,z,v));

         n = (float)std::sqrt(n);

         if (n>0) cimg_forV(*this,v) (*this)(x,y,z,v) = (T)((*this)(x,y,z,v)/n);

         else cimg_forV(*this,v) (*this)(x,y,z,v) = 0;

       }

       return *this;

     }


     CImg<Tfloat> get_normalize() const {

       return CImg<Tfloat>(*this,false).normalize();

     }


     CImg<T>& norm(const int norm_type=2) {

       return get_norm(norm_type).transfer_to(*this);

     }


     CImg<Tfloat> get_norm(const int norm_type=2) const {

       if (is_empty()) return *this;

       if (dim==1) return get_abs();

       CImg<Tfloat> res(width,height,depth);

       switch (norm_type) {

       case -1 : {             // Linf norm

         cimg_forXYZ(*this,x,y,z) {

           Tfloat n = 0; cimg_forV(*this,v) {

             const Tfloat tmp = (Tfloat)cimg::abs((*this)(x,y,z,v));

             if (tmp>n) n=tmp; res(x,y,z) = n;

           }

         }

       } break;

       case 1 : {              // L1 norm

         cimg_forXYZ(*this,x,y,z) {

           Tfloat n = 0; cimg_forV(*this,v) n+=cimg::abs((*this)(x,y,z,v)); res(x,y,z) = n;

         }

       } break;

       default : {             // L2 norm

         cimg_forXYZ(*this,x,y,z) {

           Tfloat n = 0; cimg_forV(*this,v) n+=(*this)(x,y,z,v)*(*this)(x,y,z,v); res(x,y,z) = (Tfloat)std::sqrt((double)n);

         }

       }

       }

       return res;

     }


     CImg<T>& cut(const T value_min, const T value_max) {

       if (is_empty()) return *this;

       const T a = value_min<value_max?value_min:value_max, b = value_min<value_max?value_max:value_min;

       cimg_for(*this,ptr,T) *ptr = (*ptr<a)?a:((*ptr>b)?b:*ptr);

       return *this;

     }


     CImg<T> get_cut(const T value_min, const T value_max) const {

       return (+*this).cut(value_min,value_max);

     }


     CImg<T>& quantize(const unsigned int nb_levels, const bool keep_range=true) {

       if (is_empty()) return *this;

       if (!nb_levels)

         throw CImgArgumentException("CImg<%s>::quantize() : Cannot quantize image to 0 values.",

                                     pixel_type());

       Tfloat m, M = (Tfloat)maxmin(m), range = M - m;

       if (range>0) {

         if (keep_range) cimg_for(*this,ptr,T) {

           const unsigned int val = (unsigned int)((*ptr-m)*nb_levels/range);

           *ptr = (T)(m + cimg::min(val,nb_levels-1)*range/nb_levels);

         } else cimg_for(*this,ptr,T) {

           const unsigned int val = (unsigned int)((*ptr-m)*nb_levels/range);

           *ptr = (T)cimg::min(val,nb_levels-1);

         }

       }

       return *this;

     }


     CImg<T> get_quantize(const unsigned int n, const bool keep_range=true) const {

       return (+*this).quantize(n,keep_range);

     }


     CImg<T>& threshold(const T value, const bool soft_threshold=false, const bool strict_threshold=false) {

       if (is_empty()) return *this;

       if (strict_threshold) {

         if (soft_threshold) cimg_for(*this,ptr,T) { const T v = *ptr; *ptr = v>value?(T)(v-value):v<-(float)value?(T)(v+value):(T)0; }

         else cimg_for(*this,ptr,T) *ptr = *ptr>value?(T)1:(T)0;

       } else {

         if (soft_threshold) cimg_for(*this,ptr,T) { const T v = *ptr; *ptr = v>=value?(T)(v-value):v<=-(float)value?(T)(v+value):(T)0; }

         else cimg_for(*this,ptr,T) *ptr = *ptr>=value?(T)1:(T)0;

       }

       return *this;

     }


     CImg<T> get_threshold(const T value, const bool soft_threshold=false, const bool strict_threshold=false) const {

       return (+*this).threshold(value,soft_threshold,strict_threshold);

     }


     CImg<T>& histogram(const unsigned int nb_levels, const T value_min=(T)0, const T value_max=(T)0) {

       return get_histogram(nb_levels,value_min,value_max).transfer_to(*this);

     }


     CImg<floatT> get_histogram(const unsigned int nb_levels, const T value_min=(T)0, const T value_max=(T)0) const {

       if (is_empty()) return CImg<floatT>();

       if (!nb_levels)

         throw CImgArgumentException("CImg<%s>::histogram() : Cannot compute an histogram with 0 levels",

                                     pixel_type());

       T vmin = value_min, vmax = value_max;

       CImg<floatT> res(nb_levels,1,1,1,0);

       if (vmin>=vmax && vmin==0) vmin = minmax(vmax);

       if (vmin<vmax) cimg_for(*this,ptr,T) {

         const T val = *ptr;

         if (val>=vmin && val<=vmax) ++res[val==vmax?nb_levels-1:(int)((val-vmin)*nb_levels/(vmax-vmin))];

       } else res[0]+=size();

       return res;

     }


     CImg<T>& equalize(const unsigned int nb_levels, const T value_min=(T)0, const T value_max=(T)0) {

       if (is_empty()) return *this;

       T vmin = value_min, vmax = value_max;

       if (vmin==vmax && vmin==0) vmin = minmax(vmax);

       if (vmin<vmax) {

         CImg<floatT> hist = get_histogram(nb_levels,vmin,vmax);

         float cumul = 0;

         cimg_forX(hist,pos) { cumul+=hist[pos]; hist[pos] = cumul; }

         cimg_for(*this,ptr,T) {

           const int pos = (unsigned int)((*ptr-vmin)*(nb_levels-1)/(vmax-vmin));

           if (pos>=0 && pos<(int)nb_levels) *ptr = (T)(vmin + (vmax-vmin)*hist[pos]/size());

         }

       }

       return *this;

     }


     CImg<T> get_equalize(const unsigned int nblevels, const T val_min=(T)0, const T val_max=(T)0) const {

       return (+*this).equalize(nblevels,val_min,val_max);

     }


     template<typename t>

     CImg<T>& index(const CImg<t>& palette, const bool dithering=false, const bool map_indexes=false) {

       return get_index(palette,dithering,map_indexes).transfer_to(*this);

     }


     template<typename t>

     CImg<typename cimg::superset<t,unsigned int>::type>

     get_index(const CImg<t>& palette, const bool dithering=false, const bool map_indexes=true) const {

       typedef typename cimg::superset<t,unsigned int>::type tuint;

       if (is_empty()) return CImg<tuint>();

       if (palette.dim!=dim)

         throw CImgArgumentException("CImg<%s>::index() : Palette (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) "

                                     "have incompatible sizes.",pixel_type(),

                                     palette.width,palette.height,palette.depth,palette.dim,palette.data,

                                     width,height,depth,dim,data);

       const unsigned int whz = width*height*depth, pwhz = palette.width*palette.height*palette.depth;

       CImg<tuint> res(width,height,depth,map_indexes?dim:1);

       tuint *ptrd = res.data;

       if (dithering) { // Dithered versions.

         Tfloat valm = 0, valM = (Tfloat)maxmin(valm);

         if (valm==valM && valm>=0 && valM<=255) { valm = 0; valM = 255; }

         CImg<Tfloat> cache = get_crop(-1,0,0,0,width,1,0,dim-1);

         Tfloat *cache_current = cache.ptr(1,0,0,0), *cache_next = cache.ptr(1,1,0,0);

         const unsigned int cwhz = cache.width*cache.height*cache.depth;

         switch (dim) {

         case 1 : { // Optimized for scalars.

           cimg_forYZ(*this,y,z) {

             if (y<dimy()-2) {

               Tfloat *ptrc0 = cache_next; const T *ptrs0 = ptr(0,y+1,z,0);

               cimg_forX(*this,x) *(ptrc0++) = (Tfloat)*(ptrs0++);

             }

             Tfloat *ptrs0 = cache_current, *ptrsn0 = cache_next;

             cimg_forX(*this,x) {

               const Tfloat _val0 = (Tfloat)*ptrs0, val0 = _val0<valm?valm:_val0>valM?valM:_val0;

               Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

               for (const t *ptrp0 = palette.data, *ptrp_end = ptrp0 + pwhz; ptrp0<ptrp_end; ) {

                 const Tfloat pval0 = (Tfloat)*(ptrp0++) - val0, dist = pval0*pval0;

                 if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

               }

               const Tfloat err0 = ((*(ptrs0++)=val0) - (Tfloat)*ptrmin0)/16;

               *ptrs0 += 7*err0; *(ptrsn0-1) += 3*err0; *(ptrsn0++) += 5*err0; *ptrsn0 += err0;

               if (map_indexes) *(ptrd++) = (tuint)*ptrmin0; else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

             }

             cimg::swap(cache_current,cache_next);

           }

         } break;

         case 2 : { // Optimized for 2D vectors.

           tuint *ptrd1 = ptrd + whz;

           cimg_forYZ(*this,y,z) {

             if (y<dimy()-2) {

               Tfloat *ptrc0 = cache_next, *ptrc1 = ptrc0 + cwhz;

               const T *ptrs0 = ptr(0,y+1,z,0), *ptrs1 = ptrs0 + whz;

               cimg_forX(*this,x) { *(ptrc0++) = (Tfloat)*(ptrs0++); *(ptrc1++) = (Tfloat)*(ptrs1++); }

             }

             Tfloat

               *ptrs0 = cache_current, *ptrs1 = ptrs0 + cwhz,

               *ptrsn0 = cache_next, *ptrsn1 = ptrsn0 + cwhz;

             cimg_forX(*this,x) {

               const Tfloat

                 _val0 = (Tfloat)*ptrs0, val0 = _val0<valm?valm:_val0>valM?valM:_val0,

                 _val1 = (Tfloat)*ptrs1, val1 = _val1<valm?valm:_val1>valM?valM:_val1;

               Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

               for (const t *ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz, *ptrp_end = ptrp1; ptrp0<ptrp_end; ) {

                 const Tfloat

                   pval0 = (Tfloat)*(ptrp0++) - val0, pval1 = (Tfloat)*(ptrp1++) - val1,

                   dist = pval0*pval0 + pval1*pval1;

                 if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

               }

               const t *const ptrmin1 = ptrmin0 + pwhz;

               const Tfloat

                 err0 = ((*(ptrs0++)=val0) - (Tfloat)*ptrmin0)/16,

                 err1 = ((*(ptrs1++)=val1) - (Tfloat)*ptrmin1)/16;

               *ptrs0 += 7*err0; *ptrs1 += 7*err1;

               *(ptrsn0-1) += 3*err0; *(ptrsn1-1) += 3*err1;

               *(ptrsn0++) += 5*err0; *(ptrsn1++) += 5*err1;

               *ptrsn0 += err0; *ptrsn1 += err1;

               if (map_indexes) { *(ptrd++) = (tuint)*ptrmin0; *(ptrd1++) = (tuint)*ptrmin1; }

               else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

             }

             cimg::swap(cache_current,cache_next);

           }

         } break;

         case 3 : { // Optimized for 3D vectors (colors).

           tuint *ptrd1 = ptrd + whz, *ptrd2 = ptrd1 + whz;

           cimg_forYZ(*this,y,z) {

             if (y<dimy()-2) {

               Tfloat *ptrc0 = cache_next, *ptrc1 = ptrc0 + cwhz, *ptrc2 = ptrc1 + cwhz;

               const T *ptrs0 = ptr(0,y+1,z,0), *ptrs1 = ptrs0 + whz, *ptrs2 = ptrs1 + whz;

               cimg_forX(*this,x) { *(ptrc0++) = (Tfloat)*(ptrs0++); *(ptrc1++) = (Tfloat)*(ptrs1++); *(ptrc2++) = (Tfloat)*(ptrs2++); }

             }

             Tfloat

               *ptrs0 = cache_current, *ptrs1 = ptrs0 + cwhz, *ptrs2 = ptrs1 + cwhz,

               *ptrsn0 = cache_next, *ptrsn1 = ptrsn0 + cwhz, *ptrsn2 = ptrsn1 + cwhz;

             cimg_forX(*this,x) {

               const Tfloat

                 _val0 = (Tfloat)*ptrs0, val0 = _val0<valm?valm:_val0>valM?valM:_val0,

                 _val1 = (Tfloat)*ptrs1, val1 = _val1<valm?valm:_val1>valM?valM:_val1,

                 _val2 = (Tfloat)*ptrs2, val2 = _val2<valm?valm:_val2>valM?valM:_val2;

               Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

               for (const t *ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz, *ptrp2 = ptrp1 + pwhz, *ptrp_end = ptrp1; ptrp0<ptrp_end; ) {

                 const Tfloat

                   pval0 = (Tfloat)*(ptrp0++) - val0, pval1 = (Tfloat)*(ptrp1++) - val1, pval2 = (Tfloat)*(ptrp2++) - val2,

                   dist = pval0*pval0 + pval1*pval1 + pval2*pval2;

                 if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

               }

               const t *const ptrmin1 = ptrmin0 + pwhz, *const ptrmin2 = ptrmin1 + pwhz;

               const Tfloat

                 err0 = ((*(ptrs0++)=val0) - (Tfloat)*ptrmin0)/16,

                 err1 = ((*(ptrs1++)=val1) - (Tfloat)*ptrmin1)/16,

                 err2 = ((*(ptrs2++)=val2) - (Tfloat)*ptrmin2)/16;

               *ptrs0 += 7*err0; *ptrs1 += 7*err1; *ptrs2 += 7*err2;

               *(ptrsn0-1) += 3*err0; *(ptrsn1-1) += 3*err1; *(ptrsn2-1) += 3*err2;

               *(ptrsn0++) += 5*err0; *(ptrsn1++) += 5*err1; *(ptrsn2++) += 5*err2;

               *ptrsn0 += err0; *ptrsn1 += err1; *ptrsn2 += err2;

               if (map_indexes) { *(ptrd++) = (tuint)*ptrmin0; *(ptrd1++) = (tuint)*ptrmin1; *(ptrd2++) = (tuint)*ptrmin2; }

               else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

             }

             cimg::swap(cache_current,cache_next);

           }

         } break;

         default : // Generic version

           cimg_forYZ(*this,y,z) {

             if (y<dimy()-2) {

               Tfloat *ptrc = cache_next;

               cimg_forV(*this,k) {

                 Tfloat *_ptrc = ptrc; const T *_ptrs = ptr(0,y+1,z,k);

                 cimg_forX(*this,x) *(_ptrc++) = (Tfloat)*(_ptrs++);

                 ptrc+=cwhz;

               }

             }

             Tfloat *ptrs = cache_current, *ptrsn = cache_next;

             cimg_forX(*this,x) {

               Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin = palette.data;

               for (const t *ptrp = palette.data, *ptrp_end = ptrp + pwhz; ptrp<ptrp_end; ++ptrp) {

                 Tfloat dist = 0; Tfloat *_ptrs = ptrs; const t *_ptrp = ptrp;

                 cimg_forV(*this,k) {

                   const Tfloat _val = *_ptrs, val = _val<valm?valm:_val>valM?valM:_val;

                   dist += cimg::sqr((*_ptrs=val) - (Tfloat)*_ptrp); _ptrs+=cwhz; _ptrp+=pwhz;

                 }

                 if (dist<distmin) { ptrmin = ptrp; distmin = dist; }

               }

               const t *_ptrmin = ptrmin; Tfloat *_ptrs = ptrs++, *_ptrsn = (ptrsn++)-1;

               cimg_forV(*this,k) {

                 const Tfloat err = (*(_ptrs++) - (Tfloat)*_ptrmin)/16;

                 *_ptrs += 7*err; *(_ptrsn++) += 3*err; *(_ptrsn++) += 5*err; *_ptrsn += err;

                 _ptrmin+=pwhz; _ptrs+=cwhz-1; _ptrsn+=cwhz-2;

               }

               if (map_indexes) { tuint *_ptrd = ptrd++; cimg_forV(*this,k) { *_ptrd = (tuint)*ptrmin; _ptrd+=whz; ptrmin+=pwhz; }}

               else *(ptrd++) = (tuint)(ptrmin - palette.data);

             }

             cimg::swap(cache_current,cache_next);

           }

         }

       } else { // Non-dithered versions

         switch (dim) {

         case 1 : { // Optimized for scalars.

           for (const T *ptrs0 = data, *ptrs_end = ptrs0 + whz; ptrs0<ptrs_end; ) {

             const Tfloat val0 = (Tfloat)*(ptrs0++);

             Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

             for (const t *ptrp0 = palette.data, *ptrp_end = ptrp0 + pwhz; ptrp0<ptrp_end; ) {

               const Tfloat pval0 = (Tfloat)*(ptrp0++) - val0, dist = pval0*pval0;

               if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

             }

             if (map_indexes) *(ptrd++) = (tuint)*ptrmin0; else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

           }

         } break;

         case 2 : { // Optimized for 2D vectors.

           tuint *ptrd1 = ptrd + whz;

           for (const T *ptrs0 = data, *ptrs1 = ptrs0 + whz, *ptrs_end = ptrs1; ptrs0<ptrs_end; ) {

             const Tfloat val0 = (Tfloat)*(ptrs0++), val1 = (Tfloat)*(ptrs1++);

             Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

             for (const t *ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz, *ptrp_end = ptrp1; ptrp0<ptrp_end; ) {

               const Tfloat

                 pval0 = (Tfloat)*(ptrp0++) - val0, pval1 = (Tfloat)*(ptrp1++) - val1,

                 dist = pval0*pval0 + pval1*pval1;

               if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

             }

             if (map_indexes) { *(ptrd++) = (tuint)*ptrmin0; *(ptrd1++) = (tuint)*(ptrmin0 + pwhz); }

             else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

           }

         } break;

         case 3 : { // Optimized for 3D vectors (colors).

           tuint *ptrd1 = ptrd + whz, *ptrd2 = ptrd1 + whz;

           for (const T *ptrs0 = data, *ptrs1 = ptrs0 + whz, *ptrs2 = ptrs1 + whz, *ptrs_end = ptrs1; ptrs0<ptrs_end; ) {

             const Tfloat val0 = (Tfloat)*(ptrs0++), val1 = (Tfloat)*(ptrs1++), val2 = (Tfloat)*(ptrs2++);

             Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin0 = palette.data;

             for (const t *ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz, *ptrp2 = ptrp1 + pwhz, *ptrp_end = ptrp1; ptrp0<ptrp_end; ) {

               const Tfloat

                 pval0 = (Tfloat)*(ptrp0++) - val0, pval1 = (Tfloat)*(ptrp1++) - val1, pval2 = (Tfloat)*(ptrp2++) - val2,

                 dist = pval0*pval0 + pval1*pval1 + pval2*pval2;

               if (dist<distmin) { ptrmin0 = ptrp0 - 1; distmin = dist; }

             }

             if (map_indexes) { *(ptrd++) = (tuint)*ptrmin0; *(ptrd1++) = (tuint)*(ptrmin0 + pwhz); *(ptrd2++) = (tuint)*(ptrmin0 + 2*pwhz); }

             else *(ptrd++) = (tuint)(ptrmin0 - palette.data);

           }

         } break;

         default : // Generic version.

           for (const T *ptrs = data, *ptrs_end = ptrs + whz; ptrs<ptrs_end; ++ptrs) {

             Tfloat distmin = cimg::type<Tfloat>::max(); const t *ptrmin = palette.data;

             for (const t *ptrp = palette.data, *ptrp_end = ptrp + pwhz; ptrp<ptrp_end; ++ptrp) {

               Tfloat dist = 0; const T *_ptrs = ptrs; const t *_ptrp = ptrp;

               cimg_forV(*this,k) { dist += cimg::sqr((Tfloat)*_ptrs - (Tfloat)*_ptrp); _ptrs+=whz; _ptrp+=pwhz; }

               if (dist<distmin) { ptrmin = ptrp; distmin = dist; }

             }

             if (map_indexes) { tuint *_ptrd = ptrd++; cimg_forV(*this,k) { *_ptrd = (tuint)*ptrmin; _ptrd+=whz; ptrmin+=pwhz; }}

             else *(ptrd++) = (tuint)(ptrmin - palette.data);

           }

         }

       }

       return res;

     }


     template<typename t>

     CImg<T>& map(const CImg<t>& palette) {

       return get_map(palette).transfer_to(*this);

     }


     template<typename t>

     CImg<t> get_map(const CImg<t>& palette) const {

       if (dim!=1 && palette.dim!=1)

         throw CImgArgumentException("CImg<%s>::map() : Palette (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) "

                                     "have incompatible sizes.",pixel_type(),

                                     palette.width,palette.height,palette.depth,palette.dim,palette.data,

                                     width,height,depth,dim,data);

       const unsigned int whz = width*height*depth, pwhz = palette.width*palette.height*palette.depth;

       CImg<t> res(width,height,depth,palette.dim==1?dim:palette.dim);

       switch (palette.dim) {

       case 1 : { // Optimized for scalars.

         const T *ptrs = data + whz*dim;

         cimg_for(res,ptrd,t) {

           const unsigned int _ind = (unsigned int)*(--ptrs), ind = _ind<pwhz?_ind:0;

           *ptrd = palette[ind];

         }

       } break;

       case 2 : { // Optimized for 2D vectors.

         const t *const ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz;

         t *ptrd0 = res.data, *ptrd1 = ptrd0 + whz;

         for (const T *ptrs = data, *ptrs_end = ptrs + whz; ptrs<ptrs_end; ) {

           const unsigned int _ind = (unsigned int)*(ptrs++), ind = _ind<pwhz?_ind:0;

           *(ptrd0++) = ptrp0[ind]; *(ptrd1++) = ptrp1[ind];

         }

       } break;

       case 3 : { // Optimized for 3D vectors (colors).

         const t *const ptrp0 = palette.data, *ptrp1 = ptrp0 + pwhz, *ptrp2 = ptrp1 + pwhz;

         t *ptrd0 = res.data, *ptrd1 = ptrd0 + whz, *ptrd2 = ptrd1 + whz;

         for (const T *ptrs = data, *ptrs_end = ptrs + whz; ptrs<ptrs_end; ) {

           const unsigned int _ind = (unsigned int)*(ptrs++), ind = _ind<pwhz?_ind:0;

           *(ptrd0++) = ptrp0[ind]; *(ptrd1++) = ptrp1[ind]; *(ptrd2++) = ptrp2[ind];

         }

       } break;

       default : { // Generic version.

         t *ptrd = res.data;

         for (const T *ptrs = data, *ptrs_end = ptrs + whz; ptrs<ptrs_end; ) {

           const unsigned int _ind = (unsigned int)*(ptrs++), ind = _ind<pwhz?_ind:0;

           const t *ptrp = palette.data + ind;

           t *_ptrd = ptrd++; cimg_forV(res,k) { *_ptrd = *ptrp; _ptrd+=whz; ptrp+=pwhz; }

         }

       }

       }

       return res;

     }


     CImg<T>& label_regions() {

       return get_label_regions().transfer_to(*this);

     }


     CImg<uintT> get_label_regions() const {

 #define _cimg_get_label_test(p,q) { \

   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); } \

 }

       if (depth>1)

         throw CImgInstanceException("CImg<%s>::label_regions() : Instance image must be a 2D image");

       CImg<uintT> res(width,height,depth,1,0);

       unsigned int label = 1;

       const unsigned int wh = width*height, siz = width*height*dim;

       const int W1 = dimx()-1, H1 = dimy()-1;

       bool flag;

       cimg_forXY(*this,x,y) {

         bool done = false;

         if (y) {

           _cimg_get_label_test(x,y-1);

           if (flag) {

             const unsigned int lab = (res(x,y) = res(x,y-1));

             done = true;

             if (x && res(x-1,y)!=lab) {

               _cimg_get_label_test(x-1,y);

               if (flag) {

                 const unsigned int lold = res(x-1,y), *const cptr = res.ptr(x,y);

                 for (unsigned int *ptr = res.ptr(); ptr<cptr; ++ptr) if (*ptr==lold) *ptr = lab;

               }

             }

           }

         }

         if (x && !done) { _cimg_get_label_test(x-1,y); if (flag) { res(x,y) = res(x-1,y); done = true; }}

         if (!done) res(x,y) = label++;

       }

       for (int y = H1; y>=0; --y) for (int x=W1; x>=0; --x) {

         bool done = false;

         if (y<H1) {

           _cimg_get_label_test(x,y+1);

           if (flag) {

             const unsigned int lab = (res(x,y) = res(x,y+1));

             done = true;

             if (x<W1 && res(x+1,y)!=lab) {

               _cimg_get_label_test(x+1,y);

               if (flag) {

                 const unsigned int lold = res(x+1,y), *const cptr = res.ptr(x,y);

                 for (unsigned int *ptr = res.ptr()+res.size()-1; ptr>cptr; --ptr) if (*ptr==lold) *ptr = lab;

               }

             }

           }

         }

         if (x<W1 && !done) { _cimg_get_label_test(x+1,y); if (flag) res(x,y) = res(x+1,y); done = true; }

       }

       const unsigned int lab0 = res.max()+1;

       label = lab0;

       cimg_foroff(res,off) { // Relabel regions

         const unsigned int lab = res[off];

         if (lab<lab0) { cimg_for(res,ptr,unsigned int) if (*ptr==lab) *ptr = label; ++label; }

       }

       return (res-=lab0);

     }


     //---------------------------------

     //


     //---------------------------------


     static CImg<Tuchar> default_LUT256() {

       static CImg<Tuchar> palette;

       if (!palette) {

         palette.assign(1,256,1,3);

         for (unsigned int index = 0, r = 16; r<256; r+=32)

           for (unsigned int g = 16; g<256; g+=32)

             for (unsigned int b = 32; b<256; b+=64) {

               palette(0,index,0) = (Tuchar)r;

               palette(0,index,1) = (Tuchar)g;

               palette(0,index++,2) = (Tuchar)b;

             }

       }

       return palette;

     }


     static CImg<Tuchar> rainbow_LUT256() {

       static CImg<Tuchar> palette;

       if (!palette) {

         CImg<Tint> tmp(1,256,1,3,1);

         tmp.get_shared_channel(0).sequence(0,359);

         palette = tmp.HSVtoRGB();

       }

       return palette;

     }


     static CImg<Tuchar> contrast_LUT256() {

       static const unsigned char pal[] = {

         217,62,88,75,1,237,240,12,56,160,165,116,1,1,204,2,15,248,148,185,133,141,46,246,222,116,16,5,207,226,

         17,114,247,1,214,53,238,0,95,55,233,235,109,0,17,54,33,0,90,30,3,0,94,27,19,0,68,212,166,130,0,15,7,119,

         238,2,246,198,0,3,16,10,13,2,25,28,12,6,2,99,18,141,30,4,3,140,12,4,30,233,7,10,0,136,35,160,168,184,20,

         233,0,1,242,83,90,56,180,44,41,0,6,19,207,5,31,214,4,35,153,180,75,21,76,16,202,218,22,17,2,136,71,74,

         81,251,244,148,222,17,0,234,24,0,200,16,239,15,225,102,230,186,58,230,110,12,0,7,129,249,22,241,37,219,

         1,3,254,210,3,212,113,131,197,162,123,252,90,96,209,60,0,17,0,180,249,12,112,165,43,27,229,77,40,195,12,

         87,1,210,148,47,80,5,9,1,137,2,40,57,205,244,40,8,252,98,0,40,43,206,31,187,0,180,1,69,70,227,131,108,0,

         223,94,228,35,248,243,4,16,0,34,24,2,9,35,73,91,12,199,51,1,249,12,103,131,20,224,2,70,32,

         233,1,165,3,8,154,246,233,196,5,0,6,183,227,247,195,208,36,0,0,226,160,210,198,69,153,210,1,23,8,192,2,4,

         137,1,0,52,2,249,241,129,0,0,234,7,238,71,7,32,15,157,157,252,158,2,250,6,13,30,11,162,0,199,21,11,27,224,

         4,157,20,181,111,187,218,3,0,11,158,230,196,34,223,22,248,135,254,210,157,219,0,117,239,3,255,4,227,5,247,

         11,4,3,188,111,11,105,195,2,0,14,1,21,219,192,0,183,191,113,241,1,12,17,248,0,48,7,19,1,254,212,0,239,246,

         0,23,0,250,165,194,194,17,3,253,0,24,6,0,141,167,221,24,212,2,235,243,0,0,205,1,251,133,204,28,4,6,1,10,

         141,21,74,12,236,254,228,19,1,0,214,1,186,13,13,6,13,16,27,209,6,216,11,207,251,59,32,9,155,23,19,235,143,

         116,6,213,6,75,159,23,6,0,228,4,10,245,249,1,7,44,234,4,102,174,0,19,239,103,16,15,18,8,214,22,4,47,244,

         255,8,0,251,173,1,212,252,250,251,252,6,0,29,29,222,233,246,5,149,0,182,180,13,151,0,203,183,0,35,149,0,

         235,246,254,78,9,17,203,73,11,195,0,3,5,44,0,0,237,5,106,6,130,16,214,20,168,247,168,4,207,11,5,1,232,251,

         129,210,116,231,217,223,214,27,45,38,4,177,186,249,7,215,172,16,214,27,249,230,236,2,34,216,217,0,175,30,

         243,225,244,182,20,212,2,226,21,255,20,0,2,13,62,13,191,14,76,64,20,121,4,118,0,216,1,147,0,2,210,1,215,

         95,210,236,225,184,46,0,248,24,11,1,9,141,250,243,9,221,233,160,11,147,2,55,8,23,12,253,9,0,54,0,231,6,3,

         141,8,2,246,9,180,5,11,8,227,8,43,110,242,1,130,5,97,36,10,6,219,86,133,11,108,6,1,5,244,67,19,28,0,174,

         154,16,127,149,252,188,196,196,228,244,9,249,0,0,0,37,170,32,250,0,73,255,23,3,224,234,38,195,198,0,255,87,

         33,221,174,31,3,0,189,228,6,153,14,144,14,108,197,0,9,206,245,254,3,16,253,178,248,0,95,125,8,0,3,168,21,

         23,168,19,50,240,244,185,0,1,144,10,168,31,82,1,13 };

       static const CImg<Tuchar> palette(pal,1,256,1,3,false);

       return palette;

     }


     CImg<T>& RGBtoHSV() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoHSV() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image.",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1,

           G = (Tfloat)*p2,

           B = (Tfloat)*p3,

           nR = (R<0?0:(R>255?255:R))/255,

           nG = (G<0?0:(G>255?255:G))/255,

           nB = (B<0?0:(B>255?255:B))/255,

           m = cimg::min(nR,nG,nB),

           M = cimg::max(nR,nG,nB);

         Tfloat H = 0, S = 0;

         if (M!=m) {

           const Tfloat

             f = (nR==m)?(nG-nB):((nG==m)?(nB-nR):(nR-nG)),

             i = (Tfloat)((nR==m)?3:((nG==m)?5:1));

           H = (i-f/(M-m));

           if (H>=6) H-=6;

           H*=60;

           S = (M-m)/M;

         }

         *(p1++) = (T)H;

         *(p2++) = (T)S;

         *(p3++) = (T)M;

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoHSV() const {

       return CImg<Tfloat>(*this,false).RGBtoHSV();

     }


     CImg<T>& HSVtoRGB() {

     if (is_empty()) return *this;

     if (dim!=3)

       throw CImgInstanceException("CImg<%s>::HSVtoRGB() : Input image dimension is dim=%u, "

                                   "should be a (H,S,V) image",

                                   pixel_type(),dim);

     T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

     for (unsigned int N = width*height*depth; N; --N) {

       Tfloat

         H = (Tfloat)*p1,

         S = (Tfloat)*p2,

         V = (Tfloat)*p3,

         R = 0, G = 0, B = 0;

       if (H==0 && S==0) R = G = B = V;

       else {

         H/=60;

         const int i = (int)std::floor(H);

         const Tfloat

           f = (i&1)?(H-i):(1-H+i),

           m = V*(1-S),

           n = V*(1-S*f);

         switch (i) {

         case 6 :

         case 0 : R = V; G = n; B = m; break;

         case 1 : R = n; G = V; B = m; break;

         case 2 : R = m; G = V; B = n; break;

         case 3 : R = m; G = n; B = V; break;

         case 4 : R = n; G = m; B = V; break;

         case 5 : R = V; G = m; B = n; break;

         }

       }

       R*=255; G*=255; B*=255;

       *(p1++) = (T)(R<0?0:(R>255?255:R));

       *(p2++) = (T)(G<0?0:(G>255?255:G));

       *(p3++) = (T)(B<0?0:(B>255?255:B));

     }

     return *this;

     }


     CImg<Tuchar> get_HSVtoRGB() const {

       return CImg<Tuchar>(*this,false).HSVtoRGB();

     }


     CImg<T>& RGBtoHSL() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoHSL() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image.",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1,

           G = (Tfloat)*p2,

           B = (Tfloat)*p3,

           nR = (R<0?0:(R>255?255:R))/255,

           nG = (G<0?0:(G>255?255:G))/255,

           nB = (B<0?0:(B>255?255:B))/255,

           m = cimg::min(nR,nG,nB),

           M = cimg::max(nR,nG,nB),

           L = (m+M)/2;

         Tfloat H = 0, S = 0;

         if (M==m) H = S = 0;

         else {

           const Tfloat

             f = (nR==m)?(nG-nB):((nG==m)?(nB-nR):(nR-nG)),

             i = (nR==m)?3.0f:((nG==m)?5.0f:1.0f);

           H = (i-f/(M-m));

           if (H>=6) H-=6;

           H*=60;

           S = (2*L<=1)?((M-m)/(M+m)):((M-m)/(2-M-m));

         }

         *(p1++) = (T)H;

         *(p2++) = (T)S;

         *(p3++) = (T)L;

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoHSL() const {

       return CImg< Tfloat>(*this,false).RGBtoHSL();

     }


     CImg<T>& HSLtoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::HSLtoRGB() : Input image dimension is dim=%u, "

                                     "should be a (H,S,V) image",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           H = (Tfloat)*p1,

           S = (Tfloat)*p2,

           L = (Tfloat)*p3,

           q = 2*L<1?L*(1+S):(L+S-L*S),

           p = 2*L-q,

           h = H/360,

           tr = h + 1.0f/3,

           tg = h,

           tb = h - 1.0f/3,

           ntr = tr<0?tr+1:(tr>1?tr-1:tr),

           ntg = tg<0?tg+1:(tg>1?tg-1:tg),

           ntb = tb<0?tb+1:(tb>1?tb-1:tb),

           R = 255*(6*ntr<1?p+(q-p)*6*ntr:(2*ntr<1?q:(3*ntr<2?p+(q-p)*6*(2.0f/3-ntr):p))),

           G = 255*(6*ntg<1?p+(q-p)*6*ntg:(2*ntg<1?q:(3*ntg<2?p+(q-p)*6*(2.0f/3-ntg):p))),

           B = 255*(6*ntb<1?p+(q-p)*6*ntb:(2*ntb<1?q:(3*ntb<2?p+(q-p)*6*(2.0f/3-ntb):p)));

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tuchar> get_HSLtoRGB() const {

       return CImg<Tuchar>(*this,false).HSLtoRGB();

     }


     CImg<T>& RGBtoHSI() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoHSI() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image.",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1,

           G = (Tfloat)*p2,

           B = (Tfloat)*p3,

           nR = (R<0?0:(R>255?255:R))/255,

           nG = (G<0?0:(G>255?255:G))/255,

           nB = (B<0?0:(B>255?255:B))/255,

           m = cimg::min(nR,nG,nB),

           theta = (Tfloat)(std::acos(0.5f*((nR-nG)+(nR-nB))/std::sqrt(std::pow(nR-nG,2)+(nR-nB)*(nG-nB)))*180/cimg::valuePI),

           sum = nR + nG + nB;

         Tfloat H = 0, S = 0, I = 0;

         if (theta>0) H = (nB<=nG)?theta:360-theta;

         if (sum>0) S = 1 - 3/sum*m;

         I = sum/3;

         *(p1++) = (T)H;

         *(p2++) = (T)S;

         *(p3++) = (T)I;

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoHSI() const {

       return CImg<Tfloat>(*this,false).RGBtoHSI();

     }


     CImg<T>& HSItoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::HSItoRGB() : Input image dimension is dim=%u, "

                                     "should be a (H,S,I) image",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         Tfloat

           H = (Tfloat)*p1,

           S = (Tfloat)*p2,

           I = (Tfloat)*p3,

           a = I*(1-S),

           R = 0, G = 0, B = 0;

         if (H<120) {

           B = a;

           R = (Tfloat)(I*(1+S*std::cos(H*cimg::valuePI/180)/std::cos((60-H)*cimg::valuePI/180)));

           G = 3*I-(R+B);

         } else if (H<240) {

           H-=120;

           R = a;

           G = (Tfloat)(I*(1+S*std::cos(H*cimg::valuePI/180)/std::cos((60-H)*cimg::valuePI/180)));

           B = 3*I-(R+G);

         } else {

           H-=240;

           G = a;

           B = (Tfloat)(I*(1+S*std::cos(H*cimg::valuePI/180)/std::cos((60-H)*cimg::valuePI/180)));

           R = 3*I-(G+B);

         }

         R*=255; G*=255; B*=255;

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tfloat> get_HSItoRGB() const {

       return CImg< Tuchar>(*this,false).HSItoRGB();

     }


     CImg<T>& RGBtoYCbCr() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoYCbCr() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1,

           G = (Tfloat)*p2,

           B = (Tfloat)*p3,

           Y = (66*R + 129*G + 25*B + 128)/256 + 16,

           Cb = (-38*R - 74*G + 112*B + 128)/256 + 128,

           Cr = (112*R - 94*G - 18*B + 128)/256 + 128;

         *(p1++) = (T)(Y<0?0:(Y>255?255:Y));

         *(p2++) = (T)(Cb<0?0:(Cb>255?255:Cb));

         *(p3++) = (T)(Cr<0?0:(Cr>255?255:Cr));

       }

       return *this;

     }


     CImg<Tuchar> get_RGBtoYCbCr() const {

       return CImg<Tuchar>(*this,false).RGBtoYCbCr();

     }


     CImg<T>& YCbCrtoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::YCbCrtoRGB() : Input image dimension is dim=%u, "

                                     "should be a (Y,Cb,Cr)_8 image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           Y = (Tfloat)*p1 - 16,

           Cb = (Tfloat)*p2 - 128,

           Cr = (Tfloat)*p3 - 128,

           R = (298*Y + 409*Cr + 128)/256,

           G = (298*Y - 100*Cb - 208*Cr + 128)/256,

           B = (298*Y + 516*Cb + 128)/256;

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tuchar> get_YCbCrtoRGB() const {

       return CImg<Tuchar>(*this,false).YCbCrtoRGB();

     }


     CImg<T>& RGBtoYUV() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoYUV() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1/255,

           G = (Tfloat)*p2/255,

           B = (Tfloat)*p3/255,

           Y = 0.299f*R + 0.587f*G + 0.114f*B;

         *(p1++) = (T)Y;

         *(p2++) = (T)(0.492f*(B-Y));

         *(p3++) = (T)(0.877*(R-Y));

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoYUV() const {

       return CImg<Tfloat>(*this,false).RGBtoYUV();

     }


     CImg<T>& YUVtoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::YUVtoRGB() : Input image dimension is dim=%u, "

                                     "should be a (Y,U,V) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           Y = (Tfloat)*p1,

           U = (Tfloat)*p2,

           V = (Tfloat)*p3,

           R = (Y + 1.140f*V)*255,

           G = (Y - 0.395f*U - 0.581f*V)*255,

           B = (Y + 2.032f*U)*255;

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tuchar> get_YUVtoRGB() const {

       return CImg< Tuchar>(*this,false).YUVtoRGB();

     }


     CImg<T>& RGBtoCMY() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoCMY() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1/255,

           G = (Tfloat)*p2/255,

           B = (Tfloat)*p3/255;

         *(p1++) = (T)(1 - R);

         *(p2++) = (T)(1 - G);

         *(p3++) = (T)(1 - B);

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoCMY() const {

       return CImg<Tfloat>(*this,false).RGBtoCMY();

     }


     CImg<T>& CMYtoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::CMYtoRGB() : Input image dimension is dim=%u, "

                                     "should be a (C,M,Y) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           C = (Tfloat)*p1,

           M = (Tfloat)*p2,

           Y = (Tfloat)*p3,

           R = 255*(1 - C),

           G = 255*(1 - M),

           B = 255*(1 - Y);

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tuchar> get_CMYtoRGB() const {

       return CImg<Tuchar>(*this,false).CMYtoRGB();

     }


     CImg<T>& CMYtoCMYK() {

       return get_CMYtoCMYK().transfer_to(*this);

     }


     CImg<Tfloat> get_CMYtoCMYK() const {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::CMYtoCMYK() : Input image dimension is dim=%u, "

                                     "should be a (C,M,Y) image (dim=3)",

                                     pixel_type(),dim);

       CImg<Tfloat> res(width,height,depth,4);

       const T *ps1 = ptr(0,0,0,0), *ps2 = ptr(0,0,0,1), *ps3 = ptr(0,0,0,2);

       Tfloat *pd1 = res.ptr(0,0,0,0), *pd2 = res.ptr(0,0,0,1), *pd3 = res.ptr(0,0,0,2), *pd4 = res.ptr(0,0,0,3);

       for (unsigned int N = width*height*depth; N; --N) {

         Tfloat

           C = (Tfloat)*(ps1++),

           M = (Tfloat)*(ps2++),

           Y = (Tfloat)*(ps3++),

           K = cimg::min(C,M,Y);

         if (K==1) C = M = Y = 0;

         else { const Tfloat K1 = 1 - K; C = (C - K)/K1; M = (M - K)/K1; Y = (Y - K)/K1; }

         *(pd1++) = C;

         *(pd2++) = M;

         *(pd3++) = Y;

         *(pd4++) = K;

       }

       return res;

     }


     CImg<T>& CMYKtoCMY() {

       return get_CMYKtoCMY().transfer_to(*this);

     }


     CImg<Tfloat> get_CMYKtoCMY() const {

       if (is_empty()) return *this;

       if (dim!=4)

         throw CImgInstanceException("CImg<%s>::CMYKtoCMY() : Input image dimension is dim=%u, "

                                     "should be a (C,M,Y,K) image (dim=4)",

                                     pixel_type(),dim);

       CImg<Tfloat> res(width,height,depth,3);

       const T *ps1 = ptr(0,0,0,0), *ps2 = ptr(0,0,0,1), *ps3 = ptr(0,0,0,2), *ps4 = ptr(0,0,0,3);

       Tfloat *pd1 = res.ptr(0,0,0,0), *pd2 = res.ptr(0,0,0,1), *pd3 = res.ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           C = (Tfloat)*ps1,

           M = (Tfloat)*ps2,

           Y = (Tfloat)*ps3,

           K = (Tfloat)*ps4,

           K1 = 1 - K;

         *(pd1++) = C*K1 + K;

         *(pd2++) = M*K1 + K;

         *(pd3++) = Y*K1 + K;

       }

       return res;

     }


     CImg<T>& RGBtoXYZ() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoXYZ() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           R = (Tfloat)*p1/255,

           G = (Tfloat)*p2/255,

           B = (Tfloat)*p3/255;

         *(p1++) = (T)(0.412453f*R + 0.357580f*G + 0.180423f*B);

         *(p2++) = (T)(0.212671f*R + 0.715160f*G + 0.072169f*B);

         *(p3++) = (T)(0.019334f*R + 0.119193f*G + 0.950227f*B);

       }

       return *this;

     }


     CImg<Tfloat> get_RGBtoXYZ() const {

       return CImg<Tfloat>(*this,false).RGBtoXYZ();

     }


     CImg<T>& XYZtoRGB() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::XYZtoRGB() : Input image dimension is dim=%u, "

                                     "should be a (X,Y,Z) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           X = (Tfloat)*p1*255,

           Y = (Tfloat)*p2*255,

           Z = (Tfloat)*p3*255,

           R = 3.240479f*X  - 1.537150f*Y - 0.498535f*Z,

           G = -0.969256f*X + 1.875992f*Y + 0.041556f*Z,

           B = 0.055648f*X  - 0.204043f*Y + 1.057311f*Z;

         *(p1++) = (T)(R<0?0:(R>255?255:R));

         *(p2++) = (T)(G<0?0:(G>255?255:G));

         *(p3++) = (T)(B<0?0:(B>255?255:B));

       }

       return *this;

     }


     CImg<Tuchar> get_XYZtoRGB() const {

       return CImg<Tuchar>(*this,false).XYZtoRGB();

     }


     CImg<T>& XYZtoLab() {

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

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::XYZtoLab() : Input image dimension is dim=%u, "

                                     "should be a (X,Y,Z) image (dim=3)",

                                     pixel_type(),dim);

       const Tfloat

         Xn = (Tfloat)(0.412453f + 0.357580f + 0.180423f),

         Yn = (Tfloat)(0.212671f + 0.715160f + 0.072169f),

         Zn = (Tfloat)(0.019334f + 0.119193f + 0.950227f);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           X = (Tfloat)*p1,

           Y = (Tfloat)*p2,

           Z = (Tfloat)*p3,

           XXn = X/Xn, YYn = Y/Yn, ZZn = Z/Zn,

           fX = (Tfloat)_cimg_Labf(XXn),

           fY = (Tfloat)_cimg_Labf(YYn),

           fZ = (Tfloat)_cimg_Labf(ZZn);

         *(p1++) = (T)(116*fY - 16);

         *(p2++) = (T)(500*(fX - fY));

         *(p3++) = (T)(200*(fY - fZ));

       }

       return *this;

     }


     CImg<Tfloat> get_XYZtoLab() const {

       return CImg<Tfloat>(*this,false).XYZtoLab();

     }


     CImg<T>& LabtoXYZ() {

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

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::LabtoXYZ() : Input image dimension is dim=%u, "

                                     "should be a (X,Y,Z) image (dim=3)",

                                     pixel_type(),dim);

       const Tfloat

         Xn = (Tfloat)(0.412453f + 0.357580f + 0.180423f),

         Yn = (Tfloat)(0.212671f + 0.715160f + 0.072169f),

         Zn = (Tfloat)(0.019334f + 0.119193f + 0.950227f);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           L = (Tfloat)*p1,

           a = (Tfloat)*p2,

           b = (Tfloat)*p3,

           cY = (L + 16)/116,

           Y = (Tfloat)(Yn*_cimg_Labfi(cY)),

           pY = (Tfloat)std::pow(Y/Yn,(Tfloat)1/3),

           cX = a/500 + pY,

           X = Xn*cX*cX*cX,

           cZ = pY - b/200,

           Z = Zn*cZ*cZ*cZ;

         *(p1++) = (T)(X);

         *(p2++) = (T)(Y);

         *(p3++) = (T)(Z);

       }

       return *this;

     }


     CImg<Tfloat> get_LabtoXYZ() const {

       return CImg<Tfloat>(*this,false).LabtoXYZ();

     }


     CImg<T>& XYZtoxyY() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::XYZtoxyY() : Input image dimension is dim=%u, "

                                     "should be a (X,Y,Z) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

           X = (Tfloat)*p1,

           Y = (Tfloat)*p2,

           Z = (Tfloat)*p3,

           sum = (X+Y+Z),

           nsum = sum>0?sum:1;

         *(p1++) = (T)(X/nsum);

         *(p2++) = (T)(Y/nsum);

         *(p3++) = (T)Y;

       }

       return *this;

     }


     CImg<Tfloat> get_XYZtoxyY() const {

       return CImg<Tfloat>(*this,false).XYZtoxyY();

     }


     CImg<T>& xyYtoXYZ() {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::xyYtoXYZ() : Input image dimension is dim=%u, "

                                     "should be a (x,y,Y) image (dim=3)",

                                     pixel_type(),dim);

       T *p1 = ptr(0,0,0,0), *p2 = ptr(0,0,0,1), *p3 = ptr(0,0,0,2);

       for (unsigned int N = width*height*depth; N; --N) {

         const Tfloat

          px = (Tfloat)*p1,

          py = (Tfloat)*p2,

          Y = (Tfloat)*p3,

          ny = py>0?py:1;

         *(p1++) = (T)(px*Y/ny);

         *(p2++) = (T)Y;

         *(p3++) = (T)((1-px-py)*Y/ny);

       }

       return *this;

     }


     CImg<Tfloat> get_xyYtoXYZ() const {

       return CImg<Tfloat>(*this,false).xyYtoXYZ();

     }


     CImg<T>& RGBtoLab() {

       return RGBtoXYZ().XYZtoLab();

     }


     CImg<Tfloat> get_RGBtoLab() const {

       return CImg<Tfloat>(*this,false).RGBtoLab();

     }


     CImg<T>& LabtoRGB() {

       return LabtoXYZ().XYZtoRGB();

     }


     CImg<Tuchar> get_LabtoRGB() const {

       return CImg<Tuchar>(*this,false).LabtoRGB();

     }


     CImg<T>& RGBtoxyY() {

       return RGBtoXYZ().XYZtoxyY();

     }


     CImg<Tfloat> get_RGBtoxyY() const {

       return CImg<Tfloat>(*this,false).RGBtoxyY();

     }


     CImg<T>& xyYtoRGB() {

       return xyYtoXYZ().XYZtoRGB();

     }


     CImg<Tuchar> get_xyYtoRGB() const {

       return CImg<Tuchar>(*this,false).xyYtoRGB();

     }


     CImg<T>& RGBtoCMYK() {

       return RGBtoCMY().CMYtoCMYK();

     }


     CImg<Tfloat> get_RGBtoCMYK() const {

       return CImg<Tfloat>(*this,false).RGBtoCMYK();

     }


     CImg<T>& CMYKtoRGB() {

       return CMYKtoCMY().CMYtoRGB();

     }


     CImg<Tuchar> get_CMYKtoRGB() const {

       return CImg<Tuchar>(*this,false).CMYKtoRGB();

     }


     CImg<T>& RGBtoBayer() {

       return get_RGBtoBayer().transfer_to(*this);

     }


     CImg<T> get_RGBtoBayer() const {

       if (is_empty()) return *this;

       if (dim!=3)

         throw CImgInstanceException("CImg<%s>::RGBtoBayer() : Input image dimension is dim=%u, "

                                     "should be a (R,G,B) image (dim=3)",

                                     pixel_type(),dim);

       CImg<T> res(width,height,depth,1);

       const T *pR = ptr(0,0,0,0), *pG = ptr(0,0,0,1), *pB = ptr(0,0,0,2);

       T *ptrd = res.data;

       cimg_forXYZ(*this,x,y,z) {

         if (y%2) {

           if (x%2) *(ptrd++) = *pB;

           else *(ptrd++) = *pG;

         } else {

           if (x%2) *(ptrd++) = *pG;

           else *(ptrd++) = *pR;

         }

         ++pR; ++pG; ++pB;

       }

       return res;

     }


     CImg<T>& BayertoRGB(const unsigned int interpolation_type=3) {

       return get_BayertoRGB(interpolation_type).transfer_to(*this);

     }


     CImg<Tuchar> get_BayertoRGB(const unsigned int interpolation_type=3) const {

       if (is_empty()) return *this;

       if (dim!=1)

         throw CImgInstanceException("CImg<%s>::BayertoRGB() : Input image dimension is dim=%u, "

                                     "should be a Bayer image (dim=1)",

                                     pixel_type(),dim);

       CImg<Tuchar> res(width,height,depth,3);

       CImg_3x3(I,T);

       Tuchar *pR = res.ptr(0,0,0,0), *pG = res.ptr(0,0,0,1), *pB = res.ptr(0,0,0,2);

       switch (interpolation_type) {

       case 3 : { // Edge-directed

         CImg_3x3(R,T);

         CImg_3x3(G,T);

         CImg_3x3(B,T);

         cimg_forXYZ(*this,x,y,z) {

           const int _p1x = x?x-1:1, _p1y = y?y-1:1, _n1x = x<dimx()-1?x+1:x-1, _n1y = y<dimy()-1?y+1:y-1;

           cimg_get3x3(*this,x,y,z,0,I);

           if (y%2) {

             if (x%2) {

               const Tfloat alpha = cimg::sqr((Tfloat)Inc - Ipc), beta = cimg::sqr((Tfloat)Icn - Icp), cx = 1/(1+alpha), cy = 1/(1+beta);

               *pG = (Tuchar)((cx*(Inc+Ipc) + cy*(Icn+Icp))/(2*(cx+cy)));

             } else *pG = (Tuchar)Icc;

           } else {

             if (x%2) *pG = (Tuchar)Icc;

             else {

               const Tfloat alpha = cimg::sqr((Tfloat)Inc - Ipc), beta = cimg::sqr((Tfloat)Icn - Icp), cx = 1/(1+alpha), cy = 1/(1+beta);

               *pG = (Tuchar)((cx*(Inc+Ipc) + cy*(Icn+Icp))/(2*(cx+cy)));

             }

           }

           ++pG;

         }

         cimg_forXYZ(*this,x,y,z) {

           const int _p1x = x?x-1:1, _p1y = y?y-1:1, _n1x = x<dimx()-1?x+1:x-1, _n1y = y<dimy()-1?y+1:y-1;

           cimg_get3x3(*this,x,y,z,0,I);

           cimg_get3x3(res,x,y,z,1,G);

           if (y%2) {

             if (x%2) *pB = (Tuchar)Icc;

             else { *pR = (Tuchar)((Icn+Icp)/2); *pB = (Tuchar)((Inc+Ipc)/2); }

           } else {

             if (x%2) { *pR = (Tuchar)((Inc+Ipc)/2); *pB = (Tuchar)((Icn+Icp)/2); }

             else *pR = (Tuchar)Icc;

           }

           ++pR; ++pB;

         }

         pR = res.ptr(0,0,0,0);

         pG = res.ptr(0,0,0,1);

         pB = res.ptr(0,0,0,2);

         cimg_forXYZ(*this,x,y,z) {

           const int _p1x = x?x-1:1, _p1y = y?y-1:1, _n1x = x<dimx()-1?x+1:x-1, _n1y = y<dimy()-1?y+1:y-1;

           cimg_get3x3(res,x,y,z,0,R);

           cimg_get3x3(res,x,y,z,1,G);

           cimg_get3x3(res,x,y,z,2,B);

           if (y%2) {

             if (x%2) {

               const float alpha = (float)cimg::sqr(Rnc-Rpc), beta = (float)cimg::sqr(Rcn-Rcp), cx = 1/(1+alpha), cy = 1/(1+beta);

               *pR = (Tuchar)((cx*(Rnc+Rpc) + cy*(Rcn+Rcp))/(2*(cx+cy)));

             }

           } else {

             if (!(x%2)) {

               const float alpha = (float)cimg::sqr(Bnc-Bpc), beta = (float)cimg::sqr(Bcn-Bcp), cx = 1/(1+alpha), cy = 1/(1+beta);

               *pB = (Tuchar)((cx*(Bnc+Bpc) + cy*(Bcn+Bcp))/(2*(cx+cy)));

             }

           }

           ++pR; ++pG; ++pB;

         }

       } break;

       case 2 : { // Linear interpolation

         cimg_forXYZ(*this,x,y,z) {

           const int _p1x = x?x-1:1, _p1y = y?y-1:1, _n1x = x<dimx()-1?x+1:x-1, _n1y = y<dimy()-1?y+1:y-1;

           cimg_get3x3(*this,x,y,z,0,I);

           if (y%2) {

             if (x%2) { *pR = (Tuchar)((Ipp+Inn+Ipn+Inp)/4); *pG = (Tuchar)((Inc+Ipc+Icn+Icp)/4); *pB = (Tuchar)Icc; }

             else { *pR = (Tuchar)((Icp+Icn)/2); *pG = (Tuchar)Icc; *pB = (Tuchar)((Inc+Ipc)/2); }

           } else {

             if (x%2) { *pR = (Tuchar)((Ipc+Inc)/2); *pG = (Tuchar)Icc; *pB = (Tuchar)((Icn+Icp)/2); }

             else { *pR = (Tuchar)Icc; *pG = (Tuchar)((Inc+Ipc+Icn+Icp)/4); *pB = (Tuchar)((Ipp+Inn+Ipn+Inp)/4); }

           }

           ++pR; ++pG; ++pB;

         }

       } break;

       case 1 : { // Nearest neighbor interpolation

         cimg_forXYZ(*this,x,y,z) {

           const int _p1x = x?x-1:1, _p1y = y?y-1:1, _n1x = x<dimx()-1?x+1:x-1, _n1y = y<dimy()-1?y+1:y-1;

           cimg_get3x3(*this,x,y,z,0,I);

           if (y%2) {

             if (x%2) { *pR = (Tuchar)cimg::min(Ipp,Inn,Ipn,Inp); *pG = (Tuchar)cimg::min(Inc,Ipc,Icn,Icp); *pB = (Tuchar)Icc; }

             else { *pR = (Tuchar)cimg::min(Icn,Icp); *pG = (Tuchar)Icc; *pB = (Tuchar)cimg::min(Inc,Ipc); }

           } else {

             if (x%2) { *pR = (Tuchar)cimg::min(Inc,Ipc); *pG = (Tuchar)Icc; *pB = (Tuchar)cimg::min(Icn,Icp); }

             else { *pR = (Tuchar)Icc; *pG = (Tuchar)cimg::min(Inc,Ipc,Icn,Icp); *pB = (Tuchar)cimg::min(Ipp,Inn,Ipn,Inp); }

           }

           ++pR; ++pG; ++pB;

         }

       } break;

       default : { // 0-filling interpolation

         const T *ptrs = data;

         res.fill(0);

         cimg_forXYZ(*this,x,y,z) {

           const T val = *(ptrs++);

           if (y%2) { if (x%2) *pB = val; else *pG = val; } else { if (x%2) *pG = val; else *pR = val; }

           ++pR; ++pG; ++pB;

         }

       }

       }

       return res;

     }


     //------------------------------------------

     //


     //------------------------------------------


     CImg<T>& resize(const int pdx, const int pdy=-100, const int pdz=-100, const int pdv=-100,

                     const int interpolation_type=1, const int border_condition=-1, const bool center=false) {

       if (!pdx || !pdy || !pdz || !pdv) return assign();

       const unsigned int

         tdx = pdx<0?-pdx*width/100:pdx,

         tdy = pdy<0?-pdy*height/100:pdy,

         tdz = pdz<0?-pdz*depth/100:pdz,

         tdv = pdv<0?-pdv*dim/100:pdv,

         dx = tdx?tdx:1,

         dy = tdy?tdy:1,

         dz = tdz?tdz:1,

         dv = tdv?tdv:1;

       if (width==dx && height==dy && depth==dz && dim==dv) return *this;

       if (interpolation_type==-1 && dx*dy*dz*dv==size()) {

         width = dx; height = dy; depth = dz; dim = dv;

         return *this;

       }

       return get_resize(dx,dy,dz,dv,interpolation_type,border_condition,center).transfer_to(*this);

     }


     CImg<T> get_resize(const int pdx, const int pdy=-100, const int pdz=-100, const int pdv=-100,

                        const int interpolation_type=1, const int border_condition=-1, const bool center=false) const {

       if (!pdx || !pdy || !pdz || !pdv) return CImg<T>();

       const unsigned int

         tdx = pdx<0?-pdx*width/100:pdx,

         tdy = pdy<0?-pdy*height/100:pdy,

         tdz = pdz<0?-pdz*depth/100:pdz,

         tdv = pdv<0?-pdv*dim/100:pdv,

         dx = tdx?tdx:1,

         dy = tdy?tdy:1,

         dz = tdz?tdz:1,

         dv = tdv?tdv:1;

       if (width==dx && height==dy && depth==dz && dim==dv) return +*this;

       if (is_empty()) return CImg<T>(dx,dy,dz,dv,0);


       CImg<T> res;

       switch (interpolation_type) {

       case -1 : // Raw resizing

         std::memcpy(res.assign(dx,dy,dz,dv,0).data,data,sizeof(T)*cimg::min(size(),(unsigned int)dx*dy*dz*dv));

         break;


       case 0 :  { // No interpolation

         const unsigned int bx = width-1, by = height-1, bz = depth-1, bv = dim-1;

         res.assign(dx,dy,dz,dv);

         switch (border_condition) {

         case 1 : {

           if (center) {

             const int

               x0 = (res.dimx() - dimx())/2,

               y0 = (res.dimy() - dimy())/2,

               z0 = (res.dimz() - dimz())/2,

               v0 = (res.dimv() - dimv())/2,

               x1 = x0 + (int)bx,

               y1 = y0 + (int)by,

               z1 = z0 + (int)bz,

               v1 = v0 + (int)bv;

             res.draw_image(x0,y0,z0,v0,*this);

             cimg_for_outXYZV(res,x0,y0,z0,v0,x1,y1,z1,v1,x,y,z,v) res(x,y,z,v) = _atXYZV(x - x0,y - y0,z - z0,v - v0);

           } else {

             res.draw_image(*this);

             cimg_for_outXYZV(res,0,0,0,0,bx,by,bz,bv,x,y,z,v) res(x,y,z,v) = _atXYZV(x,y,z,v);

           }

           } break;

         case 2 : {

           int nx0 = 0, ny0 = 0, nz0 = 0, nv0 = 0;

           if (center) {

             const int

               x0 = (res.dimx() - dimx())/2,

               y0 = (res.dimy() - dimy())/2,

               z0 = (res.dimz() - dimz())/2,

               v0 = (res.dimv() - dimv())/2;

             nx0 = x0>0?x0-(1+x0/width)*width:x0;

             ny0 = y0>0?y0-(1+y0/height)*height:y0;

             nz0 = z0>0?z0-(1+z0/depth)*depth:z0;

             nv0 = v0>0?v0-(1+v0/dim)*dim:v0;

           }

           for (int k = nv0; k<(int)dv; k+=dimv())

             for (int z = nz0; z<(int)dz; z+=dimz())

               for (int y = ny0; y<(int)dy; y+=dimy())

                 for (int x = nx0; x<(int)dx; x+=dimx()) res.draw_image(x,y,z,k,*this);

           } break;

         default : {

           res.fill(0);

           if (center) res.draw_image((res.dimx()-dimx())/2,(res.dimy()-dimy())/2,(res.dimz()-dimz())/2,(res.dimv()-dimv())/2,*this);

           else res.draw_image(*this);

         }

         }

       } break;


       case 1 : { // Nearest-neighbor interpolation

         res.assign(dx,dy,dz,dv);

         unsigned int

           *const offx = new unsigned int[dx],

           *const offy = new unsigned int[dy+1],

           *const offz = new unsigned int[dz+1],

           *const offv = new unsigned int[dv+1],

           *poffx, *poffy, *poffz, *poffv,

           curr, old;

         const unsigned int wh = width*height, whd = width*height*depth, rwh = dx*dy, rwhd = dx*dy*dz;

         poffx = offx; curr = 0; cimg_forX(res,x) { old = curr; curr = (x+1)*width/dx; *(poffx++) = (unsigned int)curr - (unsigned int)old; }

         poffy = offy; curr = 0; cimg_forY(res,y) { old = curr; curr = (y+1)*height/dy; *(poffy++) = width*((unsigned int)curr - (unsigned int)old); } *poffy = 0;

         poffz = offz; curr = 0; cimg_forZ(res,z) { old = curr; curr = (z+1)*depth/dz; *(poffz++) = wh*((unsigned int)curr - (unsigned int)old); } *poffz = 0;

         poffv = offv; curr = 0; cimg_forV(res,k) { old = curr; curr = (k+1)*dim/dv; *(poffv++) = whd*((unsigned int)curr - (unsigned int)old); } *poffv = 0;

         T *ptrd = res.data;

         const T* ptrv = data;

         poffv = offv;

         for (unsigned int k = 0; k<dv; ) {

           const T *ptrz = ptrv;

           poffz = offz;

           for (unsigned int z = 0; z<dz; ) {

             const T *ptry = ptrz;

             poffy = offy;

             for (unsigned int y = 0; y<dy; ) {

               const T *ptrx = ptry;

               poffx = offx;

               cimg_forX(res,x) { *(ptrd++) = *ptrx; ptrx+=*(poffx++); }

               ++y;

               unsigned int dy = *(poffy++);

               for (;!dy && y<dy; std::memcpy(ptrd,ptrd - dx,sizeof(T)*dx), ++y, ptrd+=dx, dy=*(poffy++)) {}

               ptry+=dy;

             }

             ++z;

             unsigned int dz = *(poffz++);

             for (;!dz && z<dz; std::memcpy(ptrd,ptrd-rwh,sizeof(T)*rwh), ++z, ptrd+=rwh, dz=*(poffz++)) {}

             ptrz+=dz;

           }

           ++k;

           unsigned int dv = *(poffv++);

           for (;!dv && k<dv; std::memcpy(ptrd,ptrd-rwhd,sizeof(T)*rwhd), ++k, ptrd+=rwhd, dv=*(poffv++)) {}

           ptrv+=dv;

         }

         delete[] offx; delete[] offy; delete[] offz; delete[] offv;

       } break;


       case 2 : { // Moving average

         bool instance_first = true;

         if (dx!=width) {

           CImg<Tfloat> tmp(dx,height,depth,dim,0);

           for (unsigned int a = width*dx, b = width, c = dx, s = 0, t = 0; a; ) {

             const unsigned int d = cimg::min(b,c);

             a-=d; b-=d; c-=d;

             cimg_forYZV(tmp,y,z,v) tmp(t,y,z,v)+=(Tfloat)(*this)(s,y,z,v)*d;

             if (!b) { cimg_forYZV(tmp,y,z,v) tmp(t,y,z,v)/=width; ++t; b = width; }

             if (!c) { ++s; c = dx; }

           }

           tmp.transfer_to(res);

           instance_first = false;

         }

         if (dy!=height) {

           CImg<Tfloat> tmp(dx,dy,depth,dim,0);

           for (unsigned int a = height*dy, b = height, c = dy, s = 0, t = 0; a; ) {

             const unsigned int d = cimg::min(b,c);

             a-=d; b-=d; c-=d;

             if (instance_first) cimg_forXZV(tmp,x,z,v) tmp(x,t,z,v)+=(Tfloat)(*this)(x,s,z,v)*d;

             else cimg_forXZV(tmp,x,z,v) tmp(x,t,z,v)+=(Tfloat)res(x,s,z,v)*d;

             if (!b) { cimg_forXZV(tmp,x,z,v) tmp(x,t,z,v)/=height; ++t; b = height; }

             if (!c) { ++s; c = dy; }

           }

           tmp.transfer_to(res);

           instance_first = false;

         }

         if (dz!=depth) {

           CImg<Tfloat> tmp(dx,dy,dz,dim,0);

           for (unsigned int a = depth*dz, b = depth, c = dz, s = 0, t = 0; a; ) {

             const unsigned int d = cimg::min(b,c);

             a-=d; b-=d; c-=d;

             if (instance_first) cimg_forXYV(tmp,x,y,v) tmp(x,y,t,v)+=(Tfloat)(*this)(x,y,s,v)*d;

             else cimg_forXYV(tmp,x,y,v) tmp(x,y,t,v)+=(Tfloat)res(x,y,s,v)*d;

             if (!b) { cimg_forXYV(tmp,x,y,v) tmp(x,y,t,v)/=depth; ++t; b = depth; }

             if (!c) { ++s; c = dz; }

           }

           tmp.transfer_to(res);

           instance_first = false;

         }

         if (dv!=dim) {

           CImg<Tfloat> tmp(dx,dy,dz,dv,0);

           for (unsigned int a = dim*dv, b = dim, c = dv, s = 0, t = 0; a; ) {

             const unsigned int d = cimg::min(b,c);

             a-=d; b-=d; c-=d;

             if (instance_first) cimg_forXYZ(tmp,x,y,z) tmp(x,y,z,t)+=(Tfloat)(*this)(x,y,z,s)*d;

             else cimg_forXYZ(tmp,x,y,z) tmp(x,y,z,t)+=(Tfloat)res(x,y,z,s)*d;

             if (!b) { cimg_forXYZ(tmp,x,y,z) tmp(x,y,z,t)/=dim; ++t; b = dim; }

             if (!c) { ++s; c = dv; }

           }

           tmp.transfer_to(res);

           instance_first = false;

         }

       } break;


       case 3 : { // Linear interpolation

         const unsigned int dimmax = cimg::max(dx,dy,dz,dv);

         const float

           sx = (border_condition<0 && dx>width )?(dx>1?(width-1.0f)/(dx-1) :0):(float)width/dx,

           sy = (border_condition<0 && dy>height)?(dy>1?(height-1.0f)/(dy-1):0):(float)height/dy,

           sz = (border_condition<0 && dz>depth )?(dz>1?(depth-1.0f)/(dz-1) :0):(float)depth/dz,

           sv = (border_condition<0 && dv>dim   )?(dv>1?(dim-1.0f)/(dv-1)   :0):(float)dim/dv;


         unsigned int *const off = new unsigned int[dimmax], *poff;

         float *const foff = new float[dimmax], *pfoff, old, curr;

         CImg<T> resx, resy, resz, resv;

         T *ptrd;


         if (dx!=width) {

           if (width==1) resx = get_resize(dx,height,depth,dim,1,0);

           else {

             resx.assign(dx,height,depth,dim);

             curr = old = 0; poff = off; pfoff = foff;

             cimg_forX(resx,x) { *(pfoff++) = curr-(unsigned int)curr; old = curr; curr+=sx; *(poff++) = (unsigned int)curr-(unsigned int)old; }

             ptrd = resx.data;

             const T *ptrs0 = data;

             cimg_forYZV(resx,y,z,k) {

               poff = off; pfoff = foff;

               const T *ptrs = ptrs0, *const ptrsmax = ptrs0 + (width-1);

               cimg_forX(resx,x) {

                 const float alpha = *(pfoff++);

                 const T val1 = *ptrs, val2 = ptrs<ptrsmax?*(ptrs+1):(border_condition?val1:(T)0);

                 *(ptrd++) = (T)((1-alpha)*val1 + alpha*val2);

                 ptrs+=*(poff++);

               }

               ptrs0+=width;

             }

           }

         } else resx.assign(*this,true);


         if (dy!=height) {

           if (height==1) resy = resx.get_resize(dx,dy,depth,dim,1,0);

           else {

             resy.assign(dx,dy,depth,dim);

             curr = old = 0; poff = off; pfoff = foff;

             cimg_forY(resy,y) { *(pfoff++) = curr-(unsigned int)curr; old = curr; curr+=sy; *(poff++) = dx*((unsigned int)curr-(unsigned int)old); }

             cimg_forXZV(resy,x,z,k) {

               ptrd = resy.ptr(x,0,z,k);

               const T *ptrs = resx.ptr(x,0,z,k), *const ptrsmax = ptrs + (height-1)*dx;

               poff = off; pfoff = foff;

               cimg_forY(resy,y) {

                 const float alpha = *(pfoff++);

                 const T val1 = *ptrs, val2 = ptrs<ptrsmax?*(ptrs+dx):(border_condition?val1:(T)0);

                 *ptrd = (T)((1-alpha)*val1 + alpha*val2);

                 ptrd+=dx;

                 ptrs+=*(poff++);

               }

             }

           }

           resx.assign();

         } else resy.assign(resx,true);


         if (dz!=depth) {

           if (depth==1) resz = resy.get_resize(dx,dy,dz,dim,1,0);

           else {

             const unsigned int wh = dx*dy;

             resz.assign(dx,dy,dz,dim);

             curr = old = 0; poff = off; pfoff = foff;

             cimg_forZ(resz,z) { *(pfoff++) = curr-(unsigned int)curr; old = curr; curr+=sz; *(poff++) = wh*((unsigned int)curr-(unsigned int)old); }

             cimg_forXYV(resz,x,y,k) {

               ptrd = resz.ptr(x,y,0,k);

               const T *ptrs = resy.ptr(x,y,0,k), *const ptrsmax = ptrs + (depth-1)*wh;

               poff = off; pfoff = foff;

               cimg_forZ(resz,z) {

                 const float alpha = *(pfoff++);

                 const T val1 = *ptrs, val2 = ptrs<ptrsmax?*(ptrs+wh):(border_condition?val1:(T)0);

                 *ptrd = (T)((1-alpha)*val1 + alpha*val2);

                 ptrd+=wh;

                 ptrs+=*(poff++);

               }

             }

           }

           resy.assign();

         } else resz.assign(resy,true);


         if (dv!=dim) {

           if (dim==1) resv = resz.get_resize(dx,dy,dz,dv,1,0);

           else {

             const unsigned int whd = dx*dy*dz;

             resv.assign(dx,dy,dz,dv);

             curr = old = 0; poff = off; pfoff = foff;

             cimg_forV(resv,k) { *(pfoff++) = curr-(unsigned int)curr; old = curr; curr+=sv; *(poff++) = whd*((unsigned int)curr-(unsigned int)old); }

             cimg_forXYZ(resv,x,y,z) {

               ptrd = resv.ptr(x,y,z,0);

               const T *ptrs = resz.ptr(x,y,z,0), *const ptrsmax = ptrs + (dim-1)*whd;

               poff = off; pfoff = foff;

               cimg_forV(resv,k) {

                 const float alpha = *(pfoff++);

                 const T val1 = *ptrs, val2 = ptrs<ptrsmax?*(ptrs+whd):(border_condition?val1:(T)0);

                 *ptrd = (T)((1-alpha)*val1 + alpha*val2);

                 ptrd+=whd;

                 ptrs+=*(poff++);

               }

             }

           }

           resz.assign();

         } else resv.assign(resz,true);


         delete[] off; delete[] foff;

         return resv.is_shared?(resz.is_shared?(resy.is_shared?(resx.is_shared?(+(*this)):resx):resy):resz):resv;

       } break;


       case 4 : { // Grid filling

         res.assign(dx,dy,dz,dv,0);

         cimg_forXYZV(*this,x,y,z,k) res(x*dx/width,y*dy/height,z*dz/depth,k*dv/dim) = (*this)(x,y,z,k);

       } break;


       case 5 : { // Cubic interpolation

         const float

           sx = (border_condition<0 && dx>width )?(dx>1?(width-1.0f)/(dx-1) :0):(float)width/dx,

           sy = (border_condition<0 && dy>height)?(dy>1?(height-1.0f)/(dy-1):0):(float)height/dy,

           sz = (border_condition<0 && dz>depth )?(dz>1?(depth-1.0f)/(dz-1) :0):(float)depth/dz,

           sv = (border_condition<0 && dv>dim   )?(dv>1?(dim-1.0f)/(dv-1)   :0):(float)dim/dv;

         res.assign(dx,dy,dz,dv);

         T *ptrd = res.ptr();

         float cx, cy, cz, ck = 0;

         cimg_forV(res,k) { cz = 0;

         cimg_forZ(res,z) { cy = 0;

         cimg_forY(res,y) { cx = 0;

         cimg_forX(res,x) {

           *(ptrd++) = (T)(border_condition?_cubic_atXY(cx,cy,(int)cz,(int)ck):cubic_atXY(cx,cy,(int)cz,(int)ck,0));

           cx+=sx;

         } cy+=sy;

         } cz+=sz;

         } ck+=sv;

         }

       } break;


       default : // Invalid interpolation method

         throw CImgArgumentException("CImg<%s>::resize() : Invalid interpolation_type %d "

                                     "(should be { -1=raw, 0=zero, 1=nearest, 2=average, 3=linear, 4=grid, 5=bicubic}).",

                                     pixel_type(),interpolation_type);

       }

       return res;

     }


     template<typename t>

     CImg<T>& resize(const CImg<t>& src, const int interpolation_type=1,

                     const int border_condition=-1, const bool center=false) {

       return resize(src.width,src.height,src.depth,src.dim,interpolation_type,border_condition,center);

     }


     template<typename t>

     CImg<T> get_resize(const CImg<t>& src, const int interpolation_type=1,

                        const int border_condition=-1, const bool center=false) const {

       return get_resize(src.width,src.height,src.depth,src.dim,interpolation_type,border_condition,center);

     }


     CImg<T>& resize(const CImgDisplay& disp, const int interpolation_type=1,

                     const int border_condition=-1, const bool center=false) {

       return resize(disp.width,disp.height,depth,dim,interpolation_type,border_condition,center);

     }


     CImg<T> get_resize(const CImgDisplay& disp, const int interpolation_type=1,

                        const int border_condition=-1, const bool center=false) const {

       return get_resize(disp.width,disp.height,depth,dim,interpolation_type,border_condition,center);

     }


     CImg<T>& resize_halfXY() {

       return get_resize_halfXY().transfer_to(*this);

     }


     CImg<T> get_resize_halfXY() const {

       if (is_empty()) return *this;

       const Tfloat mask[9] = { 0.07842776544f, 0.1231940459f, 0.07842776544f,

                               0.1231940459f,  0.1935127547f, 0.1231940459f,

                               0.07842776544f, 0.1231940459f, 0.07842776544f };

       T I[9] = { 0 };

       CImg<T> dest(width/2,height/2,depth,dim);

       cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I)

         if (x%2 && y%2) dest(x/2,y/2,z,k) = (T)

                           (I[0]*mask[0] + I[1]*mask[1] + I[2]*mask[2] +

                            I[3]*mask[3] + I[4]*mask[4] + I[5]*mask[5] +

                            I[6]*mask[6] + I[7]*mask[7] + I[8]*mask[8]);

       return dest;

     }


     CImg<T>& resize_doubleXY() {

       return get_resize_doubleXY().transfer_to(*this);

     }


     CImg<T> get_resize_doubleXY() const {

 #define _cimg_gs2x_for3(bound,i) \

  for (int i = 0, _p1##i = 0, \

       _n1##i = 1>=(bound)?(int)(bound)-1:1; \

       _n1##i<(int)(bound) || i==--_n1##i; \

       _p1##i = i++, ++_n1##i, ptrd1+=(res).width, ptrd2+=(res).width)


 #define _cimg_gs2x_for3x3(img,x,y,z,v,I) \

   _cimg_gs2x_for3((img).height,y) for (int x = 0, \

    _p1##x = 0, \

    _n1##x = (int)( \

    (I[1] = (img)(0,_p1##y,z,v)), \

    (I[3] = I[4] = (img)(0,y,z,v)), \

    (I[7] = (img)(0,_n1##y,z,v)),        \

    1>=(img).width?(int)((img).width)-1:1); \

    (_n1##x<(int)((img).width) && ( \

    (I[2] = (img)(_n1##x,_p1##y,z,v)), \

    (I[5] = (img)(_n1##x,y,z,v)), \

    (I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \

    x==--_n1##x; \

    I[1] = I[2], \

    I[3] = I[4], I[4] = I[5], \

    I[7] = I[8], \

    _p1##x = x++, ++_n1##x)


       if (is_empty()) return *this;

       CImg<T> res(2*width,2*height,depth,dim);

       CImg_3x3(I,T);

       cimg_forZV(*this,z,k) {

         T

           *ptrd1 = res.ptr(0,0,0,k),

           *ptrd2 = ptrd1 + res.width;

         _cimg_gs2x_for3x3(*this,x,y,0,k,I) {

           if (Icp!=Icn && Ipc!=Inc) {

             *(ptrd1++) = Ipc==Icp?Ipc:Icc;

             *(ptrd1++) = Icp==Inc?Inc:Icc;

             *(ptrd2++) = Ipc==Icn?Ipc:Icc;

             *(ptrd2++) = Icn==Inc?Inc:Icc;

           } else { *(ptrd1++) = Icc; *(ptrd1++) = Icc; *(ptrd2++) = Icc; *(ptrd2++) = Icc; }

         }

       }

       return res;

     }


     CImg<T>& resize_tripleXY() {

       return get_resize_tripleXY().transfer_to(*this);

     }


     CImg<T> get_resize_tripleXY() const {

 #define _cimg_gs3x_for3(bound,i) \

  for (int i = 0, _p1##i = 0, \

       _n1##i = 1>=(bound)?(int)(bound)-1:1; \

       _n1##i<(int)(bound) || i==--_n1##i; \

       _p1##i = i++, ++_n1##i, ptrd1+=2*(res).width, ptrd2+=2*(res).width, ptrd3+=2*(res).width)


 #define _cimg_gs3x_for3x3(img,x,y,z,v,I) \

   _cimg_gs3x_for3((img).height,y) for (int x = 0, \

    _p1##x = 0, \

    _n1##x = (int)( \

    (I[0] = I[1] = (img)(0,_p1##y,z,v)), \

    (I[3] = I[4] = (img)(0,y,z,v)), \

    (I[6] = I[7] = (img)(0,_n1##y,z,v)), \

    1>=(img).width?(int)((img).width)-1:1); \

    (_n1##x<(int)((img).width) && ( \

    (I[2] = (img)(_n1##x,_p1##y,z,v)), \

    (I[5] = (img)(_n1##x,y,z,v)), \

    (I[8] = (img)(_n1##x,_n1##y,z,v)),1)) || \

    x==--_n1##x; \

    I[0] = I[1], I[1] = I[2], \

    I[3] = I[4], I[4] = I[5], \

    I[6] = I[7], I[7] = I[8], \

    _p1##x = x++, ++_n1##x)


       if (is_empty()) return *this;

       CImg<T> res(3*width,3*height,depth,dim);

       CImg_3x3(I,T);

       cimg_forZV(*this,z,k) {

         T

           *ptrd1 = res.ptr(0,0,0,k),

           *ptrd2 = ptrd1 + res.width,

           *ptrd3 = ptrd2 + res.width;

         _cimg_gs3x_for3x3(*this,x,y,0,k,I) {

           if (Icp != Icn && Ipc != Inc) {

             *(ptrd1++) = Ipc==Icp?Ipc:Icc;

             *(ptrd1++) = (Ipc==Icp && Icc!=Inp) || (Icp==Inc && Icc!=Ipp)?Icp:Icc;

             *(ptrd1++) = Icp==Inc?Inc:Icc;

             *(ptrd2++) = (Ipc==Icp && Icc!=Ipn) || (Ipc==Icn && Icc!=Ipp)?Ipc:Icc;

             *(ptrd2++) = Icc;

             *(ptrd2++) = (Icp==Inc && Icc!=Inn) || (Icn==Inc && Icc!=Inp)?Inc:Icc;

             *(ptrd3++) = Ipc==Icn?Ipc:Icc;

             *(ptrd3++) = (Ipc==Icn && Icc!=Inn) || (Icn==Inc && Icc!=Ipn)?Icn:Icc;

             *(ptrd3++) = Icn==Inc?Inc:Icc;

           } else {

             *(ptrd1++) = Icc; *(ptrd1++) = Icc; *(ptrd1++) = Icc;

             *(ptrd2++) = Icc; *(ptrd2++) = Icc; *(ptrd2++) = Icc;

             *(ptrd3++) = Icc; *(ptrd3++) = Icc; *(ptrd3++) = Icc;

           }

         }

       }

       return res;

     }


     CImg<T>& mirror(const char axis) {

       if (is_empty()) return *this;

       T *pf, *pb, *buf = 0;

       switch (cimg::uncase(axis)) {

       case 'x' : {

         pf = data; pb = ptr(width-1);

         const unsigned int width2 = width/2;

         for (unsigned int yzv = 0; yzv<height*depth*dim; ++yzv) {

           for (unsigned int x = 0; x<width2; ++x) { const T val = *pf; *(pf++) = *pb; *(pb--) = val; }

           pf+=width - width2;

           pb+=width + width2;

         }

       } break;

       case 'y' : {

         buf = new T[width];

         pf = data; pb = ptr(0,height-1);

         const unsigned int height2 = height/2;

         for (unsigned int zv = 0; zv<depth*dim; ++zv) {

           for (unsigned int y = 0; y<height2; ++y) {

             std::memcpy(buf,pf,width*sizeof(T));

             std::memcpy(pf,pb,width*sizeof(T));

             std::memcpy(pb,buf,width*sizeof(T));

             pf+=width;

             pb-=width;

           }

           pf+=width*(height - height2);

           pb+=width*(height + height2);

         }

       } break;

       case 'z' : {

         buf = new T[width*height];

         pf = data; pb = ptr(0,0,depth-1);

         const unsigned int depth2 = depth/2;

         cimg_forV(*this,v) {

           for (unsigned int z = 0; z<depth2; ++z) {

             std::memcpy(buf,pf,width*height*sizeof(T));

             std::memcpy(pf,pb,width*height*sizeof(T));

             std::memcpy(pb,buf,width*height*sizeof(T));

             pf+=width*height;

             pb-=width*height;

           }

           pf+=width*height*(depth - depth2);

           pb+=width*height*(depth + depth2);

         }

       } break;

       case 'v' : {

         buf = new T[width*height*depth];

         pf = data; pb = ptr(0,0,0,dim-1);

         const unsigned int dim2 = dim/2;

         for (unsigned int v = 0; v<dim2; ++v) {

           std::memcpy(buf,pf,width*height*depth*sizeof(T));

           std::memcpy(pf,pb,width*height*depth*sizeof(T));

           std::memcpy(pb,buf,width*height*depth*sizeof(T));

           pf+=width*height*depth;

           pb-=width*height*depth;

         }

       } break;

       default :

         throw CImgArgumentException("CImg<%s>::mirror() : unknow axis '%c', must be 'x','y','z' or 'v'.",

                                     pixel_type(),axis);

       }

       if (buf) delete[] buf;

       return *this;

     }


     CImg<T> get_mirror(const char axis) const {

       return (+*this).mirror(axis);

     }


     CImg<T>& translate(const int deltax, const int deltay=0, const int deltaz=0, const int deltav=0,

                        const int border_condition=0) {

       if (is_empty()) return *this;

       if (deltax) // Translate along X-axis

         switch (border_condition) {

         case 0 :

           if (cimg::abs(deltax)>=dimx()) return fill(0);

           if (deltax<0) cimg_forYZV(*this,y,z,k) {

             std::memmove(ptr(0,y,z,k),ptr(-deltax,y,z,k),(width+deltax)*sizeof(T));

             std::memset(ptr(width+deltax,y,z,k),0,-deltax*sizeof(T));

           } else cimg_forYZV(*this,y,z,k) {

             std::memmove(ptr(deltax,y,z,k),ptr(0,y,z,k),(width-deltax)*sizeof(T));

             std::memset(ptr(0,y,z,k),0,deltax*sizeof(T));

           }

           break;

         case 1 :

           if (deltax<0) {

             const int ndeltax = (-deltax>=dimx())?width-1:-deltax;

             if (!ndeltax) return *this;

             cimg_forYZV(*this,y,z,k) {

               std::memmove(ptr(0,y,z,k),ptr(ndeltax,y,z,k),(width-ndeltax)*sizeof(T));

               T *ptrd = ptr(width-1,y,z,k);

               const T val = *ptrd;

               for (int l = 0; l<ndeltax-1; ++l) *(--ptrd) = val;

             }

           } else {

             const int ndeltax = (deltax>=dimx())?width-1:deltax;

             if (!ndeltax) return *this;

             cimg_forYZV(*this,y,z,k) {

               std::memmove(ptr(ndeltax,y,z,k),ptr(0,y,z,k),(width-ndeltax)*sizeof(T));

               T *ptrd = ptr(0,y,z,k);

               const T val = *ptrd;

               for (int l = 0; l<ndeltax-1; ++l) *(++ptrd) = val;

             }

           }

           break;

         case 2 : {

           const int ml = cimg::mod(-deltax,dimx()), ndeltax = (ml<=dimx()/2)?ml:(ml-dimx());

           if (!ndeltax) return *this;

           T* buf = new T[cimg::abs(ndeltax)];

           if (ndeltax>0) cimg_forYZV(*this,y,z,k) {

             std::memcpy(buf,ptr(0,y,z,k),ndeltax*sizeof(T));

             std::memmove(ptr(0,y,z,k),ptr(ndeltax,y,z,k),(width-ndeltax)*sizeof(T));

             std::memcpy(ptr(width-ndeltax,y,z,k),buf,ndeltax*sizeof(T));

           } else cimg_forYZV(*this,y,z,k) {

             std::memcpy(buf,ptr(width+ndeltax,y,z,k),-ndeltax*sizeof(T));

             std::memmove(ptr(-ndeltax,y,z,k),ptr(0,y,z,k),(width+ndeltax)*sizeof(T));

             std::memcpy(ptr(0,y,z,k),buf,-ndeltax*sizeof(T));

           }

           delete[] buf;

         } break;

         }


       if (deltay) // Translate along Y-axis

         switch (border_condition) {

         case 0 :

           if (cimg::abs(deltay)>=dimy()) return fill(0);

           if (deltay<0) cimg_forZV(*this,z,k) {

             std::memmove(ptr(0,0,z,k),ptr(0,-deltay,z,k),width*(height+deltay)*sizeof(T));

             std::memset(ptr(0,height+deltay,z,k),0,-deltay*width*sizeof(T));

           } else cimg_forZV(*this,z,k) {

             std::memmove(ptr(0,deltay,z,k),ptr(0,0,z,k),width*(height-deltay)*sizeof(T));

             std::memset(ptr(0,0,z,k),0,deltay*width*sizeof(T));

           }

           break;

         case 1 :

           if (deltay<0) {

             const int ndeltay = (-deltay>=dimy())?height-1:-deltay;

             if (!ndeltay) return *this;

             cimg_forZV(*this,z,k) {

               std::memmove(ptr(0,0,z,k),ptr(0,ndeltay,z,k),width*(height-ndeltay)*sizeof(T));

               T *ptrd = ptr(0,height-ndeltay,z,k), *ptrs = ptr(0,height-1,z,k);

               for (int l = 0; l<ndeltay-1; ++l) { std::memcpy(ptrd,ptrs,width*sizeof(T)); ptrd+=width; }

             }

           } else {

             const int ndeltay = (deltay>=dimy())?height-1:deltay;

             if (!ndeltay) return *this;

             cimg_forZV(*this,z,k) {

               std::memmove(ptr(0,ndeltay,z,k),ptr(0,0,z,k),width*(height-ndeltay)*sizeof(T));

               T *ptrd = ptr(0,1,z,k), *ptrs = ptr(0,0,z,k);

               for (int l = 0; l<ndeltay-1; ++l) { std::memcpy(ptrd,ptrs,width*sizeof(T)); ptrd+=width; }

             }

           }

           break;

         case 2 : {

           const int ml = cimg::mod(-deltay,dimy()), ndeltay = (ml<=dimy()/2)?ml:(ml-dimy());

           if (!ndeltay) return *this;

           T* buf = new T[width*cimg::abs(ndeltay)];

           if (ndeltay>0) cimg_forZV(*this,z,k) {

             std::memcpy(buf,ptr(0,0,z,k),width*ndeltay*sizeof(T));

             std::memmove(ptr(0,0,z,k),ptr(0,ndeltay,z,k),width*(height-ndeltay)*sizeof(T));

             std::memcpy(ptr(0,height-ndeltay,z,k),buf,width*ndeltay*sizeof(T));

           } else cimg_forZV(*this,z,k) {

             std::memcpy(buf,ptr(0,height+ndeltay,z,k),-ndeltay*width*sizeof(T));

             std::memmove(ptr(0,-ndeltay,z,k),ptr(0,0,z,k),width*(height+ndeltay)*sizeof(T));

             std::memcpy(ptr(0,0,z,k),buf,-ndeltay*width*sizeof(T));

           }

           delete[] buf;

         } break;

         }


       if (deltaz) // Translate along Z-axis

         switch (border_condition) {

         case 0 :

           if (cimg::abs(deltaz)>=dimz()) return fill(0);

           if (deltaz<0) cimg_forV(*this,k) {

             std::memmove(ptr(0,0,0,k),ptr(0,0,-deltaz,k),width*height*(depth+deltaz)*sizeof(T));

             std::memset(ptr(0,0,depth+deltaz,k),0,width*height*(-deltaz)*sizeof(T));

           } else cimg_forV(*this,k) {

             std::memmove(ptr(0,0,deltaz,k),ptr(0,0,0,k),width*height*(depth-deltaz)*sizeof(T));

             std::memset(ptr(0,0,0,k),0,deltaz*width*height*sizeof(T));

           }

           break;

         case 1 :

           if (deltaz<0) {

             const int ndeltaz = (-deltaz>=dimz())?depth-1:-deltaz;

             if (!ndeltaz) return *this;

             cimg_forV(*this,k) {

               std::memmove(ptr(0,0,0,k),ptr(0,0,ndeltaz,k),width*height*(depth-ndeltaz)*sizeof(T));

               T *ptrd = ptr(0,0,depth-ndeltaz,k), *ptrs = ptr(0,0,depth-1,k);

               for (int l = 0; l<ndeltaz-1; ++l) { std::memcpy(ptrd,ptrs,width*height*sizeof(T)); ptrd+=width*height; }

             }

           } else {

             const int ndeltaz = (deltaz>=dimz())?depth-1:deltaz;

             if (!ndeltaz) return *this;

             cimg_forV(*this,k) {

               std::memmove(ptr(0,0,ndeltaz,k),ptr(0,0,0,k),width*height*(depth-ndeltaz)*sizeof(T));

               T *ptrd = ptr(0,0,1,k), *ptrs = ptr(0,0,0,k);

               for (int l = 0; l<ndeltaz-1; ++l) { std::memcpy(ptrd,ptrs,width*height*sizeof(T)); ptrd+=width*height; }

             }

           }

           break;

         case 2 : {

           const int ml = cimg::mod(-deltaz,dimz()), ndeltaz = (ml<=dimz()/2)?ml:(ml-dimz());

           if (!ndeltaz) return *this;

           T* buf = new T[width*height*cimg::abs(ndeltaz)];

           if (ndeltaz>0) cimg_forV(*this,k) {

             std::memcpy(buf,ptr(0,0,0,k),width*height*ndeltaz*sizeof(T));

             std::memmove(ptr(0,0,0,k),ptr(0,0,ndeltaz,k),width*height*(depth-ndeltaz)*sizeof(T));

             std::memcpy(ptr(0,0,depth-ndeltaz,k),buf,width*height*ndeltaz*sizeof(T));

           } else cimg_forV(*this,k) {

             std::memcpy(buf,ptr(0,0,depth+ndeltaz,k),-ndeltaz*width*height*sizeof(T));

             std::memmove(ptr(0,0,-ndeltaz,k),ptr(0,0,0,k),width*height*(depth+ndeltaz)*sizeof(T));

             std::memcpy(ptr(0,0,0,k),buf,-ndeltaz*width*height*sizeof(T));

           }

           delete[] buf;

         } break;

         }


       if (deltav) // Translate along V-axis

         switch (border_condition) {

         case 0 :

           if (cimg::abs(deltav)>=dimv()) return fill(0);

           if (-deltav>0) {

             std::memmove(data,ptr(0,0,0,-deltav),width*height*depth*(dim+deltav)*sizeof(T));

             std::memset(ptr(0,0,0,dim+deltav),0,width*height*depth*(-deltav)*sizeof(T));

           } else cimg_forV(*this,k) {

             std::memmove(ptr(0,0,0,deltav),data,width*height*depth*(dim-deltav)*sizeof(T));

             std::memset(data,0,deltav*width*height*depth*sizeof(T));

           }

           break;

         case 1 :

           if (deltav<0) {

             const int ndeltav = (-deltav>=dimv())?dim-1:-deltav;

             if (!ndeltav) return *this;

             std::memmove(data,ptr(0,0,0,ndeltav),width*height*depth*(dim-ndeltav)*sizeof(T));

             T *ptrd = ptr(0,0,0,dim-ndeltav), *ptrs = ptr(0,0,0,dim-1);

             for (int l = 0; l<ndeltav-1; ++l) { std::memcpy(ptrd,ptrs,width*height*depth*sizeof(T)); ptrd+=width*height*depth; }

           } else {

             const int ndeltav = (deltav>=dimv())?dim-1:deltav;

             if (!ndeltav) return *this;

             std::memmove(ptr(0,0,0,ndeltav),data,width*height*depth*(dim-ndeltav)*sizeof(T));

             T *ptrd = ptr(0,0,0,1);

             for (int l = 0; l<ndeltav-1; ++l) { std::memcpy(ptrd,data,width*height*depth*sizeof(T)); ptrd+=width*height*depth; }

           }

           break;

         case 2 : {

           const int ml = cimg::mod(-deltav,dimv()), ndeltav = (ml<=dimv()/2)?ml:(ml-dimv());

           if (!ndeltav) return *this;

           T* buf = new T[width*height*depth*cimg::abs(ndeltav)];

           if (ndeltav>0) {

             std::memcpy(buf,data,width*height*depth*ndeltav*sizeof(T));

             std::memmove(data,ptr(0,0,0,ndeltav),width*height*depth*(dim-ndeltav)*sizeof(T));

             std::memcpy(ptr(0,0,0,dim-ndeltav),buf,width*height*depth*ndeltav*sizeof(T));

           } else {

             std::memcpy(buf,ptr(0,0,0,dim+ndeltav),-ndeltav*width*height*depth*sizeof(T));

             std::memmove(ptr(0,0,0,-ndeltav),data,width*height*depth*(dim+ndeltav)*sizeof(T));

             std::memcpy(data,buf,-ndeltav*width*height*depth*sizeof(T));

           }

           delete[] buf;

         } break;

         }

       return *this;

     }


     CImg<T> get_translate(const int deltax, const int deltay=0, const int deltaz=0, const int deltav=0,

                           const int border_condition=0) const {

       return (+*this).translate(deltax,deltay,deltaz,deltav,border_condition);

     }


     // Permute axes order (internal).

     template<typename t>

     CImg<t> _get_permute_axes(const char *permut, const t&) const {

       if (is_empty() || !permut) return CImg<t>(*this,false);

       CImg<t> res;

       const T* ptrs = data;

       if (!cimg::strncasecmp(permut,"xyzv",4)) return (+*this);

       if (!cimg::strncasecmp(permut,"xyvz",4)) {

         res.assign(width,height,dim,depth);

         cimg_forXYZV(*this,x,y,z,v) res(x,y,v,z) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"xzyv",4)) {

         res.assign(width,depth,height,dim);

         cimg_forXYZV(*this,x,y,z,v) res(x,z,y,v) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"xzvy",4)) {

         res.assign(width,depth,dim,height);

         cimg_forXYZV(*this,x,y,z,v) res(x,z,v,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"xvyz",4)) {

         res.assign(width,dim,height,depth);

         cimg_forXYZV(*this,x,y,z,v) res(x,v,y,z) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"xvzy",4)) {

         res.assign(width,dim,depth,height);

         cimg_forXYZV(*this,x,y,z,v) res(x,v,z,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"yxzv",4)) {

         res.assign(height,width,depth,dim);

         cimg_forXYZV(*this,x,y,z,v) res(y,x,z,v) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"yxvz",4)) {

         res.assign(height,width,dim,depth);

         cimg_forXYZV(*this,x,y,z,v) res(y,x,v,z) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"yzxv",4)) {

         res.assign(height,depth,width,dim);

         cimg_forXYZV(*this,x,y,z,v) res(y,z,x,v) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"yzvx",4)) {

         res.assign(height,depth,dim,width);

         switch (width) {

         case 1 : {

           t *ptrR = res.ptr(0,0,0,0);

           for (unsigned int siz = height*depth*dim; siz; --siz) {

             *(ptrR++) = (t)*(ptrs++);

           }

         } break;

         case 2 : {

           t *ptrR = res.ptr(0,0,0,0), *ptrG = res.ptr(0,0,0,1);

           for (unsigned int siz = height*depth*dim; siz; --siz) {

             *(ptrR++) = (t)*(ptrs++); *(ptrG++) = (t)*(ptrs++);

           }

         } break;

         case 3 : { // Optimization for the classical conversion from interleaved RGB to planar RGB

           t *ptrR = res.ptr(0,0,0,0), *ptrG = res.ptr(0,0,0,1), *ptrB = res.ptr(0,0,0,2);

           for (unsigned int siz = height*depth*dim; siz; --siz) {

             *(ptrR++) = (t)*(ptrs++); *(ptrG++) = (t)*(ptrs++); *(ptrB++) = (t)*(ptrs++);

           }

         } break;

         case 4 : { // Optimization for the classical conversion from interleaved RGBA to planar RGBA

           t *ptrR = res.ptr(0,0,0,0), *ptrG = res.ptr(0,0,0,1), *ptrB = res.ptr(0,0,0,2), *ptrA = res.ptr(0,0,0,3);

           for (unsigned int siz = height*depth*dim; siz; --siz) {

             *(ptrR++) = (t)*(ptrs++); *(ptrG++) = (t)*(ptrs++); *(ptrB++) = (t)*(ptrs++); *(ptrA++) = (t)*(ptrs++);

           }

         } break;

         default : {

           cimg_forXYZV(*this,x,y,z,v) res(y,z,v,x) = *(ptrs++);

           return res;

         }

         }

       }

       if (!cimg::strncasecmp(permut,"yvxz",4)) {

         res.assign(height,dim,width,depth);

         cimg_forXYZV(*this,x,y,z,v) res(y,v,x,z) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"yvzx",4)) {

         res.assign(height,dim,depth,width);

         cimg_forXYZV(*this,x,y,z,v) res(y,v,z,x) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zxyv",4)) {

         res.assign(depth,width,height,dim);

         cimg_forXYZV(*this,x,y,z,v) res(z,x,y,v) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zxvy",4)) {

         res.assign(depth,width,dim,height);

         cimg_forXYZV(*this,x,y,z,v) res(z,x,v,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zyxv",4)) {

         res.assign(depth,height,width,dim);

         cimg_forXYZV(*this,x,y,z,v) res(z,y,x,v) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zyvx",4)) {

         res.assign(depth,height,dim,width);

         cimg_forXYZV(*this,x,y,z,v) res(z,y,v,x) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zvxy",4)) {

         res.assign(depth,dim,width,height);

         cimg_forXYZV(*this,x,y,z,v) res(z,v,x,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"zvyx",4)) {

         res.assign(depth,dim,height,width);

         cimg_forXYZV(*this,x,y,z,v) res(z,v,y,x) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"vxyz",4)) {

         res.assign(dim,width,height,depth);

         switch (dim) {

         case 1 : {

           const T *ptrR = ptr(0,0,0,0);

           t *ptrd = res.ptr();

           for (unsigned int siz = width*height*depth; siz; --siz) {

             *(ptrd++) = (t)*(ptrR++);

           }

         } break;

         case 2 : {

           const T *ptrR = ptr(0,0,0,0), *ptrG = ptr(0,0,0,1);

           t *ptrd = res.ptr();

           for (unsigned int siz = width*height*depth; siz; --siz) {

             *(ptrd++) = (t)*(ptrR++); *(ptrd++) = (t)*(ptrG++);

           }

         } break;

         case 3 : { // Optimization for the classical conversion from planar RGB to interleaved RGB

           const T *ptrR = ptr(0,0,0,0), *ptrG = ptr(0,0,0,1), *ptrB = ptr(0,0,0,2);

           t *ptrd = res.ptr();

           for (unsigned int siz = width*height*depth; siz; --siz) {

             *(ptrd++) = (t)*(ptrR++); *(ptrd++) = (t)*(ptrG++); *(ptrd++) = (t)*(ptrB++);

           }

         } break;

         case 4 : { // Optimization for the classical conversion from planar RGBA to interleaved RGBA

           const T *ptrR = ptr(0,0,0,0), *ptrG = ptr(0,0,0,1), *ptrB = ptr(0,0,0,2), *ptrA = ptr(0,0,0,3);

           t *ptrd = res.ptr();

           for (unsigned int siz = width*height*depth; siz; --siz) {

             *(ptrd++) = (t)*(ptrR++); *(ptrd++) = (t)*(ptrG++); *(ptrd++) = (t)*(ptrB++); *(ptrd++) = (t)*(ptrA++);

           }

         } break;

         default : {

           cimg_forXYZV(*this,x,y,z,v) res(v,x,y,z) = (t)*(ptrs++);

         }

         }

       }

       if (!cimg::strncasecmp(permut,"vxzy",4)) {

         res.assign(dim,width,depth,height);

         cimg_forXYZV(*this,x,y,z,v) res(v,x,z,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"vyxz",4)) {

         res.assign(dim,height,width,depth);

         cimg_forXYZV(*this,x,y,z,v) res(v,y,x,z) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"vyzx",4)) {

         res.assign(dim,height,depth,width);

         cimg_forXYZV(*this,x,y,z,v) res(v,y,z,x) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"vzxy",4)) {

         res.assign(dim,depth,width,height);

         cimg_forXYZV(*this,x,y,z,v) res(v,z,x,y) = (t)*(ptrs++);

       }

       if (!cimg::strncasecmp(permut,"vzyx",4)) {

         res.assign(dim,depth,height,width);

         cimg_forXYZV(*this,x,y,z,v) res(v,z,y,x) = (t)*(ptrs++);

       }

       if (!res)

         throw CImgArgumentException("CImg<%s>::permute_axes() : Invalid permutation '%s'.",

                                     pixel_type(),permut);

       return res;

     }


     CImg<T>& permute_axes(const char *order) {

       return get_permute_axes(order).transfer_to(*this);

     }


     CImg<T> get_permute_axes(const char *order) const {

       const T foo = (T)0;

       return _get_permute_axes(order,foo);

     }


     CImg<T>& unroll(const char axis) {

       const unsigned int siz = size();

       if (siz) switch (axis) {

       case 'x' : width = siz; height=depth=dim=1; break;

       case 'y' : height = siz; width=depth=dim=1; break;

       case 'z' : depth = siz; width=height=dim=1; break;

       case 'v' : dim = siz; width=height=depth=1; break;

       default :

         throw CImgArgumentException("CImg<%s>::unroll() : Given axis is '%c' which is not 'x','y','z' or 'v'",

                                     pixel_type(),axis);

       }

       return *this;

     }


     CImg<T> get_unroll(const char axis) const {

       return (+*this).unroll(axis);

     }


     CImg<T>& rotate(const float angle, const unsigned int border_conditions=3, const unsigned int interpolation=1) {

       return get_rotate(angle,border_conditions,interpolation).transfer_to(*this);

     }


     CImg<T> get_rotate(const float angle, const unsigned int border_conditions=3, const unsigned int interpolation=1) const {

       if (is_empty()) return *this;

       CImg<T> dest;

       const float nangle = cimg::mod(angle,360.0f);

       if (border_conditions!=1 && cimg::mod(nangle,90.0f)==0) { // optimized version for orthogonal angles

         const int wm1 = dimx()-1, hm1 = dimy()-1;

         const int iangle = (int)nangle/90;

         switch (iangle) {

         case 1 : {

           dest.assign(height,width,depth,dim);

           cimg_forXYZV(dest,x,y,z,v) dest(x,y,z,v) = (*this)(y,hm1-x,z,v);

         } break;

         case 2 : {

           dest.assign(width,height,depth,dim);

           cimg_forXYZV(dest,x,y,z,v) dest(x,y,z,v) = (*this)(wm1-x,hm1-y,z,v);

         } break;

         case 3 : {

           dest.assign(height,width,depth,dim);

           cimg_forXYZV(dest,x,y,z,v) dest(x,y,z,v) = (*this)(wm1-y,x,z,v);

         } break;

         default :

           return *this;

         }

       } else { // generic version

         const float

           rad = (float)(nangle*cimg::valuePI/180.0),

           ca = (float)std::cos(rad),

           sa = (float)std::sin(rad),

           ux = cimg::abs(width*ca), uy = cimg::abs(width*sa),

           vx = cimg::abs(height*sa), vy = cimg::abs(height*ca),

           w2 = 0.5f*width, h2 = 0.5f*height,

           dw2 = 0.5f*(ux+vx), dh2 = 0.5f*(uy+vy);

         dest.assign((int)(ux+vx), (int)(uy+vy),depth,dim);

         switch (border_conditions) {

         case 0 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(w2 + (x-dw2)*ca + (y-dh2)*sa,h2 - (x-dw2)*sa + (y-dh2)*ca,z,v,0);

           } break;

           case 1 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(w2 + (x-dw2)*ca + (y-dh2)*sa,h2 - (x-dw2)*sa + (y-dh2)*ca,z,v,0);

           } break;

           default : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = atXY((int)(w2 + (x-dw2)*ca + (y-dh2)*sa),(int)(h2 - (x-dw2)*sa + (y-dh2)*ca),z,v,0);

           }

           }

         } break;

         case 1 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(w2 + (x-dw2)*ca + (y-dh2)*sa,h2 - (x-dw2)*sa + (y-dh2)*ca,z,v);

            } break;

           case 1 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(w2 + (x-dw2)*ca + (y-dh2)*sa,h2 - (x-dw2)*sa + (y-dh2)*ca,z,v);

           } break;

           default : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = atXY((int)(w2 + (x-dw2)*ca + (y-dh2)*sa),(int)(h2 - (x-dw2)*sa + (y-dh2)*ca),z,v);

           }

           }

         } break;

         case 2 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(cimg::mod(w2 + (x-dw2)*ca + (y-dh2)*sa,(float)dimx()),

                                             cimg::mod(h2 - (x-dw2)*sa + (y-dh2)*ca,(float)dimy()),z,v);

             } break;

           case 1 : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(cimg::mod(w2 + (x-dw2)*ca + (y-dh2)*sa,(float)dimx()),

                                              cimg::mod(h2 - (x-dw2)*sa + (y-dh2)*ca,(float)dimy()),z,v);

             } break;

           default : {

             cimg_forXY(dest,x,y) cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (*this)(cimg::mod((int)(w2 + (x-dw2)*ca + (y-dh2)*sa),dimx()),

                                       cimg::mod((int)(h2 - (x-dw2)*sa + (y-dh2)*ca),dimy()),z,v);

           }

           }

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::rotate() : Invalid border conditions %d (should be 0,1 or 2).",

                                       pixel_type(),border_conditions);

         }

       }

       return dest;

     }


     CImg<T>& rotate(const float angle, const float cx, const float cy, const float zoom,

                     const unsigned int border_conditions=3, const unsigned int interpolation=1) {

       return get_rotate(angle,cx,cy,zoom,border_conditions,interpolation).transfer_to(*this);

     }


     CImg<T> get_rotate(const float angle, const float cx, const float cy, const float zoom,

                        const unsigned int border_conditions=3, const unsigned int interpolation=1) const {

       if (interpolation>2)

         throw CImgArgumentException("CImg<%s>::rotate() : Invalid interpolation parameter %d (should be {0=none, 1=linear or 2=cubic}).",

                                     pixel_type(),interpolation);

       if (is_empty()) return *this;

       CImg<T> dest(width,height,depth,dim);

       const float nangle = cimg::mod(angle,360.0f);

       if (border_conditions!=1 && zoom==1 && cimg::mod(nangle,90.0f)==0) { // optimized version for orthogonal angles

         const int iangle = (int)nangle/90;

         switch (iangle) {

         case 1 : {

           dest.fill(0);

           const unsigned int

             xmin = cimg::max(0,(dimx()-dimy())/2), xmax = cimg::min(width,xmin+height),

             ymin = cimg::max(0,(dimy()-dimx())/2), ymax = cimg::min(height,ymin+width),

             xoff = xmin + cimg::min(0,(dimx()-dimy())/2),

             yoff = ymin + cimg::min(0,(dimy()-dimx())/2);

           cimg_forZV(dest,z,v) for (unsigned int y = ymin; y<ymax; ++y) for (unsigned int x = xmin; x<xmax; ++x)

             dest(x,y,z,v) = (*this)(y-yoff,height-1-x+xoff,z,v);

         } break;

         case 2 : {

           cimg_forXYZV(dest,x,y,z,v) dest(x,y,z,v) = (*this)(width-1-x,height-1-y,z,v);

         } break;

         case 3 : {

           dest.fill(0);

           const unsigned int

             xmin = cimg::max(0,(dimx()-dimy())/2), xmax = cimg::min(width,xmin+height),

             ymin = cimg::max(0,(dimy()-dimx())/2), ymax = cimg::min(height,ymin+width),

             xoff = xmin + cimg::min(0,(dimx()-dimy())/2),

             yoff = ymin + cimg::min(0,(dimy()-dimx())/2);

           cimg_forZV(dest,z,v) for (unsigned int y = ymin; y<ymax; ++y) for (unsigned int x = xmin; x<xmax; ++x)

             dest(x,y,z,v) = (*this)(width-1-y+yoff,x-xoff,z,v);

         } break;

         default :

           return *this;

         }

       } else {

         const float

           rad = (float)((nangle*cimg::valuePI)/180.0),

           ca = (float)std::cos(rad)/zoom,

           sa = (float)std::sin(rad)/zoom;

         switch (border_conditions) { // generic version

         case 0 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(cx + (x-cx)*ca + (y-cy)*sa,cy - (x-cx)*sa + (y-cy)*ca,z,v,0);

           } break;

           case 1 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(cx + (x-cx)*ca + (y-cy)*sa,cy - (x-cx)*sa + (y-cy)*ca,z,v,0);

           } break;

           default : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = atXY((int)(cx + (x-cx)*ca + (y-cy)*sa),(int)(cy - (x-cx)*sa + (y-cy)*ca),z,v,0);

           }

           }

         } break;

         case 1 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(cx + (x-cx)*ca + (y-cy)*sa,cy - (x-cx)*sa + (y-cy)*ca,z,v);

             } break;

           case 1 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(cx + (x-cx)*ca + (y-cy)*sa,cy - (x-cx)*sa + (y-cy)*ca,z,v);

           } break;

           default : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = atXY((int)(cx + (x-cx)*ca + (y-cy)*sa),(int)(cy - (x-cx)*sa + (y-cy)*ca),z,v);

           }

           }

         } break;

         case 2 : {

           switch (interpolation) {

           case 2 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)cubic_atXY(cimg::mod(cx + (x-cx)*ca + (y-cy)*sa,(float)dimx()),

                                             cimg::mod(cy - (x-cx)*sa + (y-cy)*ca,(float)dimy()),z,v);

             } break;

           case 1 : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (T)linear_atXY(cimg::mod(cx + (x-cx)*ca + (y-cy)*sa,(float)dimx()),

                                              cimg::mod(cy - (x-cx)*sa + (y-cy)*ca,(float)dimy()),z,v);

           } break;

           default : {

             cimg_forXY(dest,x,y)

               cimg_forZV(*this,z,v)

               dest(x,y,z,v) = (*this)(cimg::mod((int)(cx + (x-cx)*ca + (y-cy)*sa),dimx()),

                                       cimg::mod((int)(cy - (x-cx)*sa + (y-cy)*ca),dimy()),z,v);

           }

           }

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::rotate() : Incorrect border conditions %d (should be 0,1 or 2).",

                                       pixel_type(),border_conditions);

         }

       }

       return dest;

     }


     template<typename t>

     CImg<T>& warp(const CImg<t>& warp, const bool relative=false,

                   const bool interpolation=true, const unsigned int border_conditions=0) {

       return get_warp(warp,relative,interpolation,border_conditions).transfer_to(*this);

     }


     template<typename t>

     CImg<T> get_warp(const CImg<t>& warp, const bool relative=false,

                      const bool interpolation=true, const unsigned int border_conditions=0) const {

       if (is_empty() || !warp) return *this;

       if (relative && !is_sameXYZ(warp))

         throw CImgArgumentException("CImg<%s>::warp() : Instance image (%u,%u,%u,%u,%p) and relative warping field (%u,%u,%u,%u,%p) "

                                     "have different XYZ dimensions.",

                                     pixel_type(),width,height,depth,dim,data,

                                     warp.width,warp.height,warp.depth,warp.dim,warp.data);

       CImg<T> res(warp.width,warp.height,warp.depth,dim);

       switch (warp.dim) {

       case 1 : // 1D warping.

         if (relative) { // Relative warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atX(cimg::mod(x-(float)warp(x,y,z,0),(float)width),y,z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atX(x-(float)warp(x,y,z,0),y,z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atX(x-(float)warp(x,y,z,0),y,z,v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod(x-(int)warp(x,y,z,0),(int)width),y,z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atX(x-(int)warp(x,y,z,0),y,z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atX(x-(int)warp(x,y,z,0),y,z,v,0);

           }

           }

         } else { // Absolute warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atX(cimg::mod((float)warp(x,y,z,0),(float)width),y,z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atX((float)warp(x,y,z,0),y,z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atX((float)warp(x,y,z,0),y,z,v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod((int)warp(x,y,z,0),(int)width),y,z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atX((int)warp(x,y,z,0),y,z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atX((int)warp(x,y,z,0),y,z,v,0);

           }

           }

         }

         break;


       case 2 : // 2D warping

         if (relative) { // Relative warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXY(cimg::mod(x-(float)warp(x,y,z,0),(float)width),

                                              cimg::mod(y-(float)warp(x,y,z,1),(float)height),z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXY(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXY(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z,v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod(x-(int)warp(x,y,z,0),(int)width),

                                      cimg::mod(y-(int)warp(x,y,z,1),(int)height),z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXY(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXY(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z,v,0);

           }

           }

         } else { // Absolute warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXY(cimg::mod((float)warp(x,y,z,0),(float)width),

                                              cimg::mod((float)warp(x,y,z,1),(float)height),z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXY((float)warp(x,y,z,0),(float)warp(x,y,z,1),z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXY((float)warp(x,y,z,0),(float)warp(x,y,z,1),z,v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod((int)warp(x,y,z,0),(int)width),

                                      cimg::mod((int)warp(x,y,z,1),(int)height),z,v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXY((int)warp(x,y,z,0),(int)warp(x,y,z,1),z,v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXY((int)warp(x,y,z,0),(int)warp(x,y,z,1),z,v,0);

           }

           }

         }

         break;


       case 3 : // 3D warping

         if (relative) { // Relative warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZ(cimg::mod(x-(float)warp(x,y,z,0),(float)width),

                                               cimg::mod(y-(float)warp(x,y,z,1),(float)height),

                                               cimg::mod(z-(float)warp(x,y,z,2),(float)depth),v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZ(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z-(float)warp(x,y,z,2),v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXYZ(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z-(float)warp(x,y,z,2),v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod(x-(int)warp(x,y,z,0),(int)width),

                                      cimg::mod(y-(int)warp(x,y,z,1),(int)height),

                                      cimg::mod(z-(int)warp(x,y,z,2),(int)depth),v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXYZ(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z-(int)warp(x,y,z,2),v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXYZ(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z-(int)warp(x,y,z,2),v,0);

           }

           }

         } else { // Absolute warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZ(cimg::mod((float)warp(x,y,z,0),(float)width),

                                               cimg::mod((float)warp(x,y,z,1),(float)height),

                                               cimg::mod((float)warp(x,y,z,2),(float)depth),v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZ((float)warp(x,y,z,0),(float)warp(x,y,z,1),(float)warp(x,y,z,2),v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXYZ((float)warp(x,y,z,0),(float)warp(x,y,z,1),(float)warp(x,y,z,2),v,0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod((int)warp(x,y,z,0),(int)width),

                                      cimg::mod((int)warp(x,y,z,1),(int)height),

                                      cimg::mod((int)warp(x,y,z,2),(int)depth),v);

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXYZ((int)warp(x,y,z,0),(int)warp(x,y,z,1),(int)warp(x,y,z,2),v);

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXYZ((int)warp(x,y,z,0),(int)warp(x,y,z,1),(int)warp(x,y,z,2),v,0);

           }

           }

         }

         break;


       default : // 4D warping

         if (relative) { // Relative warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZV(cimg::mod(x-(float)warp(x,y,z,0),(float)width),

                                                cimg::mod(y-(float)warp(x,y,z,1),(float)height),

                                                cimg::mod(z-(float)warp(x,y,z,2),(float)depth),

                                                cimg::mod(z-(float)warp(x,y,z,3),(float)dim));

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZV(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z-(float)warp(x,y,z,2),v-(float)warp(x,y,z,3));

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXYZV(x-(float)warp(x,y,z,0),y-(float)warp(x,y,z,1),z-(float)warp(x,y,z,2),v-(float)warp(x,y,z,3),0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod(x-(int)warp(x,y,z,0),(int)width),

                                      cimg::mod(y-(int)warp(x,y,z,1),(int)height),

                                      cimg::mod(z-(int)warp(x,y,z,2),(int)depth),

                                      cimg::mod(v-(int)warp(x,y,z,3),(int)dim));

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXYZV(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z-(int)warp(x,y,z,2),v-(int)warp(x,y,z,3));

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXYZ(x-(int)warp(x,y,z,0),y-(int)warp(x,y,z,1),z-(int)warp(x,y,z,2),v-(int)warp(x,y,z,3),0);

           }

           }

         } else { // Absolute warp coordinates

           if (interpolation) switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZV(cimg::mod((float)warp(x,y,z,0),(float)width),

                                                cimg::mod((float)warp(x,y,z,1),(float)height),

                                                cimg::mod((float)warp(x,y,z,2),(float)depth),

                                                cimg::mod((float)warp(x,y,z,3),(float)dim));

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)_linear_atXYZV((float)warp(x,y,z,0),(float)warp(x,y,z,1),(float)warp(x,y,z,2),(float)warp(x,y,z,3));

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (T)linear_atXYZV((float)warp(x,y,z,0),(float)warp(x,y,z,1),(float)warp(x,y,z,2),(float)warp(x,y,z,3),0);

           }

           } else switch (border_conditions) {

           case 2 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = (*this)(cimg::mod((int)warp(x,y,z,0),(int)width),

                                      cimg::mod((int)warp(x,y,z,1),(int)height),

                                      cimg::mod((int)warp(x,y,z,2),(int)depth),

                                      cimg::mod((int)warp(x,y,z,3),(int)dim));

           } break;

           case 1 : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = _atXYZV((int)warp(x,y,z,0),(int)warp(x,y,z,1),(int)warp(x,y,z,2),(int)warp(x,y,z,3));

           } break;

           default : {

             cimg_forXYZV(res,x,y,z,v)

               res(x,y,z,v) = atXYZV((int)warp(x,y,z,0),(int)warp(x,y,z,1),(int)warp(x,y,z,2),(int)warp(x,y,z,3),0);

           }

           }

         }

       }

       return res;

     }


     CImg<T>& projections2d(const unsigned int x0, const unsigned int y0, const unsigned int z0,

                            const int dx=-100, const int dy=-100, const int dz=-100) {

       return get_projections2d(x0,y0,z0,dx,dy,dz).transfer_to(*this);

     }


     CImg<T> get_projections2d(const unsigned int x0, const unsigned int y0, const unsigned int z0,

                               const int dx=-100, const int dy=-100, const int dz=-100) const {

       if (is_empty()) return *this;

       const unsigned int

         nx0 = (x0>=width)?width-1:x0,

         ny0 = (y0>=height)?height-1:y0,

         nz0 = (z0>=depth)?depth-1:z0;

       CImg<T>

         imgxy(width,height,1,dim),

         imgzy(depth,height,1,dim),

         imgxz(width,depth,1,dim);

       cimg_forXYV(*this,x,y,k) imgxy(x,y,k) = (*this)(x,y,nz0,k);

       cimg_forYZV(*this,y,z,k) imgzy(z,y,k) = (*this)(nx0,y,z,k);

       cimg_forXZV(*this,x,z,k) imgxz(x,z,k) = (*this)(x,ny0,z,k);

       imgxy.resize(dx,dy,1,dim,1);

       imgzy.resize(dz,dy,1,dim,1);

       imgxz.resize(dx,dz,1,dim,1);

       return CImg<T>(imgxy.width + imgzy.width,imgxy.height + imgxz.height,1,dim,0).

         draw_image(imgxy).draw_image(imgxy.width,imgzy).draw_image(0,imgxy.height,imgxz);

     }


     CImg<T>& crop(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) {

       return get_crop(x0,y0,z0,v0,x1,y1,z1,v1,border_condition).transfer_to(*this);

     }


     CImg<T> get_crop(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) const {

       if (is_empty()) return *this;

       const int

         nx0 = x0<x1?x0:x1, nx1 = x0^x1^nx0,

         ny0 = y0<y1?y0:y1, ny1 = y0^y1^ny0,

         nz0 = z0<z1?z0:z1, nz1 = z0^z1^nz0,

         nv0 = v0<v1?v0:v1, nv1 = v0^v1^nv0;

       CImg<T> dest(1U+nx1-nx0,1U+ny1-ny0,1U+nz1-nz0,1U+nv1-nv0);

       if (nx0<0 || nx1>=dimx() || ny0<0 || ny1>=dimy() || nz0<0 || nz1>=dimz() || nv0<0 || nv1>=dimv()) {

         if (border_condition) cimg_forXYZV(dest,x,y,z,v) dest(x,y,z,v) = _atXYZV(nx0+x,ny0+y,nz0+z,nv0+v);

         else dest.fill(0).draw_image(-nx0,-ny0,-nz0,-nv0,*this);

       } else dest.draw_image(-nx0,-ny0,-nz0,-nv0,*this);

       return dest;

     }


     CImg<T>& crop(const int x0, const int y0, const int z0,

                   const int x1, const int y1, const int z1,

                   const bool border_condition=false) {

       return crop(x0,y0,z0,0,x1,y1,z1,dim-1,border_condition);

     }


     CImg<T> get_crop(const int x0, const int y0, const int z0,

                      const int x1, const int y1, const int z1,

                      const bool border_condition=false) const {

       return get_crop(x0,y0,z0,0,x1,y1,z1,dim-1,border_condition);

     }


     CImg<T>& crop(const int x0, const int y0,

                   const int x1, const int y1,

                   const bool border_condition=false) {

       return crop(x0,y0,0,0,x1,y1,depth-1,dim-1,border_condition);

     }


     CImg<T> get_crop(const int x0, const int y0,

                      const int x1, const int y1,

                      const bool border_condition=false) const {

       return get_crop(x0,y0,0,0,x1,y1,depth-1,dim-1,border_condition);

     }


     CImg<T>& crop(const int x0, const int x1, const bool border_condition=false) {

       return crop(x0,0,0,0,x1,height-1,depth-1,dim-1,border_condition);

     }


     CImg<T> get_crop(const int x0, const int x1, const bool border_condition=false) const {

       return get_crop(x0,0,0,0,x1,height-1,depth-1,dim-1,border_condition);

     }


     CImg<T>& autocrop(const T value, const char *const axes="vzyx") {

       if (is_empty()) return *this;

       for (const char *s = axes; *s; ++s) {

         const char axis = cimg::uncase(*s);

         const CImg<intT> coords = _autocrop(value,axis);

         switch (axis) {

         case 'x' : {

           const int x0 = coords[0], x1 = coords[1];

           if (x0>=0 && x1>=0) crop(x0,x1);

         } break;

         case 'y' : {

           const int y0 = coords[0], y1 = coords[1];

           if (y0>=0 && y1>=0) crop(0,y0,width-1,y1);

         } break;

         case 'z' : {

           const int z0 = coords[0], z1 = coords[1];

           if (z0>=0 && z1>=0) crop(0,0,z0,width-1,height-1,z1);

         } break;

         case 'v' : {

           const int v0 = coords[0], v1 = coords[1];

           if (v0>=0 && v1>=0) crop(0,0,0,v0,width-1,height-1,depth-1,v1);

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::autocrop() : Invalid axis '%c' (should be 'x','y','z' or 'v').",

                                       pixel_type(),*s);

         }

       }

       return *this;

     }


     CImg<T> get_autocrop(const T value, const char *const axes="vzyx") const {

       return (+*this).autocrop(value,axes);

     }


     CImg<T>& autocrop(const T *const color, const char *const axes="zyx") {

       if (is_empty()) return *this;

       for (const char *s = axes; *s; ++s) {

         const char axis = cimg::uncase(*s);

         switch (axis) {

         case 'x' : {

           int x0 = width, x1 = -1;

           cimg_forV(*this,k) {

             const CImg<intT> coords = get_shared_channel(k)._autocrop(color[k],'x');

             const int nx0 = coords[0], nx1 = coords[1];

             if (nx0>=0 && nx1>=0) { x0 = cimg::min(x0,nx0); x1 = cimg::max(x1,nx1); }

           }

           if (x0<=x1) crop(x0,x1);

         } break;

         case 'y' : {

           int y0 = height, y1 = -1;

           cimg_forV(*this,k) {

             const CImg<intT> coords = get_shared_channel(k)._autocrop(color[k],'y');

             const int ny0 = coords[0], ny1 = coords[1];

             if (ny0>=0 && ny1>=0) { y0 = cimg::min(y0,ny0); y1 = cimg::max(y1,ny1); }

           }

           if (y0<=y1) crop(0,y0,width-1,y1);

         } break;

         case 'z' : {

           int z0 = depth, z1 = -1;

           cimg_forV(*this,k) {

             const CImg<intT> coords = get_shared_channel(k)._autocrop(color[k],'z');

             const int nz0 = coords[0], nz1 = coords[1];

             if (nz0>=0 && nz1>=0) { z0 = cimg::min(z0,nz0); z1 = cimg::max(z1,nz1); }

           }

           if (z0<=z1) crop(0,0,z0,width-1,height-1,z1);

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::autocrop() : Invalid axis '%c' (should be 'x','y' or 'z').",

                                       pixel_type(),*s);

         }

       }

       return *this;

     }


     CImg<T> get_autocrop(const T *const color, const char *const axes="zyx") const {

       return (+*this).autocrop(color,axes);

     }


     template<typename t> CImg<T>& autocrop(const CImg<t>& color, const char *const axes="zyx") {

       return get_autocrop(color,axes).transfer_to(*this);

     }


     template<typename t> CImg<T> get_autocrop(const CImg<t>& color, const char *const axes="zyx") const {

       return get_autocrop(color.data,axes);

     }


     CImg<intT> _autocrop(const T value, const char axis) const {

       CImg<intT> res;

       int x0 = -1, y0 = -1, z0 = -1, v0 = -1, x1 = -1, y1 = -1, z1 = -1, v1 = -1;

       switch (cimg::uncase(axis)) {

       case 'x' : {

         cimg_forX(*this,x) cimg_forYZV(*this,y,z,v)

           if ((*this)(x,y,z,v)!=value) { x0 = x; x = dimx(); y = dimy(); z = dimz(); v = dimv(); }

         if (x0>=0) {

           for (int x = dimx()-1; x>=0; --x) cimg_forYZV(*this,y,z,v)

             if ((*this)(x,y,z,v)!=value) { x1 = x; x = 0; y = dimy(); z = dimz(); v = dimv(); }

         }

         res = CImg<intT>::vector(x0,x1);

       } break;

       case 'y' : {

         cimg_forY(*this,y) cimg_forXZV(*this,x,z,v)

           if ((*this)(x,y,z,v)!=value) { y0 = y; x = dimx(); y = dimy(); z = dimz(); v = dimv(); }

         if (y0>=0) {

           for (int y = dimy()-1; y>=0; --y) cimg_forXZV(*this,x,z,v)

             if ((*this)(x,y,z,v)!=value) { y1 = y; x = dimx(); y = 0; z = dimz(); v = dimv(); }

         }

         res = CImg<intT>::vector(y0,y1);

       } break;

       case 'z' : {

         cimg_forZ(*this,z) cimg_forXYV(*this,x,y,v)

           if ((*this)(x,y,z,v)!=value) { z0 = z; x = dimx(); y = dimy(); z = dimz(); v = dimv(); }

         if (z0>=0) {

           for (int z = dimz()-1; z>=0; --z) cimg_forXYV(*this,x,y,v)

             if ((*this)(x,y,z,v)!=value) { z1 = z; x = dimx(); y = dimy(); z = 0; v = dimv(); }

         }

         res = CImg<intT>::vector(z0,z1);

       } break;

       case 'v' : {

         cimg_forV(*this,v) cimg_forXYZ(*this,x,y,z)

           if ((*this)(x,y,z,v)!=value) { v0 = v; x = dimx(); y = dimy(); z = dimz(); v = dimv(); }

         if (v0>=0) {

           for (int v = dimv()-1; v>=0; --v) cimg_forXYZ(*this,x,y,z)

             if ((*this)(x,y,z,v)!=value) { v1 = v; x = dimx(); y = dimy(); z = dimz(); v = 0; }

         }

         res = CImg<intT>::vector(v0,v1);

       } break;

       default :

         throw CImgArgumentException("CImg<%s>::autocrop() : unknow axis '%c', must be 'x','y','z' or 'v'",

                                     pixel_type(),axis);

       }

       return res;

     }


     CImg<T>& column(const unsigned int x0) {

       return columns(x0,x0);

     }


     CImg<T> get_column(const unsigned int x0) const {

       return get_columns(x0,x0);

     }


     CImg<T>& columns(const unsigned int x0, const unsigned int x1) {

       return get_columns(x0,x1).transfer_to(*this);

     }


     CImg<T> get_columns(const unsigned int x0, const unsigned int x1) const {

       return get_crop((int)x0,0,0,0,(int)x1,dimy()-1,dimz()-1,dimv()-1);

     }


     CImg<T>& line(const unsigned int y0) {

       return lines(y0,y0);

     }


     CImg<T> get_line(const unsigned int y0) const {

       return get_lines(y0,y0);

     }


     CImg<T>& lines(const unsigned int y0, const unsigned int y1) {

       return get_lines(y0,y1).transfer_to(*this);

     }


     CImg<T> get_lines(const unsigned int y0, const unsigned int y1) const {

       return get_crop(0,(int)y0,0,0,dimx()-1,(int)y1,dimz()-1,dimv()-1);

     }


     CImg<T>& slice(const unsigned int z0) {

       return slices(z0,z0);

     }


     CImg<T> get_slice(const unsigned int z0) const {

       return get_slices(z0,z0);

     }


     CImg<T>& slices(const unsigned int z0, const unsigned int z1) {

       return get_slices(z0,z1).transfer_to(*this);

     }


     CImg<T> get_slices(const unsigned int z0, const unsigned int z1) const {

       return get_crop(0,0,(int)z0,0,dimx()-1,dimy()-1,(int)z1,dimv()-1);

     }


     CImg<T>& channel(const unsigned int v0) {

       return channels(v0,v0);

     }


     CImg<T> get_channel(const unsigned int v0) const {

       return get_channels(v0,v0);

     }


     CImg<T>& channels(const unsigned int v0, const unsigned int v1) {

       return get_channels(v0,v1).transfer_to(*this);

     }


     CImg<T> get_channels(const unsigned int v0, const unsigned int v1) const {

       return get_crop(0,0,0,(int)v0,dimx()-1,dimy()-1,dimz()-1,(int)v1);

     }


     CImg<T> get_shared_points(const unsigned int x0, const unsigned int x1,

                               const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0) {

       const unsigned int beg = (unsigned int)offset(x0,y0,z0,v0), end = offset(x1,y0,z0,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_points() : Cannot return a shared-memory subset (%u->%u,%u,%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),x0,x1,y0,z0,v0,width,height,depth,dim);

       return CImg<T>(data+beg,x1-x0+1,1,1,1,true);

     }


     const CImg<T> get_shared_points(const unsigned int x0, const unsigned int x1,

                                     const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0) const {

       const unsigned int beg = (unsigned int)offset(x0,y0,z0,v0), end = offset(x1,y0,z0,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_points() : Cannot return a shared-memory subset (%u->%u,%u,%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),x0,x1,y0,z0,v0,width,height,depth,dim);

       return CImg<T>(data+beg,x1-x0+1,1,1,1,true);

     }


     CImg<T> get_shared_lines(const unsigned int y0, const unsigned int y1,

                              const unsigned int z0=0, const unsigned int v0=0) {

       const unsigned int beg = offset(0,y0,z0,v0), end = offset(0,y1,z0,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_lines() : Cannot return a shared-memory subset (0->%u,%u->%u,%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,y0,y1,z0,v0,width,height,depth,dim);

       return CImg<T>(data+beg,width,y1-y0+1,1,1,true);

     }


     const CImg<T> get_shared_lines(const unsigned int y0, const unsigned int y1,

                                    const unsigned int z0=0, const unsigned int v0=0) const {

       const unsigned int beg = offset(0,y0,z0,v0), end = offset(0,y1,z0,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_lines() : Cannot return a shared-memory subset (0->%u,%u->%u,%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,y0,y1,z0,v0,width,height,depth,dim);

       return CImg<T>(data+beg,width,y1-y0+1,1,1,true);

     }


     CImg<T> get_shared_line(const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0) {

       return get_shared_lines(y0,y0,z0,v0);

     }


     const CImg<T> get_shared_line(const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0) const {

       return get_shared_lines(y0,y0,z0,v0);

     }


     CImg<T> get_shared_planes(const unsigned int z0, const unsigned int z1, const unsigned int v0=0) {

       const unsigned int beg = offset(0,0,z0,v0), end = offset(0,0,z1,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_planes() : Cannot return a shared-memory subset (0->%u,0->%u,%u->%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,height-1,z0,z1,v0,width,height,depth,dim);

       return CImg<T>(data+beg,width,height,z1-z0+1,1,true);

     }


     const CImg<T> get_shared_planes(const unsigned int z0, const unsigned int z1, const unsigned int v0=0) const {

       const unsigned int beg = offset(0,0,z0,v0), end = offset(0,0,z1,v0);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_planes() : Cannot return a shared-memory subset (0->%u,0->%u,%u->%u,%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,height-1,z0,z1,v0,width,height,depth,dim);

       return CImg<T>(data+beg,width,height,z1-z0+1,1,true);

     }


     CImg<T> get_shared_plane(const unsigned int z0, const unsigned int v0=0) {

       return get_shared_planes(z0,z0,v0);

     }


     const CImg<T> get_shared_plane(const unsigned int z0, const unsigned int v0=0) const {

       return get_shared_planes(z0,z0,v0);

     }


     CImg<T> get_shared_channels(const unsigned int v0, const unsigned int v1) {

       const unsigned int beg = offset(0,0,0,v0), end = offset(0,0,0,v1);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_channels() : Cannot return a shared-memory subset (0->%u,0->%u,0->%u,%u->%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,height-1,depth-1,v0,v1,width,height,depth,dim);

       return CImg<T>(data+beg,width,height,depth,v1-v0+1,true);

     }


     const CImg<T> get_shared_channels(const unsigned int v0, const unsigned int v1) const {

       const unsigned int beg = offset(0,0,0,v0), end = offset(0,0,0,v1);

       if (beg>end || beg>=size() || end>=size())

         throw CImgArgumentException("CImg<%s>::get_shared_channels() : Cannot return a shared-memory subset (0->%u,0->%u,0->%u,%u->%u) from "

                                     "a (%u,%u,%u,%u) image.",

                                     pixel_type(),width-1,height-1,depth-1,v0,v1,width,height,depth,dim);

       return CImg<T>(data+beg,width,height,depth,v1-v0+1,true);

     }


     CImg<T> get_shared_channel(const unsigned int v0) {

       return get_shared_channels(v0,v0);

     }


     const CImg<T> get_shared_channel(const unsigned int v0) const {

       return get_shared_channels(v0,v0);

     }


     CImgList<T> get_split(const char axis, const int nb=0) const {

       CImgList<T> res;

       const char naxis = cimg::uncase(axis);

       const unsigned int nnb = (unsigned int)(nb==0?1:(nb>0?nb:-nb));

       if (nb<=0) switch (naxis) { // Split by bloc size

       case 'x': {

         for (unsigned int p = 0; p<width; p+=nnb) get_crop(p,0,0,0,cimg::min(p+nnb-1,width-1),height-1,depth-1,dim-1).transfer_to(res);

       } break;

       case 'y': {

         for (unsigned int p = 0; p<height; p+=nnb) get_crop(0,p,0,0,width-1,cimg::min(p+nnb-1,height-1),depth-1,dim-1).transfer_to(res);

       } break;

       case 'z': {

         for (unsigned int p = 0; p<depth; p+=nnb) get_crop(0,0,p,0,width-1,height-1,cimg::min(p+nnb-1,depth-1),dim-1).transfer_to(res);

       } break;

       default: {

         for (unsigned int p = 0; p<dim; p+=nnb) get_crop(0,0,0,p,width-1,height-1,depth-1,cimg::min(p+nnb-1,dim-1)).transfer_to(res);

       }} else { // Split by number of blocs

         const unsigned int siz = naxis=='x'?width:naxis=='y'?height:naxis=='z'?depth:naxis=='v'?dim:0;

         if (nnb>siz) throw CImgArgumentException("CImg<%s>::get_split() : Cannot split instance image (%u,%u,%u,%u,%p) along axis '%c' into %u blocs.",

                                                 pixel_type(),width,height,depth,dim,data,axis,nnb);

         res.assign(nnb);

         switch (naxis) {

         case 'x' : {

           cimglist_for(res,p) get_crop(p*siz/nnb,0,0,0,(p+1)*siz/nnb-1,height-1,depth-1,dim-1).transfer_to(res[p]);

         } break;

         case 'y' : {

           cimglist_for(res,p) get_crop(0,p*siz/nnb,0,0,width-1,(p+1)*siz/nnb-1,depth-1,dim-1).transfer_to(res[p]);

         } break;

         case 'z' : {

           cimglist_for(res,p) get_crop(0,0,p*siz/nnb,0,width-1,height-1,(p+1)*siz/nnb-1,dim-1).transfer_to(res[p]);

         } break;

         default : {

           cimglist_for(res,p) get_crop(0,0,0,p*siz/nnb,width-1,height-1,depth-1,(p+1)*siz/nnb-1).transfer_to(res[p]);

         }

         }

       }

       return res;

     }


     // Split image into a list of vectors, according to a given splitting value.

     CImgList<T> get_split(const T value, const bool keep_values, const bool shared, const char axis='y') const {

       CImgList<T> res;

       const T *ptr0 = data, *const ptr_end = data + size();

       while (ptr0<ptr_end) {

         const T *ptr1 = ptr0;

         while (ptr1<ptr_end && *ptr1==value) ++ptr1;

         const unsigned int siz0 = ptr1 - ptr0;

         if (siz0 && keep_values) res.insert(CImg<T>(ptr0,1,siz0,1,1,shared));

         ptr0 = ptr1;

         while (ptr1<ptr_end && *ptr1!=value) ++ptr1;

         const unsigned int siz1 = ptr1 - ptr0;

         if (siz1) res.insert(CImg<T>(ptr0,1,siz1,1,1,shared),~0U,shared);

         ptr0 = ptr1;

       }

       cimglist_apply(res,unroll)(axis);

       return res;

     }


     template<typename t>

     CImg<T>& append(const CImg<t>& img, const char axis='x', const char align='p') {

       if (is_empty()) return assign(img,false);

       if (!img) return *this;

       return CImgList<T>(*this,img).get_append(axis,align).transfer_to(*this);

     }


     CImg<T>& append(const CImg<T>& img, const char axis='x', const char align='p') {

       if (is_empty()) return assign(img,false);

       if (!img) return *this;

       return CImgList<T>(*this,img,true).get_append(axis,align).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Tt> get_append(const CImg<T>& img, const char axis='x', const char align='p') const {

       if (is_empty()) return +img;

       if (!img) return +*this;

       return CImgList<_cimg_Tt>(*this,img).get_append(axis,align);

     }


     CImg<T> get_append(const CImg<T>& img, const char axis='x', const char align='p') const {

       if (is_empty()) return +img;

       if (!img) return +*this;

       return CImgList<T>(*this,img,true).get_append(axis,align);

     }


     //---------------------------------------

     //


     //---------------------------------------


     template<typename t>

     CImg<T>& correlate(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_correl=false) {

       return get_correlate(mask,cond,weighted_correl).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Ttfloat> get_correlate(const CImg<t>& mask, const unsigned int cond=1,

                                       const bool weighted_correl=false) const {

       if (is_empty()) return *this;

       if (!mask || mask.dim!=1)

         throw CImgArgumentException("CImg<%s>::correlate() : Specified mask (%u,%u,%u,%u,%p) is not scalar.",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);

       typedef _cimg_Ttfloat Ttfloat;

       CImg<Ttfloat> dest(width,height,depth,dim);

       if (cond && mask.width==mask.height && ((mask.depth==1 && mask.width<=5) || (mask.depth==mask.width && mask.width<=3))) {

         // A special optimization is done for 2x2, 3x3, 4x4, 5x5, 2x2x2 and 3x3x3 mask (with cond=1)

         switch (mask.depth) {

         case 3 : {

           T I[27] = { 0 };

           cimg_forZV(*this,z,v) cimg_for3x3x3(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

             (I[ 0]*mask[ 0] + I[ 1]*mask[ 1] + I[ 2]*mask[ 2] +

              I[ 3]*mask[ 3] + I[ 4]*mask[ 4] + I[ 5]*mask[ 5] +

              I[ 6]*mask[ 6] + I[ 7]*mask[ 7] + I[ 8]*mask[ 8] +

              I[ 9]*mask[ 9] + I[10]*mask[10] + I[11]*mask[11] +

              I[12]*mask[12] + I[13]*mask[13] + I[14]*mask[14] +

              I[15]*mask[15] + I[16]*mask[16] + I[17]*mask[17] +

              I[18]*mask[18] + I[19]*mask[19] + I[20]*mask[20] +

              I[21]*mask[21] + I[22]*mask[22] + I[23]*mask[23] +

              I[24]*mask[24] + I[25]*mask[25] + I[26]*mask[26]);

           if (weighted_correl) cimg_forZV(*this,z,v) cimg_for3x3x3(*this,x,y,z,v,I) {

             const double weight = (double)(I[ 0]*I[ 0] + I[ 1]*I[ 1] + I[ 2]*I[ 2] +

                                            I[ 3]*I[ 3] + I[ 4]*I[ 4] + I[ 5]*I[ 5] +

                                            I[ 6]*I[ 6] + I[ 7]*I[ 7] + I[ 8]*I[ 8] +

                                            I[ 9]*I[ 9] + I[10]*I[10] + I[11]*I[11] +

                                            I[12]*I[12] + I[13]*I[13] + I[14]*I[14] +

                                            I[15]*I[15] + I[16]*I[16] + I[17]*I[17] +

                                            I[18]*I[18] + I[19]*I[19] + I[20]*I[20] +

                                            I[21]*I[21] + I[22]*I[22] + I[23]*I[23] +

                                            I[24]*I[24] + I[25]*I[25] + I[26]*I[26]);

             if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

           }

         } break;

         case 2 : {

           T I[8] = { 0 };

           cimg_forZV(*this,z,v) cimg_for2x2x2(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

             (I[0]*mask[0] + I[1]*mask[1] +

              I[2]*mask[2] + I[3]*mask[3] +

              I[4]*mask[4] + I[5]*mask[5] +

              I[6]*mask[6] + I[7]*mask[7]);

           if (weighted_correl) cimg_forZV(*this,z,v) cimg_for2x2x2(*this,x,y,z,v,I) {

             const double weight = (double)(I[0]*I[0] + I[1]*I[1] +

                                            I[2]*I[2] + I[3]*I[3] +

                                            I[4]*I[4] + I[5]*I[5] +

                                            I[6]*I[6] + I[7]*I[7]);

             if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

           }

         } break;

         default :

         case 1 :

           switch (mask.width) {

           case 6 : {

             T I[36] = { 0 };

             cimg_forZV(*this,z,v) cimg_for6x6(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

               (I[ 0]*mask[ 0] + I[ 1]*mask[ 1] + I[ 2]*mask[ 2] + I[ 3]*mask[ 3] + I[ 4]*mask[ 4] + I[ 5]*mask[ 5] +

                I[ 6]*mask[ 6] + I[ 7]*mask[ 7] + I[ 8]*mask[ 8] + I[ 9]*mask[ 9] + I[10]*mask[10] + I[11]*mask[11] +

                I[12]*mask[12] + I[13]*mask[13] + I[14]*mask[14] + I[15]*mask[15] + I[16]*mask[16] + I[17]*mask[17] +

                I[18]*mask[18] + I[19]*mask[19] + I[20]*mask[20] + I[21]*mask[21] + I[22]*mask[22] + I[23]*mask[23] +

                I[24]*mask[24] + I[25]*mask[25] + I[26]*mask[26] + I[27]*mask[27] + I[28]*mask[28] + I[29]*mask[29] +

                I[30]*mask[30] + I[31]*mask[31] + I[32]*mask[32] + I[33]*mask[33] + I[34]*mask[34] + I[35]*mask[35]);

             if (weighted_correl) cimg_forZV(*this,z,v) cimg_for5x5(*this,x,y,z,v,I) {

               const double weight = (double)(I[ 0]*I[ 0] + I[ 1]*I[ 1] + I[ 2]*I[ 2] + I[ 3]*I[ 3] + I[ 4]*I[ 4] + I[ 5]*I[ 5] +

                                              I[ 6]*I[ 6] + I[ 7]*I[ 7] + I[ 8]*I[ 8] + I[ 9]*I[ 9] + I[10]*I[10] + I[11]*I[11] +

                                              I[12]*I[12] + I[13]*I[13] + I[14]*I[14] + I[15]*I[15] + I[16]*I[16] + I[17]*I[17] +

                                              I[18]*I[18] + I[19]*I[19] + I[20]*I[20] + I[21]*I[21] + I[22]*I[22] + I[23]*I[23] +

                                              I[24]*I[24] + I[25]*I[25] + I[26]*I[26] + I[27]*I[27] + I[28]*I[28] + I[29]*I[29] +

                                              I[30]*I[30] + I[31]*I[31] + I[32]*I[32] + I[33]*I[33] + I[34]*I[34] + I[35]*I[35]);

               if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

             }

           } break;

           case 5 : {

             T I[25] = { 0 };

             cimg_forZV(*this,z,v) cimg_for5x5(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

               (I[ 0]*mask[ 0] + I[ 1]*mask[ 1] + I[ 2]*mask[ 2] + I[ 3]*mask[ 3] + I[ 4]*mask[ 4] +

                I[ 5]*mask[ 5] + I[ 6]*mask[ 6] + I[ 7]*mask[ 7] + I[ 8]*mask[ 8] + I[ 9]*mask[ 9] +

                I[10]*mask[10] + I[11]*mask[11] + I[12]*mask[12] + I[13]*mask[13] + I[14]*mask[14] +

                I[15]*mask[15] + I[16]*mask[16] + I[17]*mask[17] + I[18]*mask[18] + I[19]*mask[19] +

                I[20]*mask[20] + I[21]*mask[21] + I[22]*mask[22] + I[23]*mask[23] + I[24]*mask[24]);

             if (weighted_correl) cimg_forZV(*this,z,v) cimg_for5x5(*this,x,y,z,v,I) {

               const double weight = (double)(I[ 0]*I[ 0] + I[ 1]*I[ 1] + I[ 2]*I[ 2] + I[ 3]*I[ 3] + I[ 4]*I[ 4] +

                                              I[ 5]*I[ 5] + I[ 6]*I[ 6] + I[ 7]*I[ 7] + I[ 8]*I[ 8] + I[ 9]*I[ 9] +

                                              I[10]*I[10] + I[11]*I[11] + I[12]*I[12] + I[13]*I[13] + I[14]*I[14] +

                                              I[15]*I[15] + I[16]*I[16] + I[17]*I[17] + I[18]*I[18] + I[19]*I[19] +

                                              I[20]*I[20] + I[21]*I[21] + I[22]*I[22] + I[23]*I[23] + I[24]*I[24]);

               if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

             }

           } break;

           case 4 : {

             T I[16] = { 0 };

             cimg_forZV(*this,z,v) cimg_for4x4(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

               (I[ 0]*mask[ 0] + I[ 1]*mask[ 1] + I[ 2]*mask[ 2] + I[ 3]*mask[ 3] +

                I[ 4]*mask[ 4] + I[ 5]*mask[ 5] + I[ 6]*mask[ 6] + I[ 7]*mask[ 7] +

                I[ 8]*mask[ 8] + I[ 9]*mask[ 9] + I[10]*mask[10] + I[11]*mask[11] +

                I[12]*mask[12] + I[13]*mask[13] + I[14]*mask[14] + I[15]*mask[15]);

             if (weighted_correl) cimg_forZV(*this,z,v) cimg_for4x4(*this,x,y,z,v,I) {

               const double weight = (double)(I[ 0]*I[ 0] + I[ 1]*I[ 1] + I[ 2]*I[ 2] + I[ 3]*I[ 3] +

                                              I[ 4]*I[ 4] + I[ 5]*I[ 5] + I[ 6]*I[ 6] + I[ 7]*I[ 7] +

                                              I[ 8]*I[ 8] + I[ 9]*I[ 9] + I[10]*I[10] + I[11]*I[11] +

                                              I[12]*I[12] + I[13]*I[13] + I[14]*I[14] + I[15]*I[15]);

               if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

             }

           } break;

           case 3 : {

             T I[9] = { 0 };

             cimg_forZV(*this,z,v) cimg_for3x3(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

               (I[0]*mask[0] + I[1]*mask[1] + I[2]*mask[2] +

                I[3]*mask[3] + I[4]*mask[4] + I[5]*mask[5] +

                I[6]*mask[6] + I[7]*mask[7] + I[8]*mask[8]);

             if (weighted_correl) cimg_forZV(*this,z,v) cimg_for3x3(*this,x,y,z,v,I) {

               const double weight = (double)(I[0]*I[0] + I[1]*I[1] + I[2]*I[2] +

                                              I[3]*I[3] + I[4]*I[4] + I[5]*I[5] +

                                              I[6]*I[6] + I[7]*I[7] + I[8]*I[8]);

               if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

             }

           } break;

           case 2 : {

             T I[4] = { 0 };

             cimg_forZV(*this,z,v) cimg_for2x2(*this,x,y,z,v,I) dest(x,y,z,v) = (Ttfloat)

               (I[0]*mask[0] + I[1]*mask[1] +

                I[2]*mask[2] + I[3]*mask[3]);

             if (weighted_correl) cimg_forZV(*this,z,v) cimg_for2x2(*this,x,y,z,v,I) {

               const double weight = (double)(I[0]*I[0] + I[1]*I[1] +

                                              I[2]*I[2] + I[3]*I[3]);

               if (weight>0) dest(x,y,z,v)/=(Ttfloat)std::sqrt(weight);

             }

           } break;

           case 1 : (dest.assign(*this))*=mask(0); break;

           }

         }

       } else { // Generic version for other masks

         const int

           mx2 = mask.dimx()/2, my2 = mask.dimy()/2, mz2 = mask.dimz()/2,

           mx1 = mx2 - 1 + (mask.dimx()%2), my1 = my2 - 1 + (mask.dimy()%2), mz1 = mz2 - 1 + (mask.dimz()%2),

           mxe = dimx() - mx2, mye = dimy() - my2, mze = dimz() - mz2;

         cimg_forV(*this,v)

           if (!weighted_correl) { // Classical correlation

             for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

               Ttfloat val = 0;

               for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm)

                 val+=(*this)(x+xm,y+ym,z+zm,v)*mask(mx1+xm,my1+ym,mz1+zm);

               dest(x,y,z,v) = (Ttfloat)val;

             }

             if (cond)

               cimg_forYZV(*this,y,z,v)

                 for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                   Ttfloat val = 0;

                   for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm)

                     val+=_atXYZ(x+xm,y+ym,z+zm,v)*mask(mx1+xm,my1+ym,mz1+zm);

                   dest(x,y,z,v) = (Ttfloat)val;

                 }

             else

               cimg_forYZV(*this,y,z,v)

                 for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                   Ttfloat val = 0;

                   for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm)

                     val+=atXYZ(x+xm,y+ym,z+zm,v,0)*mask(mx1+xm,my1+ym,mz1+zm);

                   dest(x,y,z,v) = (Ttfloat)val;

                 }

           } else { // Weighted correlation

             for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

               Ttfloat val = 0, weight = 0;

               for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                 const Ttfloat cval = (Ttfloat)(*this)(x+xm,y+ym,z+zm,v);

                 val+=cval*mask(mx1+xm,my1+ym,mz1+zm);

                 weight+=cval*cval;

               }

               dest(x,y,z,v) = (weight>(Ttfloat)0)?(Ttfloat)(val/std::sqrt((double)weight)):(Ttfloat)0;

             }

             if (cond)

               cimg_forYZV(*this,y,z,v)

                 for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                   Ttfloat val = 0, weight = 0;

                   for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                     const Ttfloat cval = (Ttfloat)_atXYZ(x+xm,y+ym,z+zm,v);

                     val+=cval*mask(mx1+xm,my1+ym,mz1+zm);

                     weight+=cval*cval;

                   }

                   dest(x,y,z,v) = (weight>(Ttfloat)0)?(Ttfloat)(val/std::sqrt((double)weight)):(Ttfloat)0;

                 }

             else

               cimg_forYZV(*this,y,z,v)

                 for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                   Ttfloat val = 0, weight = 0;

                   for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                     const Ttfloat cval = (Ttfloat)atXYZ(x+xm,y+ym,z+zm,v,0);

                     val+=cval*mask(mx1+xm,my1+ym,mz1+zm);

                     weight+=cval*cval;

                   }

                   dest(x,y,z,v) = (weight>(Ttfloat)0)?(Ttfloat)(val/std::sqrt((double)weight)):(Ttfloat)0;

                 }

           }

       }

       return dest;

     }


     template<typename t>

     CImg<T>& convolve(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_convol=false) {

       return get_convolve(mask,cond,weighted_convol).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Ttfloat> get_convolve(const CImg<t>& mask, const unsigned int cond=1,

                                      const bool weighted_convol=false) const {

       if (is_empty()) return *this;

       if (!mask || mask.dim!=1)

         throw CImgArgumentException("CImg<%s>::convolve() : Specified mask (%u,%u,%u,%u,%p) is not scalar.",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);

       return get_correlate(CImg<t>(mask.ptr(),mask.size(),1,1,1,true).get_mirror('x').resize(mask,-1),cond,weighted_convol);

     }


     template<typename t>

     CImg<T>& erode(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_erosion=false) {

       return get_erode(mask,cond,weighted_erosion).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Tt> get_erode(const CImg<t>& mask, const unsigned int cond=1,

                              const bool weighted_erosion=false) const {

       if (is_empty()) return *this;

       if (!mask || mask.dim!=1)

         throw CImgArgumentException("CImg<%s>::erode() : Specified mask (%u,%u,%u,%u,%p) is not a scalar image.",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);

       typedef _cimg_Tt Tt;

       CImg<Tt> dest(width,height,depth,dim);

       const int

         mx2 = mask.dimx()/2, my2 = mask.dimy()/2, mz2 = mask.dimz()/2,

         mx1 = mx2 - 1 + (mask.dimx()%2), my1 = my2 - 1 + (mask.dimy()%2), mz1 = mz2 - 1 + (mask.dimz()%2),

         mxe = dimx() - mx2, mye = dimy() - my2, mze = dimz() - mz2;

       cimg_forV(*this,v)

         if (!weighted_erosion) { // Classical erosion

           for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

             Tt min_val = cimg::type<Tt>::max();

             for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

               const Tt cval = (Tt)(*this)(x+xm,y+ym,z+zm,v);

               if (mask(mx1+xm,my1+ym,mz1+zm) && cval<min_val) min_val = cval;

             }

             dest(x,y,z,v) = min_val;

           }

           if (cond)

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt min_val = cimg::type<Tt>::max();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const T cval = (Tt)_atXYZ(x+xm,y+ym,z+zm,v);

                   if (mask(mx1+xm,my1+ym,mz1+zm) && cval<min_val) min_val = cval;

                 }

                 dest(x,y,z,v) = min_val;

               }

           else

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt min_val = cimg::type<Tt>::max();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const T cval = (Tt)atXYZ(x+xm,y+ym,z+zm,v,0);

                   if (mask(mx1+xm,my1+ym,mz1+zm) && cval<min_val) min_val = cval;

                 }

                 dest(x,y,z,v) = min_val;

               }

         } else { // Weighted erosion

           for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

             Tt min_val = cimg::type<Tt>::max();

             for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

               const t mval = mask(mx1+xm,my1+ym,mz1+zm);

               const Tt cval = (Tt)((*this)(x+xm,y+ym,z+zm,v) + mval);

               if (mval && cval<min_val) min_val = cval;

             }

             dest(x,y,z,v) = min_val;

           }

           if (cond)

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt min_val = cimg::type<Tt>::max();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const t mval = mask(mx1+xm,my1+ym,mz1+zm);

                   const Tt cval = (Tt)(_atXYZ(x+xm,y+ym,z+zm,v) + mval);

                   if (mval && cval<min_val) min_val = cval;

                 }

                 dest(x,y,z,v) = min_val;

               }

           else

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt min_val = cimg::type<Tt>::max();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const t mval = mask(mx1+xm,my1+ym,mz1+zm);

                   const Tt cval = (Tt)(atXYZ(x+xm,y+ym,z+zm,v,0) + mval);

                   if (mval && cval<min_val) min_val = cval;

                 }

                 dest(x,y,z,v) = min_val;

               }

         }

       return dest;

     }


     CImg<T>& erode(const unsigned int n, const unsigned int cond=1) {

       if (n<2) return *this;

       return get_erode(n,cond).transfer_to(*this);

     }


     CImg<T> get_erode(const unsigned int n, const unsigned int cond=1) const {

       static CImg<T> mask;

       if (n<2) return *this;

       if (mask.width!=n) mask.assign(n,n,1,1,1);

       const CImg<T> res = get_erode(mask,cond,false);

       if (n>20) mask.assign();

       return res;

     }


     template<typename t>

     CImg<T>& dilate(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_dilatation=false) {

       return get_dilate(mask,cond,weighted_dilatation).transfer_to(*this);

     }


     template<typename t>

     CImg<_cimg_Tt> get_dilate(const CImg<t>& mask, const unsigned int cond=1,

                               const bool weighted_dilatation=false) const {

       if (is_empty()) return *this;

       if (!mask || mask.dim!=1)

         throw CImgArgumentException("CImg<%s>::dilate() : Specified mask (%u,%u,%u,%u,%p) is not a scalar image.",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);

       typedef _cimg_Tt Tt;

       CImg<Tt> dest(width,height,depth,dim);

       const int

         mx2 = mask.dimx()/2, my2 = mask.dimy()/2, mz2 = mask.dimz()/2,

         mx1 = mx2 - 1 + (mask.dimx()%2), my1 = my2 - 1 + (mask.dimy()%2), mz1 = mz2 - 1 + (mask.dimz()%2),

         mxe = dimx() - mx2, mye = dimy() - my2, mze = dimz() - mz2;

       cimg_forV(*this,v)

         if (!weighted_dilatation) { // Classical dilatation

           for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

             Tt max_val = cimg::type<Tt>::min();

             for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

               const Tt cval = (Tt)(*this)(x+xm,y+ym,z+zm,v);

               if (mask(mx1+xm,my1+ym,mz1+zm) && cval>max_val) max_val = cval;

             }

             dest(x,y,z,v) = max_val;

           }

           if (cond)

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt max_val = cimg::type<Tt>::min();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const T cval = (Tt)_atXYZ(x+xm,y+ym,z+zm,v);

                   if (mask(mx1+xm,my1+ym,mz1+zm) && cval>max_val) max_val = cval;

                 }

                 dest(x,y,z,v) = max_val;

               }

           else

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt max_val = cimg::type<Tt>::min();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const T cval = (Tt)atXYZ(x+xm,y+ym,z+zm,v,0);

                   if (mask(mx1+xm,my1+ym,mz1+zm) && cval>max_val) max_val = cval;

                 }

                 dest(x,y,z,v) = max_val;

               }

         } else { // Weighted dilatation

           for (int z = mz1; z<mze; ++z) for (int y = my1; y<mye; ++y) for (int x = mx1; x<mxe; ++x) {

             Tt max_val = cimg::type<Tt>::min();

             for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

               const t mval = mask(mx1+xm,my1+ym,mz1+zm);

               const Tt cval = (Tt)((*this)(x+xm,y+ym,z+zm,v) - mval);

               if (mval && cval>max_val) max_val = cval;

             }

             dest(x,y,z,v) = max_val;

           }

           if (cond)

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt max_val = cimg::type<Tt>::min();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const t mval = mask(mx1+xm,my1+ym,mz1+zm);

                   const Tt cval = (Tt)(_atXYZ(x+xm,y+ym,z+zm,v) - mval);

                   if (mval && cval>max_val) max_val = cval;

                 }

                 dest(x,y,z,v) = max_val;

               }

           else

             cimg_forYZV(*this,y,z,v)

               for (int x = 0; x<dimx(); (y<my1 || y>=mye || z<mz1 || z>=mze)?++x:((x<mx1-1 || x>=mxe)?++x:(x=mxe))) {

                 Tt max_val = cimg::type<Tt>::min();

                 for (int zm = -mz1; zm<=mz2; ++zm) for (int ym = -my1; ym<=my2; ++ym) for (int xm = -mx1; xm<=mx2; ++xm) {

                   const t mval = mask(mx1+xm,my1+ym,mz1+zm);

                   const Tt cval = (Tt)(atXYZ(x+xm,y+ym,z+zm,v,0) - mval);

                   if (mval && cval>max_val) max_val = cval;

                 }

                 dest(x,y,z,v) = max_val;

               }

         }

       return dest;

     }


     CImg<T>& dilate(const unsigned int n, const unsigned int cond=1) {

       if (n<2) return *this;

       return get_dilate(n,cond).transfer_to(*this);

     }


     CImg<T> get_dilate(const unsigned int n, const unsigned int cond=1) const {

       static CImg<T> mask;

       if (n<2) return *this;

       if (mask.width!=n) mask.assign(n,n,1,1,1);

       const CImg<T> res = get_dilate(mask,cond,false);

       if (n>20) mask.assign();

       return res;

     }


     CImg<T>& deriche(const float sigma, const int order=0, const char axis='x', const bool cond=true) {

 #define _cimg_deriche2_apply \

   Tfloat *ptrY = Y.data, yb = 0, yp = 0; \

   T xp = (T)0; \

   if (cond) { xp = *ptrX; yb = yp = (Tfloat)(coefp*xp); } \

   for (int m = 0; m<N; ++m) { \

     const T xc = *ptrX; ptrX+=off; \

     const Tfloat yc = *(ptrY++) = (Tfloat)(a0*xc + a1*xp - b1*yp - b2*yb); \

     xp = xc; yb = yp; yp = yc; \

   } \

   T xn = (T)0, xa = (T)0; \

   Tfloat yn = 0, ya = 0; \

   if (cond) { xn = xa = *(ptrX-off); yn = ya = (Tfloat)coefn*xn; } \

   for (int n = N-1; n>=0; --n) { \

     const T xc = *(ptrX-=off); \

     const Tfloat yc = (Tfloat)(a2*xn + a3*xa - b1*yn - b2*ya); \

     xa = xn; xn = xc; ya = yn; yn = yc; \

     *ptrX = (T)(*(--ptrY)+yc); \

   }

       const char naxis = cimg::uncase(axis);

       const float nsigma = sigma>=0?sigma:-sigma*(naxis=='x'?width:naxis=='y'?height:naxis=='z'?depth:dim)/100;

       if (is_empty() || (nsigma<0.1 && !order)) return *this;

       const float

         nnsigma = nsigma<0.1f?0.1f:nsigma,

         alpha = 1.695f/nnsigma,

         ema = (float)std::exp(-alpha),

         ema2 = (float)std::exp(-2*alpha),

         b1 = -2*ema,

         b2 = ema2;

       float a0 = 0, a1 = 0, a2 = 0, a3 = 0, coefp = 0, coefn = 0;

       switch (order) {

       case 0 : {

         const float k = (1-ema)*(1-ema)/(1+2*alpha*ema-ema2);

         a0 = k;

         a1 = k*(alpha-1)*ema;

         a2 = k*(alpha+1)*ema;

         a3 = -k*ema2;

       } break;

       case 1 : {

         const float k = (1-ema)*(1-ema)/ema;

         a0 = k*ema;

         a1 = a3 = 0;

         a2 = -a0;

       } break;

       case 2 : {

         const float

           ea = (float)std::exp(-alpha),

           k = -(ema2-1)/(2*alpha*ema),

           kn = (-2*(-1+3*ea-3*ea*ea+ea*ea*ea)/(3*ea+1+3*ea*ea+ea*ea*ea));

         a0 = kn;

         a1 = -kn*(1+k*alpha)*ema;

         a2 = kn*(1-k*alpha)*ema;

         a3 = -kn*ema2;

       } break;

       default :

         throw CImgArgumentException("CImg<%s>::deriche() : Given filter order (order = %u) must be 0,1 or 2",

                                     pixel_type(),order);

       }

       coefp = (a0+a1)/(1+b1+b2);

       coefn = (a2+a3)/(1+b1+b2);

       switch (naxis) {

       case 'x' : {

         const int N = width, off = 1;

         CImg<Tfloat> Y(N);

         cimg_forYZV(*this,y,z,v) { T *ptrX = ptr(0,y,z,v); _cimg_deriche2_apply; }

       } break;

       case 'y' : {

         const int N = height, off = width;

         CImg<Tfloat> Y(N);

         cimg_forXZV(*this,x,z,v) { T *ptrX = ptr(x,0,z,v); _cimg_deriche2_apply; }

       } break;

       case 'z' : {

         const int N = depth, off = width*height;

         CImg<Tfloat> Y(N);

         cimg_forXYV(*this,x,y,v) { T *ptrX = ptr(x,y,0,v); _cimg_deriche2_apply; }

       } break;

       case 'v' : {

         const int N = dim, off = width*height*depth;

         CImg<Tfloat> Y(N);

         cimg_forXYZ(*this,x,y,z) { T *ptrX = ptr(x,y,z,0); _cimg_deriche2_apply; }

       } break;

       }

       return *this;

     }


     CImg<Tfloat> get_deriche(const float sigma, const int order=0, const char axis='x', const bool cond=true) const {

       return CImg<Tfloat>(*this,false).deriche(sigma,order,axis,cond);

     }


     CImg<T>& blur(const float sigmax, const float sigmay, const float sigmaz, const bool cond=true) {

       if (!is_empty()) {

         if (width>1)  deriche(sigmax,0,'x',cond);

         if (height>1) deriche(sigmay,0,'y',cond);

         if (depth>1)  deriche(sigmaz,0,'z',cond);

       }

       return *this;

     }


     CImg<Tfloat> get_blur(const float sigmax, const float sigmay, const float sigmaz, const bool cond=true) const {

       return CImg<Tfloat>(*this,false).blur(sigmax,sigmay,sigmaz,cond);

     }


     CImg<T>& blur(const float sigma, const bool cond=true) {

       const float nsigma = sigma>=0?sigma:-sigma*cimg::max(width,height,depth)/100;

       return blur(nsigma,nsigma,nsigma,cond);

     }


     CImg<Tfloat> get_blur(const float sigma, const bool cond=true) const {

       return CImg<Tfloat>(*this,false).blur(sigma,cond);

     }


     template<typename t>

     CImg<T>& blur_anisotropic(const CImg<t>& G,

                               const float amplitude=60, const float dl=0.8f, const float da=30,

                               const float gauss_prec=2, const unsigned int interpolation_type=0,

                               const unsigned int fast_approx=1) {


       // Check arguments and init variables

       if (is_empty() || amplitude<=0 || dl<0) return *this;

       if (!is_sameXYZ(G) || (G.dim!=3 && G.dim!=6))

         throw CImgArgumentException("CImg<%s>::blur_anisotropic() : Invalid diffusion tensor field (%u,%u,%u,%u,%p) "

                                     "for instance image (%u,%u,%u,%u,%p).",

                                     pixel_type(),G.width,G.height,G.depth,G.dim,G.data,width,height,depth,dim,data);

       const bool threed = G.dim==6;


       if (da<=0) {  // Iterated oriented Laplacians

         CImg<Tfloat> veloc(width,height,depth,dim);

         for (unsigned int iter = 0; iter<(unsigned int)amplitude; ++iter) {

           Tfloat *ptrd = veloc.fill(0).ptr(), betamax = 0;

           if (threed) { // 3D version

             CImg_3x3x3(I,T);

             cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

               const Tfloat

                 ixx = (Tfloat)(Incc + Ipcc - 2*Iccc),

                 iyy = (Tfloat)(Icnc + Icpc - 2*Iccc),

                 izz = (Tfloat)(Iccn + Iccp - 2*Iccc),

                 ixy = (Tfloat)(0.25f*(Innc + Ippc - Inpc - Ipnc)),

                 ixz = (Tfloat)(0.25f*(Incn + Ipcp - Incp - Ipcn)),

                 iyz = (Tfloat)(0.25f*(Icnn + Icpp - Icnp - Icpn)),

                 beta = (Tfloat)(G(x,y,z,0)*ixx + 2*G(x,y,z,1)*ixy + 2*G(x,y,z,2)*ixz + G(x,y,z,3)*iyy + 2*G(x,y,z,4)*iyz + G(x,y,z,5)*izz);

               *(ptrd++) = beta;

               betamax = beta>betamax?beta:(-beta>betamax?-beta:betamax);

             }

           } else { // 2D version

             CImg_3x3(I,T);

             Tfloat *ptrd = veloc.ptr();

             betamax = 0;

             if (G.dim==3) cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) { // Tensor field

               const Tfloat

                 ixx = (Tfloat)(Inc + Ipc - 2*Icc),

                 iyy = (Tfloat)(Icn + Icp - 2*Icc),

                 ixy = (Tfloat)(0.25f*(Inn + Ipp - Inp - Ipn)),

                 beta = (Tfloat)(G(x,y,0,0)*ixx + G(x,y,0,1)*ixy + G(x,y,0,2)*iyy);

               *(ptrd++) = beta;

               betamax = beta>betamax?beta:(-beta>betamax?-beta:betamax);

             }

           }

           if (betamax>0) (*this)+=(veloc*=dl/betamax);

         }

       } else { // LIC-based smoothing.

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

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


         const float sqrt2amplitude = (float)std::sqrt(2*amplitude);

         const int dx1 = dimx()-1, dy1 = dimy()-1, dz1 = dimz()-1;

         CImg<Tfloat> dest(width,height,depth,dim,0), W(width,height,depth,threed?4:3), tmp(dim);

         int N = 0;

         if (threed) { // 3D version

           for (float phi = (180%(int)da)/2.0f; phi<=180; phi+=da) {

             const float phir = (float)(phi*cimg::valuePI/180), datmp = (float)(da/std::cos(phir)), da2 = datmp<1?360.0f:datmp;

             for (float theta = 0; theta<360; (theta+=da2),++N) {

               const float

                 thetar = (float)(theta*cimg::valuePI/180),

                 vx = (float)(std::cos(thetar)*std::cos(phir)),

                 vy = (float)(std::sin(thetar)*std::cos(phir)),

                 vz = (float)std::sin(phir);

               const t

                 *pa = G.ptr(0,0,0,0), *pb = G.ptr(0,0,0,1), *pc = G.ptr(0,0,0,2),

                 *pd = G.ptr(0,0,0,3), *pe = G.ptr(0,0,0,4), *pf = G.ptr(0,0,0,5);

               Tfloat *pd0 = W.ptr(0,0,0,0), *pd1 = W.ptr(0,0,0,1), *pd2 = W.ptr(0,0,0,2), *pd3 = W.ptr(0,0,0,3);

               cimg_forXYZ(G,xg,yg,zg) {

                 const t a = *(pa++), b = *(pb++), c = *(pc++), d = *(pd++), e = *(pe++), f = *(pf++);

                 const float u = (float)(a*vx + b*vy + c*vz), v = (float)(b*vx + d*vy + e*vz), w = (float)(c*vx + e*vy + f*vz),

                   n = (float)std::sqrt(1e-5+u*u+v*v+w*w), dln = dl/n;

                 *(pd0++) = (Tfloat)(u*dln);

                 *(pd1++) = (Tfloat)(v*dln);

                 *(pd2++) = (Tfloat)(w*dln);

                 *(pd3++) = (Tfloat)n;

               }


               cimg_forXYZ(*this,x,y,z) {

                 tmp.fill(0);

                 const float cu = (float)W(x,y,z,0), cv = (float)W(x,y,z,1), cw = (float)W(x,y,z,2), n = (float)W(x,y,z,3),

                   fsigma = (float)(n*sqrt2amplitude), length = gauss_prec*fsigma, fsigma2 = 2*fsigma*fsigma;

                 float S = 0, pu = cu, pv = cv, pw = cw, X = (float)x, Y = (float)y, Z = (float)z;

                 switch (interpolation_type) {

                 case 0 : { // Nearest neighbor

                   for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1 && Z>=0 && Z<=dz1; l+=dl) {

                     const int cx = (int)(X+0.5f), cy = (int)(Y+0.5f), cz = (int)(Z+0.5f);

                     float u = (float)W(cx,cy,cz,0), v = (float)W(cx,cy,cz,1), w = (float)W(cx,cy,cz,2);

                     if ((pu*u + pv*v + pw*w)<0) { u=-u; v=-v; w=-w; }

                     if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)(*this)(cx,cy,cz,k); ++S; }

                     else {

                       const float coef = (float)std::exp(-l*l/fsigma2);

                       cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*(*this)(cx,cy,cz,k));

                       S+=coef;

                     }

                     X+=(pu=u); Y+=(pv=v); Z+=(pw=w);

                   }

                 } break;

                 case 1 : { // Linear interpolation

                   for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1 && Z>=0 && Z<=dz1; l+=dl) {

                     const int

                       cx = (int)X, px = (cx-1<0)?0:cx-1, nx = (cx+1>dx1)?dx1:cx+1,

                       cy = (int)Y, py = (cy-1<0)?0:cy-1, ny = (cy+1>dy1)?dy1:cy+1,

                       cz = (int)Z, pz = (cz-1<0)?0:cz-1, nz = (cz+1>dz1)?dz1:cz+1;

                     const float curru = (float)W(cx,cy,cz,0), currv = (float)W(cx,cy,cz,1), currw = (float)W(cx,cy,cz,2);

                     _cimg_valign3d(px,py,pz); _cimg_valign3d(cx,py,pz); _cimg_valign3d(nx,py,pz);

                     _cimg_valign3d(px,cy,pz); _cimg_valign3d(cx,cy,pz); _cimg_valign3d(nx,cy,pz);

                     _cimg_valign3d(px,ny,pz); _cimg_valign3d(cx,ny,pz); _cimg_valign3d(nx,ny,pz);

                     _cimg_valign3d(px,py,cz); _cimg_valign3d(cx,py,cz); _cimg_valign3d(nx,py,cz);

                     _cimg_valign3d(px,cy,cz);                           _cimg_valign3d(nx,cy,cz);

                     _cimg_valign3d(px,ny,cz); _cimg_valign3d(cx,ny,cz); _cimg_valign3d(nx,ny,cz);

                     _cimg_valign3d(px,py,nz); _cimg_valign3d(cx,py,nz); _cimg_valign3d(nx,py,nz);

                     _cimg_valign3d(px,cy,nz); _cimg_valign3d(cx,cy,nz); _cimg_valign3d(nx,cy,nz);

                     _cimg_valign3d(px,ny,nz); _cimg_valign3d(cx,ny,nz); _cimg_valign3d(nx,ny,nz);

                     float u = (float)(W._linear_atXYZ(X,Y,Z,0)), v = (float)(W._linear_atXYZ(X,Y,Z,1)), w = (float)(W._linear_atXYZ(X,Y,Z,2));

                     if ((pu*u + pv*v + pw*w)<0) { u=-u; v=-v; w=-w; }

                     if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)_linear_atXYZ(X,Y,Z,k); ++S; }

                     else {

                       const float coef = (float)std::exp(-l*l/fsigma2);

                       cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*_linear_atXYZ(X,Y,Z,k));

                       S+=coef;

                     }

                     X+=(pu=u); Y+=(pv=v); Z+=(pw=w);

                   }

                 } break;

                 default : { // 2nd order Runge Kutta

                   for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1 && Z>=0 && Z<=dz1; l+=dl) {

                     const int

                       cx = (int)X, px = (cx-1<0)?0:cx-1, nx = (cx+1>dx1)?dx1:cx+1,

                       cy = (int)Y, py = (cy-1<0)?0:cy-1, ny = (cy+1>dy1)?dy1:cy+1,

                       cz = (int)Z, pz = (cz-1<0)?0:cz-1, nz = (cz+1>dz1)?dz1:cz+1;

                     const float curru = (float)W(cx,cy,cz,0), currv = (float)W(cx,cy,cz,1), currw = (float)W(cx,cy,cz,2);

                     _cimg_valign3d(px,py,pz); _cimg_valign3d(cx,py,pz); _cimg_valign3d(nx,py,pz);

                     _cimg_valign3d(px,cy,pz); _cimg_valign3d(cx,cy,pz); _cimg_valign3d(nx,cy,pz);

                     _cimg_valign3d(px,ny,pz); _cimg_valign3d(cx,ny,pz); _cimg_valign3d(nx,ny,pz);

                     _cimg_valign3d(px,py,cz); _cimg_valign3d(cx,py,cz); _cimg_valign3d(nx,py,cz);

                     _cimg_valign3d(px,cy,cz);                           _cimg_valign3d(nx,cy,cz);

                     _cimg_valign3d(px,ny,cz); _cimg_valign3d(cx,ny,cz); _cimg_valign3d(nx,ny,cz);

                     _cimg_valign3d(px,py,nz); _cimg_valign3d(cx,py,nz); _cimg_valign3d(nx,py,nz);

                     _cimg_valign3d(px,cy,nz); _cimg_valign3d(cx,cy,nz); _cimg_valign3d(nx,cy,nz);

                     _cimg_valign3d(px,ny,nz); _cimg_valign3d(cx,ny,nz); _cimg_valign3d(nx,ny,nz);

                     const float

                       u0 = (float)(0.5f*W._linear_atXYZ(X,Y,Z,0)),

                       v0 = (float)(0.5f*W._linear_atXYZ(X,Y,Z,1)),

                       w0 = (float)(0.5f*W._linear_atXYZ(X,Y,Z,2));

                     float

                       u = (float)(W._linear_atXYZ(X+u0,Y+v0,Z+w0,0)),

                       v = (float)(W._linear_atXYZ(X+u0,Y+v0,Z+w0,1)),

                       w = (float)(W._linear_atXYZ(X+u0,Y+v0,Z+w0,2));

                     if ((pu*u + pv*v + pw*w)<0) { u=-u; v=-v; w=-w; }

                     if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)_linear_atXYZ(X,Y,Z,k); ++S; }

                     else {

                       const float coef = (float)std::exp(-l*l/fsigma2);

                       cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*_linear_atXYZ(X,Y,Z,k));

                       S+=coef;

                     }

                     X+=(pu=u); Y+=(pv=v); Z+=(pw=w);

                   }

                 } break;

                 }

                 if (S>0) cimg_forV(dest,k) dest(x,y,z,k)+=tmp[k]/S;

                 else cimg_forV(dest,k) dest(x,y,z,k)+=(Tfloat)((*this)(x,y,z,k));

               }

             }

           }

         } else { // 2D LIC algorithm

           for (float theta = (360%(int)da)/2.0f; theta<360; (theta+=da),++N) {

             const float thetar = (float)(theta*cimg::valuePI/180), vx = (float)(std::cos(thetar)), vy = (float)(std::sin(thetar));

             const t *pa = G.ptr(0,0,0,0), *pb = G.ptr(0,0,0,1), *pc = G.ptr(0,0,0,2);

             Tfloat *pd0 = W.ptr(0,0,0,0), *pd1 = W.ptr(0,0,0,1), *pd2 = W.ptr(0,0,0,2);

             cimg_forXY(G,xg,yg) {

               const t a = *(pa++), b = *(pb++), c = *(pc++);

               const float u = (float)(a*vx + b*vy), v = (float)(b*vx + c*vy), n = (float)std::sqrt(1e-5+u*u+v*v), dln = dl/n;

               *(pd0++) = (Tfloat)(u*dln);

               *(pd1++) = (Tfloat)(v*dln);

               *(pd2++) = (Tfloat)n;

             }

             cimg_forXY(*this,x,y) {

               tmp.fill(0);

               const float

                 cu = (float)W(x,y,0,0), cv = (float)W(x,y,0,1), n = (float)W(x,y,0,2),

                 fsigma = (float)(n*sqrt2amplitude), length = gauss_prec*fsigma, fsigma2 = 2*fsigma*fsigma;

               float S = 0, pu = cu, pv = cv, X = (float)x, Y = (float)y;


               switch (interpolation_type) {

               case 0 : { // Nearest-neighbor

                 for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1; l+=dl) {

                   const int cx = (int)(X+0.5f), cy = (int)(Y+0.5f);

                   float u = (float)W(cx,cy,0,0), v = (float)W(cx,cy,0,1);

                   if ((pu*u + pv*v)<0) { u=-u; v=-v; }

                   if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)(*this)(cx,cy,0,k); ++S; }

                   else {

                     const float coef = (float)std::exp(-l*l/fsigma2);

                     cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*(*this)(cx,cy,0,k));

                     S+=coef;

                   }

                   X+=(pu=u); Y+=(pv=v);

                 }

               } break;

               case 1 : { // Linear interpolation

                 for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1; l+=dl) {

                   const int

                     cx = (int)X, px = (cx-1<0)?0:cx-1, nx = (cx+1>dx1)?dx1:cx+1,

                     cy = (int)Y, py = (cy-1<0)?0:cy-1, ny = (cy+1>dy1)?dy1:cy+1;

                   const float curru = (float)W(cx,cy,0,0), currv = (float)W(cx,cy,0,1);

                   _cimg_valign2d(px,py); _cimg_valign2d(cx,py); _cimg_valign2d(nx,py);

                   _cimg_valign2d(px,cy);                        _cimg_valign2d(nx,cy);

                   _cimg_valign2d(px,ny); _cimg_valign2d(cx,ny); _cimg_valign2d(nx,ny);

                   float u = (float)(W._linear_atXY(X,Y,0,0)), v = (float)(W._linear_atXY(X,Y,0,1));

                   if ((pu*u + pv*v)<0) { u=-u; v=-v; }

                   if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)_linear_atXY(X,Y,0,k); ++S; }

                   else {

                     const float coef = (float)std::exp(-l*l/fsigma2);

                     cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*_linear_atXY(X,Y,0,k));

                     S+=coef;

                   }

                   X+=(pu=u); Y+=(pv=v);

                 }

               } break;

               default : { // 2nd-order Runge-kutta interpolation

                 for (float l = 0; l<length && X>=0 && X<=dx1 && Y>=0 && Y<=dy1; l+=dl) {

                   const int

                     cx = (int)X, px = (cx-1<0)?0:cx-1, nx = (cx+1>dx1)?dx1:cx+1,

                     cy = (int)Y, py = (cy-1<0)?0:cy-1, ny = (cy+1>dy1)?dy1:cy+1;

                   const float curru = (float)W(cx,cy,0,0), currv = (float)W(cx,cy,0,1);

                   _cimg_valign2d(px,py); _cimg_valign2d(cx,py); _cimg_valign2d(nx,py);

                   _cimg_valign2d(px,cy);                        _cimg_valign2d(nx,cy);

                   _cimg_valign2d(px,ny); _cimg_valign2d(cx,ny); _cimg_valign2d(nx,ny);

                   const float u0 = (float)(0.5f*W._linear_atXY(X,Y,0,0)), v0 = (float)(0.5f*W._linear_atXY(X,Y,0,1));

                   float u = (float)(W._linear_atXY(X+u0,Y+v0,0,0)), v = (float)(W._linear_atXY(X+u0,Y+v0,0,1));

                   if ((pu*u + pv*v)<0) { u=-u; v=-v; }

                   if (fast_approx) { cimg_forV(*this,k) tmp[k]+=(Tfloat)_linear_atXY(X,Y,0,k); ++S; }

                   else {

                     const float coef = (float)std::exp(-l*l/fsigma2);

                     cimg_forV(*this,k) tmp[k]+=(Tfloat)(coef*_linear_atXY(X,Y,0,k));

                     S+=coef;

                   }

                   X+=(pu=u); Y+=(pv=v);

                 }

               }

               }

               if (S>0) cimg_forV(dest,k) dest(x,y,0,k)+=tmp[k]/S;

               else cimg_forV(dest,k) dest(x,y,0,k)+=(Tfloat)((*this)(x,y,0,k));

             }

           }

         }

         const Tfloat *ptrs = dest.data + dest.size();

         const T m = cimg::type<T>::min(), M = cimg::type<T>::max();

         cimg_for(*this,ptrd,T) { const Tfloat val = *(--ptrs)/N; *ptrd = val<m?m:(val>M?M:(T)val); }

       }

       return *this;

     }


     template<typename t>

     CImg<T> get_blur_anisotropic(const CImg<t>& G,

                                  const float amplitude=60, const float dl=0.8f, const float da=30,

                                  const float gauss_prec=2, const unsigned int interpolation_type=0,

                                  const unsigned int fast_approx=1) const {

       return (+*this).blur_anisotropic(G,amplitude,dl,da,gauss_prec,interpolation_type,fast_approx);

     }


     CImg<T>& blur_anisotropic(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,

                               const float gauss_prec=2, const unsigned int interpolation_type=0,

                               const unsigned int fast_approx=1) {

       return blur_anisotropic(get_edge_tensors(sharpness,anisotropy,alpha,sigma,interpolation_type!=3),

                               amplitude,dl,da,gauss_prec,interpolation_type,fast_approx);

     }


     CImg<T> get_blur_anisotropic(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, const float gauss_prec=2, const unsigned int interpolation_type=0,

                                  const unsigned int fast_approx=1) const {

       return (+*this).blur_anisotropic(amplitude,sharpness,anisotropy,alpha,sigma,dl,da,gauss_prec,interpolation_type,fast_approx);

     }


     CImg<T>& blur_bilateral(const float sigma_x, const float sigma_y, const float sigma_z, const float sigma_r,

                             const int bgrid_x, const int bgrid_y, const int bgrid_z, const int bgrid_r,

                             const bool interpolation_type=true) {

       if (is_empty()) return *this;

       T m, M = maxmin(m);

       const float range = (float)(1.0f+M-m);

       const unsigned int

         bx0 = bgrid_x>=0?bgrid_x:width*(-bgrid_x)/100,

         by0 = bgrid_y>=0?bgrid_y:height*(-bgrid_y)/100,

         bz0 = bgrid_z>=0?bgrid_z:depth*(-bgrid_z)/100,

         br0 = bgrid_r>=0?bgrid_r:(int)(-range*bgrid_r/100),

         bx = bx0>0?bx0:1,

         by = by0>0?by0:1,

         bz = bz0>0?bz0:1,

         br = br0>0?br0:1;

       const float

         _sigma_x = sigma_x>=0?sigma_x:-sigma_x*width/100,

         _sigma_y = sigma_y>=0?sigma_y:-sigma_y*height/100,

         _sigma_z = sigma_z>=0?sigma_z:-sigma_z*depth/100,

         nsigma_x = _sigma_x*bx/width,

         nsigma_y = _sigma_y*by/height,

         nsigma_z = _sigma_z*bz/depth,

         nsigma_r = sigma_r*br/range;

       if (nsigma_x>0 || nsigma_y>0 || nsigma_z>0 || nsigma_r>0) {

         const bool threed = depth>1;

         if (threed) { // 3d version of the algorithm

           CImg<floatT> bgrid(bx,by,bz,br), bgridw(bx,by,bz,br);

           cimg_forV(*this,k) {

             bgrid.fill(0); bgridw.fill(0);

             cimg_forXYZ(*this,x,y,z) {

               const T val = (*this)(x,y,z,k);

               const int X = x*bx/width, Y = y*by/height, Z = z*bz/depth, R = (int)((val-m)*br/range);

               bgrid(X,Y,Z,R) = (float)val;

               bgridw(X,Y,Z,R) = 1;

             }

             bgrid.blur(nsigma_x,nsigma_y,nsigma_z,true).deriche(nsigma_r,0,'v',false);

             bgridw.blur(nsigma_x,nsigma_y,nsigma_z,true).deriche(nsigma_r,0,'v',false);

             if (interpolation_type) cimg_forXYZ(*this,x,y,z) {

               const T val = (*this)(x,y,z,k);

               const float X = (float)x*bx/width, Y = (float)y*by/height, Z = (float)z*bz/depth, R = (float)((val-m)*br/range),

                 bval0 = bgrid._linear_atXYZV(X,Y,Z,R), bval1 = bgridw._linear_atXYZV(X,Y,Z,R);

               (*this)(x,y,z,k) = (T)(bval0/bval1);

             } else cimg_forXYZ(*this,x,y,z) {

               const T val = (*this)(x,y,z,k);

               const int X = x*bx/width, Y = y*by/height, Z = z*bz/depth, R = (int)((val-m)*br/range);

               const float bval0 = bgrid(X,Y,Z,R), bval1 = bgridw(X,Y,Z,R);

               (*this)(x,y,z,k) = (T)(bval0/bval1);

             }

           }

         } else { // 2d version of the algorithm

           CImg<floatT> bgrid(bx,by,br,2);

           cimg_forV(*this,k) {

             bgrid.fill(0);

             cimg_forXY(*this,x,y) {

               const T val = (*this)(x,y,k);

               const int X = x*bx/width, Y = y*by/height, R = (int)((val-m)*br/range);

               bgrid(X,Y,R,0) = (float)val;

               bgrid(X,Y,R,1) = 1;

             }

             bgrid.blur(nsigma_x,nsigma_y,0,true).blur(0,0,nsigma_r,false);

             if (interpolation_type) cimg_forXY(*this,x,y) {

               const T val = (*this)(x,y,k);

               const float X = (float)x*bx/width, Y = (float)y*by/height, R = (float)((val-m)*br/range),

                 bval0 = bgrid._linear_atXYZ(X,Y,R,0), bval1 = bgrid._linear_atXYZ(X,Y,R,1);

               (*this)(x,y,k) = (T)(bval0/bval1);

             } else cimg_forXY(*this,x,y) {

               const T val = (*this)(x,y,k);

               const int X = x*bx/width, Y = y*by/height, R = (int)((val-m)*br/range);

               const float bval0 = bgrid(X,Y,R,0), bval1 = bgrid(X,Y,R,1);

               (*this)(x,y,k) = (T)(bval0/bval1);

             }

           }

         }

       }

       return *this;

     }


     CImg<T> get_blur_bilateral(const float sigma_x, const float sigma_y, const float sigma_z, const float sigma_r,

                                const int bgrid_x, const int bgrid_y, const int bgrid_z, const int bgrid_r,

                                const bool interpolation_type=true) const {

       return (+*this).blur_bilateral(sigma_x,sigma_y,sigma_z,sigma_r,bgrid_x,bgrid_y,bgrid_z,bgrid_r,interpolation_type);

     }


     CImg<T>& blur_bilateral(const float sigma_s, const float sigma_r, const int bgrid_s=-33, const int bgrid_r=32,

                             const bool interpolation_type=true) {

       const float nsigma_s = sigma_s>=0?sigma_s:-sigma_s*cimg::max(width,height,depth)/100;

       return blur_bilateral(nsigma_s,nsigma_s,nsigma_s,sigma_r,bgrid_s,bgrid_s,bgrid_s,bgrid_r,interpolation_type);

     }


     CImg<T> get_blur_bilateral(const float sigma_s, const float sigma_r, const int bgrid_s=-33, const int bgrid_r=32,

                                const bool interpolation_type=true) const {

       return (+*this).blur_bilateral(sigma_s,sigma_s,sigma_s,sigma_r,bgrid_s,bgrid_s,bgrid_s,bgrid_r,interpolation_type);

     }


     CImg<T>& blur_patch(const float sigma_s, const float sigma_p, const unsigned int patch_size=3,

                         const unsigned int lookup_size=4, const float smoothness=0, const bool fast_approx=true) {

       return get_blur_patch(sigma_s,sigma_p,patch_size,lookup_size,smoothness,fast_approx).transfer_to(*this);

     }


     CImg<T> get_blur_patch(const float sigma_s, const float sigma_p, const unsigned int patch_size=3,

                            const unsigned int lookup_size=4, const float smoothness=0, const bool fast_approx=true) const {


 #define _cimg_blur_patch3d_fast(N) \

       cimg_for##N##XYZ(res,x,y,z) { \

         cimg_forV(res,k) cimg_get##N##x##N##x##N(img,x,y,z,k,P.ptr(N3*k)); \

         const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2; \

         float sum_weights = 0; \

         cimg_for_in##N##XYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) if (cimg::abs(img(x,y,z,0)-img(p,q,r,0))<sigma_p3) { \

           cimg_forV(res,k) cimg_get##N##x##N##x##N(img,p,q,r,k,Q.ptr(N3*k)); \

           float distance2 = 0; \

           const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP - (float)*(--pQ); distance2+=dI*dI; } \

           distance2/=Pnorm; \

           const float dx = (float)p - x, dy = (float)q - y, dz = (float)r - z, \

             alldist = distance2 + (dx*dx + dy*dy + dz*dz)/sigma_s2, weight = alldist>3?0.0f:1.0f; \

           sum_weights+=weight; \

           cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k); \

         } \

         if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights; \

         else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k)); \

     }


 #define _cimg_blur_patch3d(N) \

       cimg_for##N##XYZ(res,x,y,z) { \

         cimg_forV(res,k) cimg_get##N##x##N##x##N(img,x,y,z,k,P.ptr(N3*k)); \

         const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2; \

         float sum_weights = 0; \

         cimg_for_in##N##XYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) { \

           cimg_forV(res,k) cimg_get##N##x##N##x##N(img,p,q,r,k,Q.ptr(N3*k)); \

           float distance2 = 0; \

           const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP - (float)*(--pQ); distance2+=dI*dI; } \

           distance2/=Pnorm; \

           const float dx = (float)p - x, dy = (float)q - y, dz = (float)r - z, \

             alldist = distance2 + (dx*dx + dy*dy + dz*dz)/sigma_s2, weight = (float)std::exp(-alldist); \

           sum_weights+=weight; \

           cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k); \

         } \

         if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights; \

         else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k)); \

       }


 #define _cimg_blur_patch2d_fast(N) \

         cimg_for##N##XY(res,x,y) { \

           cimg_forV(res,k) cimg_get##N##x##N(img,x,y,0,k,P.ptr(N2*k)); \

           const int x0 = x-rsize1, y0 = y-rsize1, x1 = x+rsize2, y1 = y+rsize2; \

           float sum_weights = 0; \

           cimg_for_in##N##XY(res,x0,y0,x1,y1,p,q) if (cimg::abs(img(x,y,0,0)-img(p,q,0,0))<sigma_p3) { \

             cimg_forV(res,k) cimg_get##N##x##N(img,p,q,0,k,Q.ptr(N2*k)); \

             float distance2 = 0; \

             const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP-(float)*(--pQ); distance2+=dI*dI; } \

             distance2/=Pnorm; \

             const float dx = (float)p-x, dy = (float)q-y, \

               alldist = distance2 + (dx*dx+dy*dy)/sigma_s2, weight = alldist>3?0.0f:1.0f; \

             sum_weights+=weight; \

             cimg_forV(res,k) res(x,y,k)+=weight*(*this)(p,q,k); \

           } \

           if (sum_weights>0) cimg_forV(res,k) res(x,y,k)/=sum_weights; \

           else cimg_forV(res,k) res(x,y,k) = (Tfloat)((*this)(x,y,k)); \

         }


 #define _cimg_blur_patch2d(N) \

         cimg_for##N##XY(res,x,y) { \

           cimg_forV(res,k) cimg_get##N##x##N(img,x,y,0,k,P.ptr(N2*k)); \

           const int x0 = x-rsize1, y0 = y-rsize1, x1 = x+rsize2, y1 = y+rsize2; \

           float sum_weights = 0; \

           cimg_for_in##N##XY(res,x0,y0,x1,y1,p,q) { \

             cimg_forV(res,k) cimg_get##N##x##N(img,p,q,0,k,Q.ptr(N2*k)); \

             float distance2 = 0; \

             const T *pQ = Q.end(); cimg_for(P,pP,T) { const float dI = (float)*pP-(float)*(--pQ); distance2+=dI*dI; } \

             distance2/=Pnorm; \

             const float dx = (float)p-x, dy = (float)q-y, \

               alldist = distance2 + (dx*dx+dy*dy)/sigma_s2, weight = (float)std::exp(-alldist); \

             sum_weights+=weight; \

             cimg_forV(res,k) res(x,y,k)+=weight*(*this)(p,q,k); \

           } \

           if (sum_weights>0) cimg_forV(res,k) res(x,y,k)/=sum_weights; \

           else cimg_forV(res,k) res(x,y,k) = (Tfloat)((*this)(x,y,k)); \

     }


       CImg<Tfloat> res(width,height,depth,dim,0);

       const CImg<T> _img = smoothness>0?get_blur(smoothness):CImg<Tfloat>(),&img = smoothness>0?_img:*this;

       CImg<T> P(patch_size*patch_size*dim), Q(P);

       const float

         nsigma_s = sigma_s>=0?sigma_s:-sigma_s*cimg::max(width,height,depth)/100,

         sigma_s2 = nsigma_s*nsigma_s, sigma_p2 = sigma_p*sigma_p, sigma_p3 = 3*sigma_p,

         Pnorm = P.size()*sigma_p2;

       const int rsize2 = (int)lookup_size/2, rsize1 = rsize2-1+(lookup_size%2);

       const unsigned int N2 = patch_size*patch_size, N3 = N2*patch_size;

       if (depth>1) switch (patch_size) { // 3D version

         case 2 : if (fast_approx) _cimg_blur_patch3d_fast(2) else _cimg_blur_patch3d(2) break;

         case 3 : if (fast_approx) _cimg_blur_patch3d_fast(3) else _cimg_blur_patch3d(3) break;

         default : {

           const int psize1 = (int)patch_size/2, psize0 = psize1-1+(patch_size%2);

           if (fast_approx) cimg_forXYZ(res,x,y,z) { // 3D fast approximation.

               P = img.get_crop(x - psize0,y - psize0,z - psize0,x + psize1,y + psize1,z + psize1,true);

               const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2;

               float sum_weights = 0;

               cimg_for_inXYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) if (cimg::abs(img(x,y,z,0)-img(p,q,r,0))<sigma_p3) {

                 (Q = img.get_crop(p - psize0,q - psize0,r - psize0,p + psize1,q + psize1,r + psize1,true))-=P;

                 const float

                   dx = (float)x - p, dy = (float)y - q, dz = (float)z - r,

                   distance2 = (float)(Q.pow(2).sum()/Pnorm + (dx*dx + dy*dy + dz*dz)/sigma_s2),

                   weight = distance2>3?0.0f:1.0f;

                 sum_weights+=weight;

                 cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k);

               }

               if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights;

               else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k));

             } else cimg_forXYZ(res,x,y,z) { // 3D exact algorithm.

               P = img.get_crop(x - psize0,y - psize0,z - psize0,x + psize1,y + psize1,z + psize1,true);

               const int x0 = x - rsize1, y0 = y - rsize1, z0 = z - rsize1, x1 = x + rsize2, y1 = y + rsize2, z1 = z + rsize2;

               float sum_weights = 0;

               cimg_for_inXYZ(res,x0,y0,z0,x1,y1,z1,p,q,r) {

                 (Q = img.get_crop(p - psize0,q - psize0,r - psize0,p + psize1,q + psize1,r + psize1,true))-=P;

                 const float

                   dx = (float)x - p, dy = (float)y - q, dz = (float)z - r,

                   distance2 = (float)(Q.pow(2).sum()/Pnorm + (dx*dx + dy*dy + dz*dz)/sigma_s2),

                   weight = (float)std::exp(-distance2);

                 sum_weights+=weight;

                 cimg_forV(res,k) res(x,y,z,k)+=weight*(*this)(p,q,r,k);

               }

               if (sum_weights>0) cimg_forV(res,k) res(x,y,z,k)/=sum_weights;

               else cimg_forV(res,k) res(x,y,z,k) = (Tfloat)((*this)(x,y,z,k));

             }

         }

         } else switch (patch_size) { // 2D version

         case 2 : if (fast_approx) _cimg_blur_patch2d_fast(2) else _cimg_blur_patch2d(2) break;

         case 3 : if (fast_approx) _cimg_blur_patch2d_fast(3) else _cimg_blur_patch2d(3) break;

         case 4 : if (fast_approx) _cimg_blur_patch2d_fast(4) else _cimg_blur_patch2d(4) break;

         case 5 : if (fast_approx) _cimg_blur_patch2d_fast(5) else _cimg_blur_patch2d(5) break;

         case 6 : if (fast_approx) _cimg_blur_patch2d_fast(6) else _cimg_blur_patch2d(6) break;

         case 7 : if (fast_approx) _cimg_blur_patch2d_fast(7) else _cimg_blur_patch2d(7) break;

         case 8 : if (fast_approx) _cimg_blur_patch2d_fast(8) else _cimg_blur_patch2d(8) break;

         case 9 : if (fast_approx) _cimg_blur_patch2d_fast(9) else _cimg_blur_patch2d(9) break;

         default : {

           const int psize1 = (int)patch_size/2, psize0 = psize1-1+(patch_size%2);

           if (fast_approx) cimg_forXY(res,x,y) { // 2D fast approximation.

               P = img.get_crop(x - psize0,y - psize0,x + psize1,y + psize1,true);

               const int x0 = x - rsize1, y0 = y - rsize1, x1 = x + rsize2, y1 = y + rsize2;

               float sum_weights = 0;

               cimg_for_inXY(res,x0,y0,x1,y1,p,q) if (cimg::abs(img(x,y,0,0)-img(p,q,0,0))<sigma_p3) {

                 (Q = img.get_crop(p - psize0,q - psize0,p + psize1,q + psize1,true))-=P;

                 const float

                   dx = (float)x - p, dy = (float)y - q,

                   distance2 = (float)(Q.pow(2).sum()/Pnorm + (dx*dx + dy*dy)/sigma_s2),

                   weight = distance2>3?0.0f:1.0f;

                 sum_weights+=weight;

                 cimg_forV(res,k) res(x,y,0,k)+=weight*(*this)(p,q,0,k);

               }

               if (sum_weights>0) cimg_forV(res,k) res(x,y,0,k)/=sum_weights;

               else cimg_forV(res,k) res(x,y,0,k) = (Tfloat)((*this)(x,y,0,k));

             } else cimg_forXY(res,x,y) { // 2D exact algorithm.

               P = img.get_crop(x - psize0,y - psize0,x + psize1,y + psize1,true);

               const int x0 = x - rsize1, y0 = y - rsize1, x1 = x + rsize2, y1 = y + rsize2;

               float sum_weights = 0;

               cimg_for_inXY(res,x0,y0,x1,y1,p,q) {

                 (Q = img.get_crop(p - psize0,q - psize0,p + psize1,q + psize1,true))-=P;

                 const float

                   dx = (float)x - p, dy = (float)y - q,

                   distance2 = (float)(Q.pow(2).sum()/Pnorm + (dx*dx + dy*dy)/sigma_s2),

                   weight = (float)std::exp(-distance2);

                 sum_weights+=weight;

                 cimg_forV(res,k) res(x,y,0,k)+=weight*(*this)(p,q,0,k);

               }

               if (sum_weights>0) cimg_forV(res,k) res(x,y,0,k)/=sum_weights;

               else cimg_forV(res,k) res(x,y,0,k) = (Tfloat)((*this)(x,y,0,k));

             }

         }

         }

       return res;

     }


     CImg<T>& blur_median(const unsigned int n) {

       return get_blur_median(n).transfer_to(*this);

     }


     CImg<T> get_blur_median(const unsigned int n) const {

       CImg<T> res(width,height,depth,dim);

       if (!n || n==1) return *this;

       const int hl=n/2, hr=hl-1+n%2;

       if (res.depth!=1) {  // 3D median filter

         CImg<T> vois;

         cimg_forXYZV(*this,x,y,z,k) {

           const int

             x0 = x - hl, y0 = y - hl, z0 = z-hl, x1 = x + hr, y1 = y + hr, z1 = z+hr,

             nx0 = x0<0?0:x0, ny0 = y0<0?0:y0, nz0 = z0<0?0:z0,

             nx1 = x1>=dimx()?dimx()-1:x1, ny1 = y1>=dimy()?dimy()-1:y1, nz1 = z1>=dimz()?dimz()-1:z1;

           vois = get_crop(nx0,ny0,nz0,k,nx1,ny1,nz1,k);

           res(x,y,z,k) = vois.median();

         }

       } else {

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

         if (res.height!=1) switch (n) { // 2D median filter

         case 3 : {

           T I[9] = { 0 };

           CImg_3x3(J,T);

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             std::memcpy(J,I,9*sizeof(T));

             _cimg_median_sort(Jcp, Jnp); _cimg_median_sort(Jcc, Jnc); _cimg_median_sort(Jcn, Jnn);

             _cimg_median_sort(Jpp, Jcp); _cimg_median_sort(Jpc, Jcc); _cimg_median_sort(Jpn, Jcn);

             _cimg_median_sort(Jcp, Jnp); _cimg_median_sort(Jcc, Jnc); _cimg_median_sort(Jcn, Jnn);

             _cimg_median_sort(Jpp, Jpc); _cimg_median_sort(Jnc, Jnn); _cimg_median_sort(Jcc, Jcn);

             _cimg_median_sort(Jpc, Jpn); _cimg_median_sort(Jcp, Jcc); _cimg_median_sort(Jnp, Jnc);

             _cimg_median_sort(Jcc, Jcn); _cimg_median_sort(Jcc, Jnp); _cimg_median_sort(Jpn, Jcc);

             _cimg_median_sort(Jcc, Jnp);

             res(x,y,0,k) = Jcc;

           }

         } break;

         case 5 : {

           T I[25] = { 0 };

           CImg_5x5(J,T);

           cimg_forV(*this,k) cimg_for5x5(*this,x,y,0,k,I) {

             std::memcpy(J,I,25*sizeof(T));

             _cimg_median_sort(Jbb, Jpb); _cimg_median_sort(Jnb, Jab); _cimg_median_sort(Jcb, Jab); _cimg_median_sort(Jcb, Jnb);

             _cimg_median_sort(Jpp, Jcp); _cimg_median_sort(Jbp, Jcp); _cimg_median_sort(Jbp, Jpp); _cimg_median_sort(Jap, Jbc);

             _cimg_median_sort(Jnp, Jbc); _cimg_median_sort(Jnp, Jap); _cimg_median_sort(Jcc, Jnc); _cimg_median_sort(Jpc, Jnc);

             _cimg_median_sort(Jpc, Jcc); _cimg_median_sort(Jbn, Jpn); _cimg_median_sort(Jac, Jpn); _cimg_median_sort(Jac, Jbn);

             _cimg_median_sort(Jnn, Jan); _cimg_median_sort(Jcn, Jan); _cimg_median_sort(Jcn, Jnn); _cimg_median_sort(Jpa, Jca);

             _cimg_median_sort(Jba, Jca); _cimg_median_sort(Jba, Jpa); _cimg_median_sort(Jna, Jaa); _cimg_median_sort(Jcb, Jbp);

             _cimg_median_sort(Jnb, Jpp); _cimg_median_sort(Jbb, Jpp); _cimg_median_sort(Jbb, Jnb); _cimg_median_sort(Jab, Jcp);

             _cimg_median_sort(Jpb, Jcp); _cimg_median_sort(Jpb, Jab); _cimg_median_sort(Jpc, Jac); _cimg_median_sort(Jnp, Jac);

             _cimg_median_sort(Jnp, Jpc); _cimg_median_sort(Jcc, Jbn); _cimg_median_sort(Jap, Jbn); _cimg_median_sort(Jap, Jcc);

             _cimg_median_sort(Jnc, Jpn); _cimg_median_sort(Jbc, Jpn); _cimg_median_sort(Jbc, Jnc); _cimg_median_sort(Jba, Jna);

             _cimg_median_sort(Jcn, Jna); _cimg_median_sort(Jcn, Jba); _cimg_median_sort(Jpa, Jaa); _cimg_median_sort(Jnn, Jaa);

             _cimg_median_sort(Jnn, Jpa); _cimg_median_sort(Jan, Jca); _cimg_median_sort(Jnp, Jcn); _cimg_median_sort(Jap, Jnn);

             _cimg_median_sort(Jbb, Jnn); _cimg_median_sort(Jbb, Jap); _cimg_median_sort(Jbc, Jan); _cimg_median_sort(Jpb, Jan);

             _cimg_median_sort(Jpb, Jbc); _cimg_median_sort(Jpc, Jba); _cimg_median_sort(Jcb, Jba); _cimg_median_sort(Jcb, Jpc);

             _cimg_median_sort(Jcc, Jpa); _cimg_median_sort(Jnb, Jpa); _cimg_median_sort(Jnb, Jcc); _cimg_median_sort(Jnc, Jca);

             _cimg_median_sort(Jab, Jca); _cimg_median_sort(Jab, Jnc); _cimg_median_sort(Jac, Jna); _cimg_median_sort(Jbp, Jna);

             _cimg_median_sort(Jbp, Jac); _cimg_median_sort(Jbn, Jaa); _cimg_median_sort(Jpp, Jaa); _cimg_median_sort(Jpp, Jbn);

             _cimg_median_sort(Jcp, Jpn); _cimg_median_sort(Jcp, Jan); _cimg_median_sort(Jnc, Jpa); _cimg_median_sort(Jbn, Jna);

             _cimg_median_sort(Jcp, Jnc); _cimg_median_sort(Jcp, Jbn); _cimg_median_sort(Jpb, Jap); _cimg_median_sort(Jnb, Jpc);

             _cimg_median_sort(Jbp, Jcn); _cimg_median_sort(Jpc, Jcn); _cimg_median_sort(Jap, Jcn); _cimg_median_sort(Jab, Jbc);

             _cimg_median_sort(Jpp, Jcc); _cimg_median_sort(Jcp, Jac); _cimg_median_sort(Jab, Jpp); _cimg_median_sort(Jab, Jcp);

             _cimg_median_sort(Jcc, Jac); _cimg_median_sort(Jbc, Jac); _cimg_median_sort(Jpp, Jcp); _cimg_median_sort(Jbc, Jcc);

             _cimg_median_sort(Jpp, Jbc); _cimg_median_sort(Jpp, Jcn); _cimg_median_sort(Jcc, Jcn); _cimg_median_sort(Jcp, Jcn);

             _cimg_median_sort(Jcp, Jbc); _cimg_median_sort(Jcc, Jnn); _cimg_median_sort(Jcp, Jcc); _cimg_median_sort(Jbc, Jnn);

             _cimg_median_sort(Jcc, Jba); _cimg_median_sort(Jbc, Jba); _cimg_median_sort(Jbc, Jcc);

             res(x,y,0,k) = Jcc;

           }

         } break;

         default : {

           CImg<T> vois;

           cimg_forXYV(*this,x,y,k) {

             const int

               x0 = x - hl, y0 = y - hl, x1 = x + hr, y1 = y + hr,

               nx0 = x0<0?0:x0, ny0 = y0<0?0:y0,

               nx1 = x1>=dimx()?dimx()-1:x1, ny1 = y1>=dimy()?dimy()-1:y1;

             vois = get_crop(nx0,ny0,0,k,nx1,ny1,0,k);

             res(x,y,0,k) = vois.median();

           }

         }

         } else switch (n) { // 1D median filter

         case 2 : {

           T I[4] = { 0 };

           cimg_forV(*this,k) cimg_for2x2(*this,x,y,0,k,I) res(x,0,0,k) = (T)(0.5f*(I[0]+I[1]));

         } break;

         case 3 : {

           T I[9] = { 0 };

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             res(x,0,0,k) = I[3]<I[4]?

               (I[4]<I[5]?I[4]:

                (I[3]<I[5]?I[5]:I[3])):

               (I[3]<I[5]?I[3]:

                (I[4]<I[5]?I[5]:I[4]));

           }

         } break;

         default : {

           CImg<T> vois;

           cimg_forXV(*this,x,k) {

             const int

               x0 = x - hl, x1 = x + hr,

               nx0 = x0<0?0:x0, nx1 = x1>=dimx()?dimx()-1:x1;

             vois = get_crop(nx0,0,0,k,nx1,0,0,k);

             res(x,0,0,k) = vois.median();

           }

         }

         }

       }

       return res;

     }


     CImg<T>& sharpen(const float amplitude, const bool sharpen_type=false, const float edge=1, const float alpha=0, const float sigma=0) {

       if (is_empty()) return *this;

       T valm, valM = maxmin(valm);

       const bool threed = (depth>1);

       const float nedge = 0.5f*edge;

       CImg<Tfloat> val, vec, veloc(width,height,depth,dim);


       if (threed) {

         CImg_3x3x3(I,T);

         if (sharpen_type) { // 3D Shock filter.

           CImg<Tfloat> G = (alpha>0?get_blur(alpha).get_structure_tensor():get_structure_tensor());

           if (sigma>0) G.blur(sigma);


           cimg_forXYZ(G,x,y,z) {

             G.get_tensor_at(x,y,z).symmetric_eigen(val,vec);

             G(x,y,z,0) = vec(0,0);

             G(x,y,z,1) = vec(0,1);

             G(x,y,z,2) = vec(0,2);

             G(x,y,z,3) = 1 - (Tfloat)std::pow(1+val[0]+val[1]+val[2],-(Tfloat)nedge);

           }

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             const Tfloat

               u = G(x,y,z,0),

               v = G(x,y,z,1),

               w = G(x,y,z,2),

               amp = G(x,y,z,3),

               ixx = (Tfloat)Incc + Ipcc - 2*Iccc,

               ixy = 0.25f*((Tfloat)Innc + Ippc - Inpc - Ipnc),

               ixz = 0.25f*((Tfloat)Incn + Ipcp - Incp - Ipcn),

               iyy = (Tfloat)Icnc + Icpc - 2*Iccc,

               iyz = 0.25f*((Tfloat)Icnn + Icpp - Icnp - Icpn),

               izz = (Tfloat)Iccn + Iccp - 2*Iccc,

               ixf = (Tfloat)Incc - Iccc,

               ixb = (Tfloat)Iccc - Ipcc,

               iyf = (Tfloat)Icnc - Iccc,

               iyb = (Tfloat)Iccc - Icpc,

               izf = (Tfloat)Iccn - Iccc,

               izb = (Tfloat)Iccc - Iccp,

               itt = u*u*ixx + v*v*iyy + w*w*izz + 2*u*v*ixy + 2*u*w*ixz + 2*v*w*iyz,

               it = u*cimg::minmod(ixf,ixb) + v*cimg::minmod(iyf,iyb) + w*cimg::minmod(izf,izb);

             veloc(x,y,z,k) = -amp*cimg::sign(itt)*cimg::abs(it);

           }

         } else cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) veloc(x,y,z,k) = -(Tfloat)Ipcc-Incc-Icpc-Icnc-Iccp-Iccn+6*Iccc; // 3D Inverse diffusion.

       } else {

         CImg_3x3(I,T);

         if (sharpen_type) { // 2D Shock filter.

           CImg<Tfloat> G = (alpha>0?get_blur(alpha).get_structure_tensor():get_structure_tensor());

           if (sigma>0) G.blur(sigma);

           cimg_forXY(G,x,y) {

             G.get_tensor_at(x,y).symmetric_eigen(val,vec);

             G(x,y,0) = vec(0,0);

             G(x,y,1) = vec(0,1);

             G(x,y,2) = 1 - (Tfloat)std::pow(1+val[0]+val[1],-(Tfloat)nedge);

           }

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             const Tfloat

               u = G(x,y,0),

               v = G(x,y,1),

               amp = G(x,y,2),

               ixx = (Tfloat)Inc + Ipc - 2*Icc,

               ixy = 0.25f*((Tfloat)Inn + Ipp - Inp - Ipn),

               iyy = (Tfloat)Icn + Icp - 2*Icc,

               ixf = (Tfloat)Inc - Icc,

               ixb = (Tfloat)Icc - Ipc,

               iyf = (Tfloat)Icn - Icc,

               iyb = (Tfloat)Icc - Icp,

               itt = u*u*ixx + v*v*iyy + 2*u*v*ixy,

               it = u*cimg::minmod(ixf,ixb) + v*cimg::minmod(iyf,iyb);

             veloc(x,y,k) = -amp*cimg::sign(itt)*cimg::abs(it);

           }

         } else cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) veloc(x,y,k) = -(Tfloat)Ipc-Inc-Icp-Icn+4*Icc;  // 3D Inverse diffusion.

       }

       float m, M = (float)veloc.maxmin(m);

       const float vmax = (float)cimg::max(cimg::abs(m),cimg::abs(M));

       if (vmax!=0) { veloc*=amplitude/vmax; (*this)+=veloc; }

       return cut(valm,valM);

     }


     CImg<T> get_sharpen(const float amplitude, const bool sharpen_type=false, const float edge=1, const float alpha=0, const float sigma=0) const {

       return (+*this).sharpen(amplitude,sharpen_type,edge,alpha,sigma);

     }


     CImgList<Tfloat> get_gradient(const char *const axes=0, const int scheme=3) const {

       CImgList<Tfloat> grad(2,width,height,depth,dim);

       bool threed = false;

       if (axes) {

         for (unsigned int a = 0; axes[a]; ++a) {

           const char axis = cimg::uncase(axes[a]);

           switch (axis) {

           case 'x' : case 'y' : break;

           case 'z' : threed = true; break;

           default :

             throw CImgArgumentException("CImg<%s>::get_gradient() : Unknown specified axis '%c'.",

                                         pixel_type(),axis);

           }

         }

       } else threed = (depth>1);

       if (threed) {

         CImg<Tfloat>(width,height,depth,dim).transfer_to(grad);

         switch (scheme) { // Compute 3D gradient

         case -1 : { // backward finite differences

           CImg_3x3x3(I,T);

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             grad[0](x,y,z,k) = (Tfloat)Iccc - Ipcc;

             grad[1](x,y,z,k) = (Tfloat)Iccc - Icpc;

             grad[2](x,y,z,k) = (Tfloat)Iccc - Iccp;

           }

         } break;

         case 1 : { // forward finite differences

           CImg_2x2x2(I,T);

           cimg_forV(*this,k) cimg_for2x2x2(*this,x,y,z,k,I) {

             grad[0](x,y,z,k) = (Tfloat)Incc - Iccc;

             grad[1](x,y,z,k) = (Tfloat)Icnc - Iccc;

             grad[2](x,y,z,k) = (Tfloat)Iccn - Iccc;

           }

         } break;

         case 4 : { // using Deriche filter with low standard variation

           grad[0] = get_deriche(0,1,'x');

           grad[1] = get_deriche(0,1,'y');

           grad[2] = get_deriche(0,1,'z');

         } break;

         default : { // central finite differences

           CImg_3x3x3(I,T);

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             grad[0](x,y,z,k) = 0.5f*((Tfloat)Incc - Ipcc);

             grad[1](x,y,z,k) = 0.5f*((Tfloat)Icnc - Icpc);

             grad[2](x,y,z,k) = 0.5f*((Tfloat)Iccn - Iccp);

           }

         }

         }

       } else switch (scheme) { // Compute 2D-gradient

       case -1 : { // backward finite differences

         CImg_3x3(I,T);

         cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) {

           grad[0](x,y,z,k) = (Tfloat)Icc - Ipc;

           grad[1](x,y,z,k) = (Tfloat)Icc - Icp;

         }

       } break;

       case 1 : { // forward finite differences

         CImg_2x2(I,T);

         cimg_forZV(*this,z,k) cimg_for2x2(*this,x,y,z,k,I) {

           grad[0](x,y,0,k) = (Tfloat)Inc - Icc;

           grad[1](x,y,z,k) = (Tfloat)Icn - Icc;

         }

       } break;

       case 2 : { // using Sobel mask

         CImg_3x3(I,T);

         const Tfloat a = 1, b = 2;

         cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) {

           grad[0](x,y,z,k) = -a*Ipp - b*Ipc - a*Ipn + a*Inp + b*Inc + a*Inn;

           grad[1](x,y,z,k) = -a*Ipp - b*Icp - a*Inp + a*Ipn + b*Icn + a*Inn;

         }

       } break;

       case 3 : { // using rotation invariant mask

         CImg_3x3(I,T);

         const Tfloat a = (Tfloat)(0.25f*(2-std::sqrt(2.0f))), b = (Tfloat)(0.5f*(std::sqrt(2.0f)-1));

         cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) {

           grad[0](x,y,z,k) = -a*Ipp - b*Ipc - a*Ipn + a*Inp + b*Inc + a*Inn;

           grad[1](x,y,z,k) = -a*Ipp - b*Icp - a*Inp + a*Ipn + b*Icn + a*Inn;

         }

       } break;

       case 4 : { // using Deriche filter with low standard variation

         grad[0] = get_deriche(0,1,'x');

         grad[1] = get_deriche(0,1,'y');

       } break;

       default : { // central finite differences

         CImg_3x3(I,T);

         cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) {

           grad[0](x,y,z,k) = 0.5f*((Tfloat)Inc - Ipc);

           grad[1](x,y,z,k) = 0.5f*((Tfloat)Icn - Icp);

         }

       }

       }

       if (!axes) return grad;

       CImgList<Tfloat> res;

       for (unsigned int l = 0; axes[l]; ++l) {

         const char axis = cimg::uncase(axes[l]);

         switch (axis) {

         case 'x' : res.insert(grad[0]); break;

         case 'y' : res.insert(grad[1]); break;

         case 'z' : res.insert(grad[2]); break;

         }

       }

       grad.assign();

       return res;

     }


     CImgList<Tfloat> get_hessian(const char *const axes=0) const {

       const char *naxes = axes, *const def_axes2d = "xxxyyy", *const def_axes3d = "xxxyxzyyyzzz";

       if (!axes) naxes = depth>1?def_axes3d:def_axes2d;

       CImgList<Tfloat> res;

       const unsigned int lmax = std::strlen(naxes);

       if (lmax%2)

         throw CImgArgumentException("CImg<%s>::get_hessian() : Incomplete parameter axes = '%s'.",

                                     pixel_type(),naxes);

       res.assign(lmax/2,width,height,depth,dim);

       if (!cimg::strcasecmp(naxes,def_axes3d)) { // Default 3D version

         CImg_3x3x3(I,T);

         cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

           res[0](x,y,z,k) = (Tfloat)Ipcc + Incc - 2*Iccc;              // Ixx

           res[1](x,y,z,k) = 0.25f*((Tfloat)Ippc + Innc - Ipnc - Inpc); // Ixy

           res[2](x,y,z,k) = 0.25f*((Tfloat)Ipcp + Incn - Ipcn - Incp); // Ixz

           res[3](x,y,z,k) = (Tfloat)Icpc + Icnc - 2*Iccc;              // Iyy

           res[4](x,y,z,k) = 0.25f*((Tfloat)Icpp + Icnn - Icpn - Icnp); // Iyz

           res[5](x,y,z,k) = (Tfloat)Iccn + Iccp - 2*Iccc;              // Izz

         }

       } else if (!cimg::strcasecmp(naxes,def_axes2d)) { // Default 2D version

         CImg_3x3(I,T);

         cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

           res[0](x,y,0,k) = (Tfloat)Ipc + Inc - 2*Icc;             // Ixx

           res[1](x,y,0,k) = 0.25f*((Tfloat)Ipp + Inn - Ipn - Inp); // Ixy

           res[2](x,y,0,k) = (Tfloat)Icp + Icn - 2*Icc;             // Iyy

         }

       } else for (unsigned int l = 0; l<lmax; ) { // Version with custom axes.

         const unsigned int l2 = l/2;

           char axis1 = naxes[l++], axis2 = naxes[l++];

           if (axis1>axis2) cimg::swap(axis1,axis2);

           bool valid_axis = false;

           if (axis1=='x' && axis2=='x') { // Ixx

             valid_axis = true; CImg_3x3(I,T);

             cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = (Tfloat)Ipc + Inc - 2*Icc;

           }

           else if (axis1=='x' && axis2=='y') { // Ixy

             valid_axis = true; CImg_3x3(I,T);

             cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = 0.25f*((Tfloat)Ipp + Inn - Ipn - Inp);

           }

           else if (axis1=='x' && axis2=='z') { // Ixz

             valid_axis = true; CImg_3x3x3(I,T);

             cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = 0.25f*((Tfloat)Ipcp + Incn - Ipcn - Incp);

           }

           else if (axis1=='y' && axis2=='y') { // Iyy

             valid_axis = true; CImg_3x3(I,T);

             cimg_forZV(*this,z,k) cimg_for3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = (Tfloat)Icp + Icn - 2*Icc;

           }

           else if (axis1=='y' && axis2=='z') { // Iyz

             valid_axis = true; CImg_3x3x3(I,T);

             cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = 0.25f*((Tfloat)Icpp + Icnn - Icpn - Icnp);

           }

           else if (axis1=='z' && axis2=='z') { // Izz

             valid_axis = true; CImg_3x3x3(I,T);

             cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) res[l2](x,y,z,k) = (Tfloat)Iccn + Iccp - 2*Iccc;

           }

           else if (!valid_axis) throw CImgArgumentException("CImg<%s>::get_hessian() : Invalid parameter axes = '%s'.",

                                                             pixel_type(),naxes);

       }

       return res;

     }


     CImg<T>& structure_tensor(const unsigned int scheme=1) {

       return get_structure_tensor(scheme).transfer_to(*this);

     }


     CImg<Tfloat> get_structure_tensor(const unsigned int scheme=1) const {

       if (is_empty()) return *this;

       CImg<Tfloat> res;

       if (depth>1) { // 3D version

         res.assign(width,height,depth,6,0);

         CImg_3x3x3(I,T);

         switch (scheme) {

         case 0 : { // classical central finite differences

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             const Tfloat

               ix = 0.5f*((Tfloat)Incc - Ipcc),

               iy = 0.5f*((Tfloat)Icnc - Icpc),

               iz = 0.5f*((Tfloat)Iccn - Iccp);

             res(x,y,z,0)+=ix*ix;

             res(x,y,z,1)+=ix*iy;

             res(x,y,z,2)+=ix*iz;

             res(x,y,z,3)+=iy*iy;

             res(x,y,z,4)+=iy*iz;

             res(x,y,z,5)+=iz*iz;

           }

         } break;

         case 1 : { // Forward/backward finite differences (version 1).

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             const Tfloat

               ixf = (Tfloat)Incc - Iccc, ixb = (Tfloat)Iccc - Ipcc,

               iyf = (Tfloat)Icnc - Iccc, iyb = (Tfloat)Iccc - Icpc,

               izf = (Tfloat)Iccn - Iccc, izb = (Tfloat)Iccc - Iccp;

             res(x,y,z,0) += 0.25f*(ixf*ixf + ixf*ixb + ixb*ixf + ixb*ixb);

             res(x,y,z,1) += 0.25f*(ixf*iyf + ixf*iyb + ixb*iyf + ixb*iyb);

             res(x,y,z,2) += 0.25f*(ixf*izf + ixf*izb + ixb*izf + ixb*izb);

             res(x,y,z,3) += 0.25f*(iyf*iyf + iyf*iyb + iyb*iyf + iyb*iyb);

             res(x,y,z,4) += 0.25f*(iyf*izf + iyf*izb + iyb*izf + iyb*izb);

             res(x,y,z,5) += 0.25f*(izf*izf + izf*izb + izb*izf + izb*izb);

           }

         } break;

         default : { // Forward/backward finite differences (version 2).

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) {

             const Tfloat

               ixf = (Tfloat)Incc - Iccc, ixb = (Tfloat)Iccc - Ipcc,

               iyf = (Tfloat)Icnc - Iccc, iyb = (Tfloat)Iccc - Icpc,

               izf = (Tfloat)Iccn - Iccc, izb = (Tfloat)Iccc - Iccp;

             res(x,y,z,0) += 0.5f*(ixf*ixf + ixb*ixb);

             res(x,y,z,1) += 0.25f*(ixf*iyf + ixf*iyb + ixb*iyf + ixb*iyb);

             res(x,y,z,2) += 0.25f*(ixf*izf + ixf*izb + ixb*izf + ixb*izb);

             res(x,y,z,3) += 0.5f*(iyf*iyf + iyb*iyb);

             res(x,y,z,4) += 0.25f*(iyf*izf + iyf*izb + iyb*izf + iyb*izb);

             res(x,y,z,5) += 0.5f*(izf*izf + izb*izb);

           }

         } break;

         }

       } else { // 2D version

         res.assign(width,height,depth,3,0);

         CImg_3x3(I,T);

         switch (scheme) {

         case 0 : { // classical central finite differences

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             const Tfloat

               ix = 0.5f*((Tfloat)Inc - Ipc),

               iy = 0.5f*((Tfloat)Icn - Icp);

             res(x,y,0,0)+=ix*ix;

             res(x,y,0,1)+=ix*iy;

             res(x,y,0,2)+=iy*iy;

           }

         } break;

         case 1 : { // Forward/backward finite differences (version 1).

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             const Tfloat

               ixf = (Tfloat)Inc - Icc, ixb = (Tfloat)Icc - Ipc,

               iyf = (Tfloat)Icn - Icc, iyb = (Tfloat)Icc - Icp;

             res(x,y,0,0) += 0.25f*(ixf*ixf + ixf*ixb + ixb*iyf + ixb*ixb);

             res(x,y,0,1) += 0.25f*(ixf*iyf + ixf*iyb + ixb*iyf + ixb*iyb);

             res(x,y,0,2) += 0.25f*(iyf*iyf + iyf*iyb + iyb*iyf + iyb*iyb);

           }

         } break;

         default : { // Forward/backward finite differences (version 2).

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) {

             const Tfloat

               ixf = (Tfloat)Inc - Icc, ixb = (Tfloat)Icc - Ipc,

               iyf = (Tfloat)Icn - Icc, iyb = (Tfloat)Icc - Icp;

             res(x,y,0,0) += 0.5f*(ixf*ixf + ixb*ixb);

             res(x,y,0,1) += 0.25f*(ixf*iyf + ixf*iyb + ixb*iyf + ixb*iyb);

             res(x,y,0,2) += 0.5f*(iyf*iyf + iyb*iyb);

           }

         } break;

         }

       }

       return res;

     }


     CImg<T>& edge_tensors(const float sharpness=0.7f, const float anisotropy=0.3f,

                           const float alpha=0.6f, const float sigma=1.1f, const bool is_sqrt=false) {

       CImg<Tfloat> dest;

       const float nsharpness = cimg::max(sharpness,1e-5f), power1 = (is_sqrt?0.5f:1)*nsharpness, power2 = power1/(1e-7f+1-anisotropy);

       blur(alpha).normalize(0,(T)255);


       if (depth>1) { // for 3D volumes

         CImg<floatT> val(3), vec(3,3);

         get_structure_tensor().transfer_to(dest).blur(sigma);

         cimg_forXYZ(*this,x,y,z) {

           dest.get_tensor_at(x,y,z).symmetric_eigen(val,vec);

           const float

             _l1 = val[2], _l2 = val[1], _l3 = val[0],

             l1 = _l1>0?_l1:0, l2 = _l2>0?_l2:0, l3 = _l3>0?_l3:0,

             ux = vec(0,0), uy = vec(0,1), uz = vec(0,2),

             vx = vec(1,0), vy = vec(1,1), vz = vec(1,2),

             wx = vec(2,0), wy = vec(2,1), wz = vec(2,2),

             n1 = (float)std::pow(1+l1+l2+l3,-power1),

             n2 = (float)std::pow(1+l1+l2+l3,-power2);

           dest(x,y,z,0) = n1*(ux*ux + vx*vx) + n2*wx*wx;

           dest(x,y,z,1) = n1*(ux*uy + vx*vy) + n2*wx*wy;

           dest(x,y,z,2) = n1*(ux*uz + vx*vz) + n2*wx*wz;

           dest(x,y,z,3) = n1*(uy*uy + vy*vy) + n2*wy*wy;

           dest(x,y,z,4) = n1*(uy*uz + vy*vz) + n2*wy*wz;

           dest(x,y,z,5) = n1*(uz*uz + vz*vz) + n2*wz*wz;

         }

       } else { // for 2D images

         CImg<floatT> val(2), vec(2,2);

         get_structure_tensor().transfer_to(dest).blur(sigma);

         cimg_forXY(*this,x,y) {

           dest.get_tensor_at(x,y).symmetric_eigen(val,vec);

           const float

             _l1 = val[1], _l2 = val[0],

             l1 = _l1>0?_l1:0, l2 = _l2>0?_l2:0,

             ux = vec(1,0), uy = vec(1,1),

             vx = vec(0,0), vy = vec(0,1),

             n1 = (float)std::pow(1+l1+l2,-power1),

             n2 = (float)std::pow(1+l1+l2,-power2);

           dest(x,y,0,0) = n1*ux*ux + n2*vx*vx;

           dest(x,y,0,1) = n1*ux*uy + n2*vx*vy;

           dest(x,y,0,2) = n1*uy*uy + n2*vy*vy;

         }

       }

       return dest.transfer_to(*this);

     }


     CImg<T> get_edge_tensors(const float sharpness=0.7f, const float anisotropy=0.3f,

                                   const float alpha=0.6f, const float sigma=1.1f, const bool is_sqrt=false) const {

       return (+*this).edge_tensors(sharpness,anisotropy,alpha,sigma,is_sqrt);

     }


     CImg<T>& displacement_field(const CImg<T>& target, const float smooth=0.1f, const float precision=0.1f,

                                 const unsigned int nb_scales=0, const unsigned int itermax=1000,

                                 const bool backward = true) {

       return get_displacement_field(target,smooth,precision,nb_scales,itermax,backward).transfer_to(*this);

     }


     CImg<Tfloat> get_displacement_field(const CImg<T>& target,

                                         const float smoothness=0.1f, const float precision=0.1f,

                                         const unsigned int nb_scales=0, const unsigned int itermax=1000,

                                         const bool backward = true) const {

       if (is_empty() || !target) return *this;

       if (!is_sameXYZV(target))

         throw CImgArgumentException("CImg<%s>::displacement_field() : Instance image (%u,%u,%u,%u,%p) and target image (%u,%u,%u,%u,%p) "

                                     "have different size.",

                                     pixel_type(),width,height,depth,dim,data,

                                     target.width,target.height,target.depth,target.dim,target.data);

       if (smoothness<0)

         throw CImgArgumentException("CImg<%s>::displacement_field() : Smoothness parameter %g is negative.",

                                     pixel_type(),smoothness);

       if (precision<0)

         throw CImgArgumentException("CImg<%s>::displacement_field() : Precision parameter %g is negative.",

                                     pixel_type(),precision);


       const unsigned int nscales = nb_scales>0?nb_scales:(unsigned int)(2*std::log((double)(cimg::max(width,height,depth))));

       Tfloat m1, M1 = (Tfloat)maxmin(m1), m2, M2 = (Tfloat)target.maxmin(m2);

       const Tfloat factor = cimg::max(cimg::abs(m1),cimg::abs(M1),cimg::abs(m2),cimg::abs(M2));

       CImg<Tfloat> U0;

       const bool threed = (depth>1);


       // Begin multi-scale motion estimation

       for (int scale = (int)nscales-1; scale>=0; --scale) {

         const float sfactor = (float)std::pow(1.5f,(float)scale), sprecision = (float)(precision/std::pow(2.25,1+scale));

         const int

           sw = (int)(width/sfactor), sh = (int)(height/sfactor), sd = (int)(depth/sfactor),

           swidth = sw?sw:1, sheight = sh?sh:1, sdepth = sd?sd:1;

         CImg<Tfloat>

           I1 = get_resize(swidth,sheight,sdepth,-100,2),

           I2 = target.get_resize(swidth,sheight,sdepth,-100,2);

         I1/=factor; I2/=factor;

         CImg<Tfloat> U;

         if (U0) U = (U0*=1.5f).get_resize(I1.dimx(),I1.dimy(),I1.dimz(),-100,3);

         else U.assign(I1.dimx(),I1.dimy(),I1.dimz(),threed?3:2,0);


         // Begin single-scale motion estimation

         CImg<Tfloat> veloc(U);

         float dt = 2, energy = cimg::type<float>::max();

         const CImgList<Tfloat> dI = backward?I1.get_gradient():I2.get_gradient();

         for (unsigned int iter = 0; iter<itermax; iter++) {

           veloc.fill(0);

           float nenergy = 0;

           if (threed) {

             cimg_for3XYZ(U,x,y,z) {

               const float

                 sgnU = backward?-1.0f:1.0f,

                 X = (float)(x + sgnU * U(x,y,z,0)),

                 Y = (float)(y + sgnU * U(x,y,z,1)),

                 Z = (float)(z + sgnU * U(x,y,z,2));

               cimg_forV(U,k) {

                 const Tfloat

                   Ux = 0.5f*(U(_n1x,y,z,k) - U(_p1x,y,z,k)),

                   Uy = 0.5f*(U(x,_n1y,z,k) - U(x,_p1y,z,k)),

                   Uz = 0.5f*(U(x,y,_n1z,k) - U(x,y,_p1z,k)),

                   Uxx = U(_n1x,y,z,k) + U(_p1x,y,z,k) - 2*U(x,y,z,k),

                   Uyy = U(x,_n1y,z,k) + U(x,_p1y,z,k) - 2*U(x,y,z,k),

                   Uzz = U(x,y,_n1z,k) + U(x,y,_n1z,k) - 2*U(x,y,z,k);

                 nenergy += (float)(smoothness*(Ux*Ux + Uy*Uy + Uz*Uz));

                 Tfloat deltaIgrad = 0;

                 cimg_forV(I1,i) {

                   const Tfloat deltaIi = (float)(backward?I2(x,y,z,i)-I1._linear_atXYZ(X,Y,Z,i):I2._linear_atXYZ(X,Y,Z,i)-I1(x,y,z,i));

                   nenergy += (float)(deltaIi*deltaIi/2);

                   deltaIgrad+=-deltaIi*dI[k]._linear_atXYZ(X,Y,Z,i);

                 }

                 veloc(x,y,z,k) = deltaIgrad + smoothness*(Uxx + Uyy + Uzz);

               }

             }

           } else {

             cimg_for3XY(U,x,y) {

               const float

                 sgnU = backward?-1.0f:1.0f,

                 X = (float)(x + sgnU * U(x,y,0)),

                 Y = (float)(y + sgnU * U(x,y,1));

               cimg_forV(U,k) {

                 const Tfloat

                   Ux = 0.5f*(U(_n1x,y,k) - U(_p1x,y,k)),

                   Uy = 0.5f*(U(x,_n1y,k) - U(x,_p1y,k)),

                   Uxx = U(_n1x,y,k) + U(_p1x,y,k) - 2*U(x,y,k),

                   Uyy = U(x,_n1y,k) + U(x,_p1y,k) - 2*U(x,y,k);

                 nenergy += (float)(smoothness*(Ux*Ux + Uy*Uy));

                 Tfloat deltaIgrad = 0;

                 cimg_forV(I1,i) {

                   const Tfloat deltaIi = (float)(backward?I2(x,y,i)-I1.linear_atXY(X,Y,i):I2._linear_atXY(X,Y,i)-I1(x,y,i));

                   nenergy += (float)(deltaIi*deltaIi/2);

                   deltaIgrad+=-deltaIi*dI[k]._linear_atXY(X,Y,i);

                 }

                 veloc(x,y,k) = deltaIgrad + smoothness*(Uxx + Uyy);

               }

             }

           }

           const Tfloat vmax = cimg::max(cimg::abs(veloc.min()), cimg::abs(veloc.max()));

           U+=(veloc*=dt/(1e-6+vmax));

           if (cimg::abs(nenergy-energy)<sprecision) break;

           if (nenergy<energy) dt*=0.5f;

           energy = nenergy;

         }

         U.transfer_to(U0);

       }

       return U0;

     }


     CImg<T>& distance(const T isovalue,

                       const float sizex=1, const float sizey=1, const float sizez=1,

                       const bool compute_sqrt=true) {

       return get_distance(isovalue,sizex,sizey,sizez,compute_sqrt).transfer_to(*this);

     }


     CImg<floatT> get_distance(const T isovalue,

                               const float sizex=1, const float sizey=1, const float sizez=1,

                               const bool compute_sqrt=true) const {

       if (is_empty()) return *this;

       const int dx = dimx(), dy = dimy(), dz = dimz();

       CImg<floatT> res(dx,dy,dz,dim);

       const float maxdist = (float)std::sqrt((float)dx*dx + dy*dy + dz*dz);

       cimg_forV(*this,k) {

         bool is_isophote = false;


         if (depth>1) { // 3D version

           cimg_forYZ(*this,y,z) {

             if ((*this)(0,y,z,k)==isovalue) { is_isophote = true; res(0,y,z,k) = 0; } else res(0,y,z,k) = maxdist;

             for (int x = 1; x<dx; ++x) if ((*this)(x,y,z,k)==isovalue) { is_isophote = true; res(x,y,z,k) = 0; }

             else res(x,y,z,k) = res(x-1,y,z,k) + sizex;

             for (int x = dx-2; x>=0; --x) if (res(x+1,y,z,k)<res(x,y,z,k)) res(x,y,z,k) = res(x+1,y,z,k) + sizex;

           }

           if (!is_isophote) { res.get_shared_channel(k).fill(cimg::type<floatT>::max()); continue; }

           CImg<floatT> tmp(cimg::max(dy,dz));

           CImg<intT> s(tmp.width), t(s.width);

           cimg_forXZ(*this,x,z) {

             cimg_forY(*this,y) tmp[y] = res(x,y,z,k);

             int q = s[0] = t[0] = 0;

             for (int y = 1; y<dy; ++y) {

               const float val = tmp[y], val2 = val*val;

               while (q>=0 && _distance_f(t[q],s[q],cimg::sqr(tmp[s[q]]),sizey)>_distance_f(t[q],y,val2,sizey)) --q;

               if (q<0) { q = 0; s[0] = y; }

               else {

                 const int w = 1 + _distance_sep(s[q],y,(int)cimg::sqr(tmp[s[q]]),(int)val2,sizey);

                 if (w<dy) { s[++q] = y; t[q] = w; }

               }

             }

             for (int y = dy - 1; y>=0; --y) {

               res(x,y,z,k) = _distance_f(y,s[q],cimg::sqr(tmp[s[q]]),sizey);

               if (y==t[q]) --q;

             }

           }

           cimg_forXY(*this,x,y) {

             cimg_forZ(*this,z) tmp[z] = res(x,y,z,k);

             int q = s[0] = t[0] = 0;

             for (int z = 1; z<dz; ++z) {

               const float val = tmp[z];

               while (q>=0 && _distance_f(t(q),s[q],tmp[s[q]],sizez)>_distance_f(t[q],z,tmp[z],sizez)) --q;

               if (q<0) { q = 0; s[0] = z; }

               else {

                 const int w = 1 + _distance_sep(s[q],z,(int)tmp[s[q]],(int)val,sizez);

                 if (w<dz) { s[++q] = z; t[q] = w; }

               }

             }

             for (int z = dz - 1; z>=0; --z) {

               const float val = _distance_f(z,s[q],tmp[s[q]],sizez);

               res(x,y,z,k) = compute_sqrt?(float)std::sqrt(val):val;

               if (z==t[q]) --q;

             }

           }

         } else { // 2D version (with small optimizations)

           cimg_forX(*this,x) {

             const T *ptrs = ptr(x,0,0,k);

             float *ptrd = res.ptr(x,0,0,k), d = *ptrd = *ptrs==isovalue?(is_isophote=true),0:maxdist;

             for (int y = 1; y<dy; ++y) { ptrs+=width; ptrd+=width; d = *ptrd = *ptrs==isovalue?(is_isophote=true),0:d+sizey; }

             for (int y = dy - 2; y>=0; --y) { ptrd-=width; if (d<*ptrd) *ptrd = (d+=sizey); else d = *ptrd; }

           }

           if (!is_isophote) { res.get_shared_channel(k).fill(cimg::type<floatT>::max()); continue; }

           CImg<floatT> tmp(dx);

           CImg<intT> s(dx), t(dx);

           cimg_forY(*this,y) {

             float *ptmp = tmp.ptr();

             std::memcpy(ptmp,res.ptr(0,y,0,k),sizeof(float)*dx);

             int q = s[0] = t[0] = 0;

             for (int x = 1; x<dx; ++x) {

               const float val = *(++ptmp), val2 = val*val;

               while (q>=0 && _distance_f(t[q],s[q],cimg::sqr(tmp[s[q]]),sizex)>_distance_f(t[q],x,val2,sizex)) --q;

               if (q<0) { q = 0; s[0] = x; }

               else {

                 const int w = 1 + _distance_sep(s[q],x,(int)cimg::sqr(tmp[s[q]]),(int)val2,sizex);

                 if (w<dx) { q++; s[q] = x; t[q] = w; }

               }

             }

             float *pres = res.ptr(0,y,0,k) + width;

             for (int x = dx - 1; x>=0; --x) {

               const float val = _distance_f(x,s[q],cimg::sqr(tmp[s[q]]),sizex);

               *(--pres) = compute_sqrt?(float)std::sqrt(val):val;

               if (x==t[q]) --q;

             }

           }

         }

       }

       return res;

     }


     static float _distance_f(const int x, const int i, const float gi2, const float fact) {

       const float xmi = fact*((float)x - i);

       return xmi*xmi + gi2;

     }

     static int _distance_sep(const int i, const int u, const int gi2, const int gu2, const float fact) {

       const float fact2 = fact*fact;

       return (int)(fact2*(u*u - i*i) + gu2 - gi2)/(int)(2*fact2*(u - i));

     }


     CImg<T>& distance_hamilton(const unsigned int nb_iter, const float band_size=0, const float precision=0.5f) {

       if (is_empty()) return *this;

       CImg<Tfloat> veloc(*this);

       for (unsigned int iter = 0; iter<nb_iter; ++iter) {

         veloc.fill(0);

         if (depth>1) { // 3D version

           CImg_3x3x3(I,T);

           cimg_forV(*this,k) cimg_for3x3x3(*this,x,y,z,k,I) if (band_size<=0 || cimg::abs(Iccc)<band_size) {

             const Tfloat

               gx = 0.5f*((Tfloat)Incc - Ipcc),

               gy = 0.5f*((Tfloat)Icnc - Icpc),

               gz = 0.5f*((Tfloat)Iccn - Iccp),

               sgn = -cimg::sign((Tfloat)Iccc),

               ix = gx*sgn>0?(Tfloat)Incc - Iccc:(Tfloat)Iccc - Ipcc,

               iy = gy*sgn>0?(Tfloat)Icnc - Iccc:(Tfloat)Iccc - Icpc,

               iz = gz*sgn>0?(Tfloat)Iccn - Iccc:(Tfloat)Iccc - Iccp,

               ng = 1e-5f + (Tfloat)std::sqrt(gx*gx + gy*gy + gz*gz),

               ngx = gx/ng,

               ngy = gy/ng,

               ngz = gz/ng;

             veloc(x,y,z,k) = sgn*(ngx*ix + ngy*iy + ngz*iz - 1);

           }

         } else { // 2D version

           CImg_3x3(I,T);

           cimg_forV(*this,k) cimg_for3x3(*this,x,y,0,k,I) if (band_size<=0 || cimg::abs(Icc)<band_size) {

             const Tfloat

               gx = 0.5f*((Tfloat)Inc - Ipc),

               gy = 0.5f*((Tfloat)Icn - Icp),

               sgn = -cimg::sign((Tfloat)Icc),

               ix = gx*sgn>0?(Tfloat)Inc - Icc:(Tfloat)Icc - Ipc,

               iy = gy*sgn>0?(Tfloat)Icn - Icc:(Tfloat)Icc - Icp,

               ng = 1e-5f + (Tfloat)std::sqrt(gx*gx + gy*gy),

               ngx = gx/ng,

               ngy = gy/ng;

             veloc(x,y,k) = sgn*(ngx*ix + ngy*iy - 1);

           }

         }

         float m, M = (float)veloc.maxmin(m), xdt = precision/(float)cimg::max(cimg::abs(m),cimg::abs(M));

         *this+=(veloc*=xdt);

       }

       return *this;

     }


     CImg<Tfloat> get_distance_hamilton(const unsigned int nb_iter, const float band_size=0, const float precision=0.5f) const {

       return CImg<Tfloat>(*this,false).distance_hamilton(nb_iter,band_size,precision);

     }


     CImg<T>& haar(const char axis, const bool invert=false, const unsigned int nb_scales=1) {

       return get_haar(axis,invert,nb_scales).transfer_to(*this);

     }


     CImg<Tfloat> get_haar(const char axis, const bool invert=false, const unsigned int nb_scales=1) const {

       if (is_empty() || !nb_scales) return *this;

       CImg<Tfloat> res;


       if (nb_scales==1) {

         switch (cimg::uncase(axis)) { // Single scale transform

         case 'x' : {

           const unsigned int w = width/2;

           if (w) {

             if (w%2)

               throw CImgInstanceException("CImg<%s>::haar() : Sub-image width = %u is not even at a particular scale (=%u).",

                                           pixel_type(),w);

             res.assign(width,height,depth,dim);

             if (invert) cimg_forYZV(*this,y,z,v) { // Inverse transform along X

               for (unsigned int x = 0, xw = w, x2 = 0; x<w; ++x, ++xw) {

                 const Tfloat val0 = (Tfloat)(*this)(x,y,z,v), val1 = (Tfloat)(*this)(xw,y,z,v);

                 res(x2++,y,z,v) = val0 - val1;

                 res(x2++,y,z,v) = val0 + val1;

               }

             } else cimg_forYZV(*this,y,z,v) { // Direct transform along X

               for (unsigned int x = 0, xw = w, x2 = 0; x<w; ++x, ++xw) {

                 const Tfloat val0 = (Tfloat)(*this)(x2++,y,z,v), val1 = (Tfloat)(*this)(x2++,y,z,v);

                 res(x,y,z,v) = (val0 + val1)/2;

                 res(xw,y,z,v) = (val1 - val0)/2;

               }

             }

           } else return *this;

         } break;

         case 'y' : {

           const unsigned int h = height/2;

           if (h) {

             if (h%2)

               throw CImgInstanceException("CImg<%s>::haar() : Sub-image height = %u is not even at a particular scale.",

                                           pixel_type(),h);

             res.assign(width,height,depth,dim);

             if (invert) cimg_forXZV(*this,x,z,v) { // Inverse transform along Y

               for (unsigned int y = 0, yh = h, y2 = 0; y<h; ++y, ++yh) {

                 const Tfloat val0 = (Tfloat)(*this)(x,y,z,v), val1 = (Tfloat)(*this)(x,yh,z,v);

                 res(x,y2++,z,v) = val0 - val1;

                 res(x,y2++,z,v) = val0 + val1;

               }

             } else cimg_forXZV(*this,x,z,v) {

               for (unsigned int y = 0, yh = h, y2 = 0; y<h; ++y, ++yh) { // Direct transform along Y

                 const Tfloat val0 = (Tfloat)(*this)(x,y2++,z,v), val1 = (Tfloat)(*this)(x,y2++,z,v);

                 res(x,y,z,v) = (val0 + val1)/2;

                 res(x,yh,z,v) = (val1 - val0)/2;

               }

             }

           } else return *this;

         } break;

         case 'z' : {

           const unsigned int d = depth/2;

           if (d) {

             if (d%2)

               throw CImgInstanceException("CImg<%s>::haar() : Sub-image depth = %u is not even at a particular scale.",

                                           pixel_type(),d);

             res.assign(width,height,depth,dim);

             if (invert) cimg_forXYV(*this,x,y,v) { // Inverse transform along Z

               for (unsigned int z = 0, zd = d, z2 = 0; z<d; ++z, ++zd) {

                 const Tfloat val0 = (Tfloat)(*this)(x,y,z,v), val1 = (Tfloat)(*this)(x,y,zd,v);

                 res(x,y,z2++,v) = val0 - val1;

                 res(x,y,z2++,v) = val0 + val1;

               }

             } else cimg_forXYV(*this,x,y,v) {

               for (unsigned int z = 0, zd = d, z2 = 0; z<d; ++z, ++zd) { // Direct transform along Z

                 const Tfloat val0 = (Tfloat)(*this)(x,y,z2++,v), val1 = (Tfloat)(*this)(x,y,z2++,v);

                 res(x,y,z,v) = (val0 + val1)/2;

                 res(x,y,zd,v) = (val1 - val0)/2;

               }

             }

           } else return *this;

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::haar() : Invalid axis '%c', must be 'x','y' or 'z'.",

                                       pixel_type(),axis);

         }

       } else { // Multi-scale version

         if (invert) {

           res.assign(*this);

           switch (cimg::uncase(axis)) {

           case 'x' : {

             unsigned int w = width;

             for (unsigned int s=1; w && s<nb_scales; ++s) w/=2;

             for (w=w?w:1; w<=width; w*=2) res.draw_image(res.get_crop(0,w-1).get_haar('x',true,1));

           } break;

           case 'y' : {

             unsigned int h = width;

             for (unsigned int s=1; h && s<nb_scales; ++s) h/=2;

             for (h=h?h:1; h<=height; h*=2) res.draw_image(res.get_crop(0,0,width-1,h-1).get_haar('y',true,1));

           } break;

           case 'z' : {

             unsigned int d = depth;

             for (unsigned int s=1; d && s<nb_scales; ++s) d/=2;

             for (d=d?d:1; d<=depth; d*=2) res.draw_image(res.get_crop(0,0,0,width-1,height-1,d-1).get_haar('z',true,1));

           } break;

           default :

             throw CImgArgumentException("CImg<%s>::haar() : Invalid axis '%c', must be 'x','y' or 'z'.",

                                         pixel_type(),axis);

           }

         } else { // Direct transform

           res = get_haar(axis,false,1);

           switch (cimg::uncase(axis)) {

           case 'x' : {

             for (unsigned int s=1, w=width/2; w && s<nb_scales; ++s, w/=2) res.draw_image(res.get_crop(0,w-1).get_haar('x',false,1));

           } break;

           case 'y' : {

             for (unsigned int s=1, h=height/2; h && s<nb_scales; ++s, h/=2) res.draw_image(res.get_crop(0,0,width-1,h-1).get_haar('y',false,1));

           } break;

           case 'z' : {

             for (unsigned int s=1, d=depth/2; d && s<nb_scales; ++s, d/=2) res.draw_image(res.get_crop(0,0,0,width-1,height-1,d-1).get_haar('z',false,1));

           } break;

           default :

             throw CImgArgumentException("CImg<%s>::haar() : Invalid axis '%c', must be 'x','y' or 'z'.",

                                         pixel_type(),axis);

           }

         }

       }

       return res;

     }


     CImg<T>& haar(const bool invert=false, const unsigned int nb_scales=1) {

       return get_haar(invert,nb_scales).transfer_to(*this);

     }


     CImg<Tfloat> get_haar(const bool invert=false, const unsigned int nb_scales=1) const {

       CImg<Tfloat> res;


       if (nb_scales==1) { // Single scale transform

         if (width>1) get_haar('x',invert,1).transfer_to(res);

         if (height>1) { if (res) res.get_haar('y',invert,1).transfer_to(res); else get_haar('y',invert,1).transfer_to(res); }

         if (depth>1) { if (res) res.get_haar('z',invert,1).transfer_to(res); else get_haar('z',invert,1).transfer_to(res); }

         if (res) return res;

       } else { // Multi-scale transform

         if (invert) { // Inverse transform

           res.assign(*this);

           if (width>1) {

             if (height>1) {

               if (depth>1) {

                 unsigned int w = width, h = height, d = depth; for (unsigned int s=1; w && h && d && s<nb_scales; ++s) { w/=2; h/=2; d/=2; }

                 for (w=w?w:1, h=h?h:1, d=d?d:1; w<=width && h<=height && d<=depth; w*=2, h*=2, d*=2)

                   res.draw_image(res.get_crop(0,0,0,w-1,h-1,d-1).get_haar(true,1));

               } else {

                 unsigned int w = width, h = height; for (unsigned int s=1; w && h && s<nb_scales; ++s) { w/=2; h/=2; }

                 for (w=w?w:1, h=h?h:1; w<=width && h<=height; w*=2, h*=2)

                   res.draw_image(res.get_crop(0,0,0,w-1,h-1,0).get_haar(true,1));

               }

             } else {

               if (depth>1) {

                 unsigned int w = width, d = depth; for (unsigned int s=1; w && d && s<nb_scales; ++s) { w/=2; d/=2; }

                 for (w=w?w:1, d=d?d:1; w<=width && d<=depth; w*=2, d*=2)

                   res.draw_image(res.get_crop(0,0,0,w-1,0,d-1).get_haar(true,1));

               } else {

                 unsigned int w = width; for (unsigned int s=1; w && s<nb_scales; ++s) w/=2;

                 for (w=w?w:1; w<=width; w*=2)

                   res.draw_image(res.get_crop(0,0,0,w-1,0,0).get_haar(true,1));

               }

             }

           } else {

             if (height>1) {

               if (depth>1) {

                 unsigned int h = height, d = depth; for (unsigned int s=1; h && d && s<nb_scales; ++s) { h/=2; d/=2; }

                 for (h=h?h:1, d=d?d:1; h<=height && d<=depth; h*=2, d*=2)

                   res.draw_image(res.get_crop(0,0,0,0,h-1,d-1).get_haar(true,1));

               } else {

                 unsigned int h = height; for (unsigned int s=1; h && s<nb_scales; ++s) h/=2;

                 for (h=h?h:1; h<=height; h*=2)

                   res.draw_image(res.get_crop(0,0,0,0,h-1,0).get_haar(true,1));

               }

             } else {

               if (depth>1) {

                 unsigned int d = depth; for (unsigned int s=1; d && s<nb_scales; ++s) d/=2;

                 for (d=d?d:1; d<=depth; d*=2)

                   res.draw_image(res.get_crop(0,0,0,0,0,d-1).get_haar(true,1));

               } else return *this;

             }

           }

         } else { // Direct transform

           res = get_haar(false,1);

           if (width>1) {

             if (height>1) {

               if (depth>1) for (unsigned int s=1, w=width/2, h=height/2, d=depth/2; w && h && d && s<nb_scales; ++s, w/=2, h/=2, d/=2)

                 res.draw_image(res.get_crop(0,0,0,w-1,h-1,d-1).haar(false,1));

               else for (unsigned int s=1, w=width/2, h=height/2; w && h && s<nb_scales; ++s, w/=2, h/=2)

                 res.draw_image(res.get_crop(0,0,0,w-1,h-1,0).haar(false,1));

             } else {

               if (depth>1) for (unsigned int s=1, w=width/2, d=depth/2; w && d && s<nb_scales; ++s, w/=2, d/=2)

                 res.draw_image(res.get_crop(0,0,0,w-1,0,d-1).haar(false,1));

               else for (unsigned int s=1, w=width/2; w && s<nb_scales; ++s, w/=2)

                 res.draw_image(res.get_crop(0,0,0,w-1,0,0).haar(false,1));

             }

           } else {

             if (height>1) {

               if (depth>1) for (unsigned int s=1, h=height/2, d=depth/2; h && d && s<nb_scales; ++s, h/=2, d/=2)

                 res.draw_image(res.get_crop(0,0,0,0,h-1,d-1).haar(false,1));

               else for (unsigned int s=1, h=height/2; h && s<nb_scales; ++s, h/=2)

                 res.draw_image(res.get_crop(0,0,0,0,h-1,0).haar(false,1));

             } else {

               if (depth>1) for (unsigned int s=1, d=depth/2; d && s<nb_scales; ++s, d/=2)

                 res.draw_image(res.get_crop(0,0,0,0,0,d-1).haar(false,1));

               else return *this;

             }

           }

         }

         return res;

       }

       return *this;

     }


     CImgList<Tfloat> get_FFT(const char axis, const bool invert=false) const {

       CImgList<Tfloat> res(*this,CImg<Tfloat>());

       CImg<Tfloat>::FFT(res[0],res[1],axis,invert);

       return res;

     }


     CImgList<Tfloat> get_FFT(const bool invert=false) const {

       CImgList<Tfloat> res(*this,CImg<Tfloat>());

       CImg<Tfloat>::FFT(res[0],res[1],invert);

       return res;

     }


     static void FFT(CImg<T>& real, CImg<T>& imag, const char axis, const bool invert=false) {

       if (!real) throw CImgInstanceException("CImg<%s>::FFT() : Input real image is empty.",pixel_type());

       if (!imag) imag.assign(real.width,real.height,real.depth,real.dim,0);

       if (!real.is_sameXYZV(imag))

         throw CImgInstanceException("CImg<%s>::FFT() : Real image (%u,%u,%u,%u,%p) and imaginary image (%u,%u,%u,%u,%p) "

                                     "have different dimensions",

                                     pixel_type(),real.width,real.height,real.depth,real.dim,real.data,

                                     imag.width,imag.height,imag.depth,imag.dim,imag.data);

 #ifdef cimg_use_fftw3

       fftw_complex *data_in;

       fftw_plan data_plan;


       switch (cimg::uncase(axis)) {

       case 'x' : { // Fourier along X, using FFTW library.

         data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*real.width);

         data_plan = fftw_plan_dft_1d(real.width,data_in,data_in,invert?FFTW_BACKWARD:FFTW_FORWARD,FFTW_ESTIMATE);

         cimg_forYZV(real,y,z,k) {

           T *ptrr = real.ptr(0,y,z,k), *ptri = imag.ptr(0,y,z,k);

           double *ptrd = (double*)data_in;

           cimg_forX(real,x) { *(ptrd++) = (double)*(ptrr++); *(ptrd++) = (double)*(ptri++); }

           fftw_execute(data_plan);

           const unsigned int fact = real.width;

           if (invert) cimg_forX(real,x) { *(--ptri) = (T)(*(--ptrd)/fact); *(--ptrr) = (T)(*(--ptrd)/fact); }

           else cimg_forX(real,x) { *(--ptri) = (T)*(--ptrd); *(--ptrr) = (T)*(--ptrd); }

         }

       } break;

       case 'y' : { // Fourier along Y, using FFTW library.

         data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * real.height);

         data_plan = fftw_plan_dft_1d(real.height,data_in,data_in,invert?FFTW_BACKWARD:FFTW_FORWARD,FFTW_ESTIMATE);

         const unsigned int off = real.width;

         cimg_forXZV(real,x,z,k) {

           T *ptrr = real.ptr(x,0,z,k), *ptri = imag.ptr(x,0,z,k);

           double *ptrd = (double*)data_in;

           cimg_forY(real,y) { *(ptrd++) = (double)*ptrr; *(ptrd++) = (double)*ptri; ptrr+=off; ptri+=off; }

           fftw_execute(data_plan);

           const unsigned int fact = real.height;

           if (invert) cimg_forY(real,y) { ptrr-=off; ptri-=off; *ptri = (T)(*(--ptrd)/fact); *ptrr = (T)(*(--ptrd)/fact); }

           else cimg_forY(real,y) { ptrr-=off; ptri-=off; *ptri = (T)*(--ptrd); *ptrr = (T)*(--ptrd); }

         }

       } break;

       case 'z' : { // Fourier along Z, using FFTW library.

         data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * real.depth);

         data_plan = fftw_plan_dft_1d(real.depth,data_in,data_in,invert?FFTW_BACKWARD:FFTW_FORWARD,FFTW_ESTIMATE);

         const unsigned int off = real.width*real.height;

         cimg_forXYV(real,x,y,k) {

           T *ptrr = real.ptr(x,y,0,k), *ptri = imag.ptr(x,y,0,k);

           double *ptrd = (double*)data_in;

           cimg_forZ(real,z) { *(ptrd++) = (double)*ptrr; *(ptrd++) = (double)*ptri; ptrr+=off; ptri+=off; }

           fftw_execute(data_plan);

           const unsigned int fact = real.depth;

           if (invert) cimg_forZ(real,z) { ptrr-=off; ptri-=off; *ptri = (T)(*(--ptrd)/fact); *ptrr = (T)(*(--ptrd)/fact); }

           else cimg_forZ(real,z) { ptrr-=off; ptri-=off; *ptri = (T)*(--ptrd); *ptrr = (T)*(--ptrd); }

         }

       } break;

       case 'v' : { // Fourier along V, using FFTW library.

         data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * real.dim);

         data_plan = fftw_plan_dft_1d(real.dim,data_in,data_in,invert?FFTW_BACKWARD:FFTW_FORWARD,FFTW_ESTIMATE);

         const unsigned int off = real.width*real.height*real.depth;

         cimg_forXYZ(real,x,y,z) {

           T *ptrr = real.ptr(x,y,z,0), *ptri = imag.ptr(x,y,z,0);

           double *ptrd = (double*)data_in;

           cimg_forV(real,k) { *(ptrd++) = (double)*ptrr; *(ptrd++) = (double)*ptri; ptrr+=off; ptri+=off; }

           fftw_execute(data_plan);

           const unsigned int fact = real.dim;

           if (invert) cimg_forV(real,k) { ptrr-=off; ptri-=off; *ptri = (T)(*(--ptrd)/fact); *ptrr = (T)(*(--ptrd)/fact); }

           else cimg_forV(real,k) { ptrr-=off; ptri-=off; *ptri = (T)*(--ptrd); *ptrr = (T)*(--ptrd); }

         }

       } break;

       }

       fftw_destroy_plan(data_plan);

       fftw_free(data_in);

 #else

       switch (cimg::uncase(axis)) {

       case 'x' : { // Fourier along X, using built-in functions.

         const unsigned int N = real.width, N2 = (N>>1);

         if (((N-1)&N) && N!=1)

           throw CImgInstanceException("CImgList<%s>::FFT() : Dimension of instance image along 'x' is %d != 2^N",

                                       pixel_type(),N);

         for (unsigned int i = 0, j = 0; i<N2; ++i) {

           if (j>i) cimg_forYZV(real,y,z,v) { cimg::swap(real(i,y,z,v),real(j,y,z,v)); cimg::swap(imag(i,y,z,v),imag(j,y,z,v));

           if (j<N2) {

             const unsigned int ri = N-1-i, rj = N-1-j;

             cimg::swap(real(ri,y,z,v),real(rj,y,z,v)); cimg::swap(imag(ri,y,z,v),imag(rj,y,z,v));

           }}

           for (unsigned int m = N, n = N2; (j+=n)>=m; j-=m, m = n, n>>=1) {}

         }

         for (unsigned int delta = 2; delta<=N; delta<<=1) {

           const unsigned int delta2 = (delta>>1);

           for (unsigned int i = 0; i<N; i+=delta) {

             float wr = 1, wi = 0;

             const float angle = (float)((invert?+1:-1)*2*cimg::valuePI/delta),

                         ca = (float)std::cos(angle),

                         sa = (float)std::sin(angle);

             for (unsigned int k = 0; k<delta2; ++k) {

               const unsigned int j = i + k, nj = j + delta2;

               cimg_forYZV(real,y,z,k) {

                 T &ir = real(j,y,z,k), &ii = imag(j,y,z,k), &nir = real(nj,y,z,k), &nii = imag(nj,y,z,k);

                 const float tmpr = (float)(wr*nir - wi*nii), tmpi = (float)(wr*nii + wi*nir);

                 nir = (T)(ir - tmpr);

                 nii = (T)(ii - tmpi);

                 ir += (T)tmpr;

                 ii += (T)tmpi;

               }

               const float nwr = wr*ca-wi*sa;

               wi = wi*ca + wr*sa;

               wr = nwr;

             }

           }

         }

         if (invert) { real/=N; imag/=N; }

       } break;

       case 'y' : { // Fourier along Y, using built-in functions.

         const unsigned int N = real.height, N2 = (N>>1);

         if (((N-1)&N) && N!=1)

           throw CImgInstanceException("CImgList<%s>::FFT() : Dimension of instance image(s) along 'y' is %d != 2^N",

                                       pixel_type(),N);

         for (unsigned int i = 0, j = 0; i<N2; ++i) {

           if (j>i) cimg_forXZV(real,x,z,v) { cimg::swap(real(x,i,z,v),real(x,j,z,v)); cimg::swap(imag(x,i,z,v),imag(x,j,z,v));

           if (j<N2) {

             const unsigned int ri = N-1-i, rj = N-1-j;

             cimg::swap(real(x,ri,z,v),real(x,rj,z,v)); cimg::swap(imag(x,ri,z,v),imag(x,rj,z,v));

           }}

           for (unsigned int m = N, n = N2; (j+=n)>=m; j-=m, m = n, n>>=1) {}

         }

         for (unsigned int delta = 2; delta<=N; delta<<=1) {

           const unsigned int delta2 = (delta>>1);

           for (unsigned int i = 0; i<N; i+=delta) {

             float wr = 1, wi = 0;

             const float angle = (float)((invert?+1:-1)*2*cimg::valuePI/delta),

                         ca = (float)std::cos(angle), sa = (float)std::sin(angle);

             for (unsigned int k = 0; k<delta2; ++k) {

               const unsigned int j = i + k, nj = j + delta2;

               cimg_forXZV(real,x,z,k) {

                 T &ir = real(x,j,z,k), &ii = imag(x,j,z,k), &nir = real(x,nj,z,k), &nii = imag(x,nj,z,k);

                 const float tmpr = (float)(wr*nir - wi*nii), tmpi = (float)(wr*nii + wi*nir);

                 nir = (T)(ir - tmpr);

                 nii = (T)(ii - tmpi);

                 ir += (T)tmpr;

                 ii += (T)tmpi;

               }

               const float nwr = wr*ca-wi*sa;

               wi = wi*ca + wr*sa;

               wr = nwr;

             }

           }

         }

         if (invert) { real/=N; imag/=N; }

       } break;

       case 'z' : { // Fourier along Z, using built-in functions.

         const unsigned int N = real.depth, N2 = (N>>1);

         if (((N-1)&N) && N!=1)

           throw CImgInstanceException("CImgList<%s>::FFT() : Dimension of instance image(s) along 'z' is %d != 2^N",

                                       pixel_type(),N);

         for (unsigned int i = 0, j = 0; i<N2; ++i) {

           if (j>i) cimg_forXYV(real,x,y,v) { cimg::swap(real(x,y,i,v),real(x,y,j,v)); cimg::swap(imag(x,y,i,v),imag(x,y,j,v));

           if (j<N2) {

             const unsigned int ri = N-1-i, rj = N-1-j;

             cimg::swap(real(x,y,ri,v),real(x,y,rj,v)); cimg::swap(imag(x,y,ri,v),imag(x,y,rj,v));

           }}

           for (unsigned int m = N, n = N2; (j+=n)>=m; j-=m, m = n, n>>=1) {}

         }

         for (unsigned int delta = 2; delta<=N; delta<<=1) {

           const unsigned int delta2 = (delta>>1);

           for (unsigned int i = 0; i<N; i+=delta) {

             float wr = 1, wi = 0;

             const float angle = (float)((invert?+1:-1)*2*cimg::valuePI/delta),

                         ca = (float)std::cos(angle), sa = (float)std::sin(angle);

             for (unsigned int k = 0; k<delta2; ++k) {

               const unsigned int j = i + k, nj = j + delta2;

               cimg_forXYV(real,x,y,k) {

                 T &ir = real(x,y,j,k), &ii = imag(x,y,j,k), &nir = real(x,y,nj,k), &nii = imag(x,y,nj,k);

                 const float tmpr = (float)(wr*nir - wi*nii), tmpi = (float)(wr*nii + wi*nir);

                 nir = (T)(ir - tmpr);

                 nii = (T)(ii - tmpi);

                 ir += (T)tmpr;

                 ii += (T)tmpi;

               }

               const float nwr = wr*ca-wi*sa;

               wi = wi*ca + wr*sa;

               wr = nwr;

             }

           }

         }

         if (invert) { real/=N; imag/=N; }

       } break;

       default :

         throw CImgArgumentException("CImgList<%s>::FFT() : Invalid axis '%c', must be 'x','y' or 'z'.");

       }

 #endif

     }


     static void FFT(CImg<T>& real, CImg<T>& imag, const bool invert=false) {

       if (!real) throw CImgInstanceException("CImgList<%s>::FFT() : Input real image is empty.",pixel_type());

       if (!imag) imag.assign(real.width,real.height,real.depth,real.dim,0);

       if (!real.is_sameXYZV(imag))

         throw CImgInstanceException("CImgList<%s>::FFT() : Real image (%u,%u,%u,%u,%p) and imaginary image (%u,%u,%u,%u,%p) "

                                     "have different dimensions",

                                     pixel_type(),real.width,real.height,real.depth,real.dim,real.data,

                                     imag.width,imag.height,imag.depth,imag.dim,imag.data);

 #ifdef cimg_use_fftw3

       fftw_complex *data_in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex)*real.width*real.height*real.depth);

       fftw_plan data_plan;

       const unsigned int w = real.width, wh = w*real.height, whd = wh*real.depth;

       data_plan = fftw_plan_dft_3d(real.width,real.height,real.depth,data_in,data_in,invert?FFTW_BACKWARD:FFTW_FORWARD,FFTW_ESTIMATE);

       cimg_forV(real,k) {

         T *ptrr = real.ptr(0,0,0,k), *ptri = imag.ptr(0,0,0,k);

         double *ptrd = (double*)data_in;

         for (unsigned int x = 0; x<real.width; ++x, ptrr-=wh-1, ptri-=wh-1)

           for (unsigned int y = 0; y<real.height; ++y, ptrr-=whd-w, ptri-=whd-w)

             for (unsigned int z = 0; z<real.depth; ++z, ptrr+=wh, ptri+=wh) {

               *(ptrd++) = (double)*ptrr; *(ptrd++) = (double)*ptri;

             }

         fftw_execute(data_plan);

         ptrd = (double*)data_in;

         ptrr = real.ptr(0,0,0,k);

         ptri = imag.ptr(0,0,0,k);

         if (!invert) for (unsigned int x = 0; x<real.width; ++x, ptrr-=wh-1, ptri-=wh-1)

           for (unsigned int y = 0; y<real.height; ++y, ptrr-=whd-w, ptri-=whd-w)

             for (unsigned int z = 0; z<real.depth; ++z, ptrr+=wh, ptri+=wh) {

               *ptrr = (T)*(ptrd++); *ptri = (T)*(ptrd++);

             }

         else for (unsigned int x = 0; x<real.width; ++x, ptrr-=wh-1, ptri-=wh-1)

           for (unsigned int y = 0; y<real.height; ++y, ptrr-=whd-w, ptri-=whd-w)

             for (unsigned int z = 0; z<real.depth; ++z, ptrr+=wh, ptri+=wh) {

               *ptrr = (T)(*(ptrd++)/whd); *ptri = (T)(*(ptrd++)/whd);

             }

       }

       fftw_destroy_plan(data_plan);

       fftw_free(data_in);

 #else

       if (real.depth>1)  FFT(real,imag,'z',invert);

       if (real.height>1) FFT(real,imag,'y',invert);

       if (real.width>1)  FFT(real,imag,'x',invert);

 #endif

     }


     //-------------------------------------

     //


     //-------------------------------------


     CImg<T>& translate_object3d(const float tx, const float ty=0, const float tz=0) {

       if (is_empty()) return *this;

       if (height!=3 || depth>1 || dim>1)

         throw CImgInstanceException("CImg<%s>::translate_object3d() : Instance image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),width,height,depth,dim,data);

       get_shared_line(0)+=tx; get_shared_line(1)+=ty; get_shared_line(2)+=tz;

       return *this;

     }


     CImg<Tfloat> get_translate_object3d(const float tx, const float ty=0, const float tz=0) const {

       return CImg<Tfloat>(*this,false).translate_object3d(tx,ty,tz);

     }


     CImg<T>& translate_object3d() {

       if (is_empty()) return *this;

       if (height!=3 || depth>1 || dim>1)

         throw CImgInstanceException("CImg<%s>::translate_object3d() : Instance image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),width,height,depth,dim,data);

       CImg<T> xcoords = get_shared_line(0), ycoords = get_shared_line(1), zcoords = get_shared_line(2);

       float xm, xM = (float)xcoords.maxmin(xm), ym, yM = (float)ycoords.maxmin(ym), zm, zM = (float)zcoords.maxmin(zm);

       xcoords-=(xm + xM)/2; ycoords-=(ym + yM)/2; zcoords-=(zm + zM)/2;

       return *this;

     }


     CImg<Tfloat> get_translate_object3d() const {

       return CImg<Tfloat>(*this,false).translate_object3d();

     }


     CImg<T>& resize_object3d(const float sx, const float sy=-100, const float sz=-100) {

       if (is_empty()) return *this;

       if (height!=3 || depth>1 || dim>1)

         throw CImgInstanceException("CImg<%s>::resize_object3d() : Instance image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),width,height,depth,dim,data);

       CImg<T> xcoords = get_shared_line(0), ycoords = get_shared_line(1), zcoords = get_shared_line(2);

       float xm, xM = (float)xcoords.maxmin(xm), ym, yM = (float)ycoords.maxmin(ym), zm, zM = (float)zcoords.maxmin(zm);

       if (xm<xM) { if (sx>0) xcoords*=sx/(xM-xm); else xcoords*=-sx/100; }

       if (ym<yM) { if (sy>0) ycoords*=sy/(yM-ym); else ycoords*=-sy/100; }

       if (zm<zM) { if (sz>0) zcoords*=sz/(zM-zm); else zcoords*=-sz/100; }

       return *this;

     }


     CImg<Tfloat> get_resize_object3d(const float sx, const float sy=-100, const float sz=-100) const {

       return CImg<Tfloat>(*this,false).resize_object3d(sx,sy,sz);

     }


     CImg<T> resize_object3d() const {

       if (is_empty()) return *this;

       if (height!=3 || depth>1 || dim>1)

         throw CImgInstanceException("CImg<%s>::resize_object3d() : Instance image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),width,height,depth,dim,data);

       CImg<T> xcoords = get_shared_line(0), ycoords = get_shared_line(1), zcoords = get_shared_line(2);

       float xm, xM = (float)xcoords.maxmin(xm), ym, yM = (float)ycoords.maxmin(ym), zm, zM = (float)zcoords.maxmin(zm);

       const float dx = xM - xm, dy = yM - ym, dz = zM - zm, dmax = cimg::max(dx,dy,dz);

       if (dmax>0) { xcoords/=dmax; ycoords/=dmax; zcoords/=dmax; }

       return *this;

     }


     CImg<Tfloat> get_resize_object3d() const {

       return CImg<Tfloat>(*this,false).resize_object3d();

     }


     template<typename tf, typename tp, typename tff>

     CImg<T>& append_object3d(CImgList<tf>& primitives, const CImg<tp>& obj_vertices, const CImgList<tff>& obj_primitives) {

       if (!obj_vertices || !obj_primitives) return *this;

       if (obj_vertices.height!=3 || obj_vertices.depth>1 || obj_vertices.dim>1)

         throw CImgInstanceException("CImg<%s>::append_object3d() : Vertice image argument (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),obj_vertices.width,obj_vertices.height,obj_vertices.depth,obj_vertices.dim,obj_vertices.data);

       if (is_empty()) { primitives.assign(obj_primitives); return assign(obj_vertices); }

       if (height!=3 || depth>1 || dim>1)

         throw CImgInstanceException("CImg<%s>::append_object3d() : Instance image (%u,%u,%u,%u,%p) is not a set of 3D vertices.",

                                     pixel_type(),width,height,depth,dim,data);

       const unsigned int P = width;

       append(obj_vertices,'x');

       const unsigned int N = primitives.width;

       primitives.insert(obj_primitives);

       for (unsigned int i = N; i<primitives.width; ++i) {

         CImg<tf> &p = primitives[i];

         switch (p.size()) {

         case 1 : p[0]+=P; break; // Point.

         case 5 : p[0]+=P; if (!p[2]) p[1]+=P; break; // Sphere.

         case 2 : case 6 : p[0]+=P; p[1]+=P; break; // Segment.

         case 3 : case 9 : p[0]+=P; p[1]+=P; p[2]+=P; break; // Triangle.

         case 4 : case 12 : p[0]+=P; p[1]+=P; p[2]+=P; p[3]+=P; break; // Rectangle.

         }

       }

       return *this;

     }


     template<typename tf, typename tc, typename te>

     CImg<floatT> get_elevation3d(CImgList<tf>& primitives, CImgList<tc>& colors, const CImg<te>& elevation) const {

       if (is_empty()) return *this;

       if (!is_sameXY(elevation) || elevation.depth>1 || elevation.dim>1)

         throw CImgArgumentException("CImg<%s>::get_elevation3d() : Elevation image (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) "

                                     "have incompatible sizes.",pixel_type(),

                                     elevation.width,elevation.height,elevation.depth,elevation.dim,elevation.data,

                                     width,height,depth,dim,data,pixel_type());

       float m, M = (float)maxmin(m);

       if (M==m) ++M;

       colors.assign();

       const unsigned int size_x1 = width - 1, size_y1 = height - 1;

       for (unsigned int y = 0; y<size_y1; ++y)

         for (unsigned int x = 0; x<size_x1; x++) {

           const unsigned char

             r = (unsigned char)(((*this)(x,y,0) - m)*255/(M-m)),

             g = dim>1?(unsigned char)(((*this)(x,y,1) - m)*255/(M-m)):r,

             b = dim>2?(unsigned char)(((*this)(x,y,2) - m)*255/(M-m)):(dim>1?0:r);

           CImg<tc>::vector((tc)r,(tc)g,(tc)b).transfer_to(colors);

         }

       const typename CImg<te>::_marching2d_func func(elevation);

       return elevation3d(primitives,func,0,0,width-1.0f,height-1.0f,width,height);

     }


     template<typename tf>

     CImg<floatT> get_isocurve3d(CImgList<tf>& primitives,

                                 const float isovalue, const int size_x=-100, const int size_y=-100) const {

       if (dim>1)

         throw CImgInstanceException("CImg<%s>::get_isocurve3d() : Instance image (%u,%u,%u,%u,%p) is not scalar.",

                                     pixel_type(),width,height,depth,dim,data);

       primitives.assign();

       if (is_empty()) return *this;

       CImg<floatT> vertices;

       if ((size_x==-100 && size_y==-100) || (size_x==dimx() && size_y==dimy())) {

         const _marching2d_func func(*this);

         vertices = isocurve3d(primitives,func,isovalue,0,0,dimx()-1.0f,dimy()-1.0f,size_x,size_y);

       } else {

         const _marching2d_func_float func(*this);

         vertices = isocurve3d(primitives,func,isovalue,0,0,dimx()-1.0f,dimy()-1.0f,size_x,size_y);

       }

       return vertices;

     }


     template<typename tf>

     CImg<floatT> get_isosurface3d(CImgList<tf>& primitives, const float isovalue,

                                   const int size_x=-100, const int size_y=-100, const int size_z=-100) const {

       if (dim>1)

         throw CImgInstanceException("CImg<%s>::get_isosurface3d() : Instance image (%u,%u,%u,%u,%p) is not scalar.",

                                     pixel_type(),width,height,depth,dim,data);

       primitives.assign();

       if (is_empty()) return *this;

       CImg<floatT> vertices;

       if ((size_x==-100 && size_y==-100 && size_z==-100) || (size_x==dimx() && size_y==dimy() && size_z==dimz())) {

         const _marching3d_func func(*this);

         vertices = isosurface3d(primitives,func,isovalue,0,0,0,dimx()-1.0f,dimy()-1.0f,dimz()-1.0f,size_x,size_y,size_z);

       } else {

         const _marching3d_func_float func(*this);

         vertices = isosurface3d(primitives,func,isovalue,0,0,0,dimx()-1.0f,dimy()-1.0f,dimz()-1.0f,size_x,size_y,size_z);

       }

       return vertices;

     }


     template<typename tf, typename tfunc>

     static CImg<floatT> elevation3d(CImgList<tf>& primitives, const tfunc& func,

                                     const float x0, const float y0, const float x1, const float y1,

                                     const int size_x=256, const int size_y=256) {

       const float

         nx0 = x0<x1?x0:x1, ny0 = y0<y1?y0:y1,

         nx1 = x0<x1?x1:x0, ny1 = y0<y1?y1:y0;

       const unsigned int

         _nsize_x = (unsigned int)(size_x>=0?size_x:(nx1-nx0)*-size_x/100), nsize_x = _nsize_x?_nsize_x:1, nsize_x1 = nsize_x - 1,

         _nsize_y = (unsigned int)(size_y>=0?size_y:(ny1-ny0)*-size_y/100), nsize_y = _nsize_y?_nsize_y:1, nsize_y1 = nsize_y - 1;

       if (nsize_x<2 || nsize_y<2)

         throw CImgArgumentException("CImg<%s>::elevation3d() : Invalid requested size (%d,%d).",

                                     pixel_type(),nsize_x,nsize_y);

       CImg<floatT> vertices(nsize_x*nsize_y,3);

       floatT *ptr_x = vertices.ptr(0,0), *ptr_y = vertices.ptr(0,1), *ptr_z = vertices.ptr(0,2);

       for (unsigned int y = 0; y<nsize_y; ++y) {

         const float Y = ny0 + y*(ny1-ny0)/nsize_y1;

         for (unsigned int x = 0; x<nsize_x; ++x) {

           const float X = nx0 + x*(nx1-nx0)/nsize_x1;

           *(ptr_x++) = (float)x;

           *(ptr_y++) = (float)y;

           *(ptr_z++) = (float)func(X,Y);

         }

       }

       primitives.assign(nsize_x1*nsize_y1,1,4);

       for (unsigned int p = 0, y = 0; y<nsize_y1; ++y) {

         const unsigned int yw = y*nsize_x;

         for (unsigned int x = 0; x<nsize_x1; ++x) {

           const unsigned int xpyw = x + yw, xpyww = xpyw + nsize_x;

           primitives[p++].fill(xpyw,xpyww,xpyww+1,xpyw+1);

         }

       }

       return vertices;

     }


     template<typename tf>

     static CImg<floatT> elevation3d(CImgList<tf>& primitives, const char *const expression,

                                     const float x0, const float y0, const float x1, const float y1,

                                     const int sizex=256, const int sizey=256) {

       const _marching2d_func_expr func(expression);

       return elevation3d(primitives,func,x0,y0,x1,y1,sizex,sizey);

     }


     template<typename tf, typename tfunc>

     static CImg<floatT> isocurve3d(CImgList<tf>& primitives, const tfunc& func, const float isovalue,

                                    const float x0, const float y0, const float x1, const float y1,

                                    const int sizex=256, const int sizey=256) {

       static const unsigned int edges[16] = { 0x0, 0x9, 0x3, 0xa, 0x6, 0xf, 0x5, 0xc, 0xc, 0x5, 0xf, 0x6, 0xa, 0x3, 0x9, 0x0 };

       static const int segments[16][4] = { { -1,-1,-1,-1 }, { 0,3,-1,-1 }, { 0,1,-1,-1 }, { 1,3,-1,-1 },

                                            { 1,2,-1,-1 },   { 0,1,2,3 },   { 0,2,-1,-1 }, { 2,3,-1,-1 },

                                            { 2,3,-1,-1 },   { 0,2,-1,-1},  { 0,3,1,2 },   { 1,2,-1,-1 },

                                            { 1,3,-1,-1 },   { 0,1,-1,-1},  { 0,3,-1,-1},  { -1,-1,-1,-1 } };

       const unsigned int

         _nx = (unsigned int)(sizex>=0?sizex:((x1-x0)*-sizex/100 + 1)),

         _ny = (unsigned int)(sizey>=0?sizey:((y1-y0)*-sizey/100 + 1)),

         nx = _nx?_nx:1,

         ny = _ny?_ny:1,

         nxm1 = nx - 1,

         nym1 = ny - 1;

       primitives.assign();

       if (!nxm1 || !nym1) return CImg<floatT>();

       const float dx = (x1 - x0)/nxm1, dy = (y1 - y0)/nym1;

       CImgList<floatT> vertices;

       CImg<intT> indices1(nx,1,1,2,-1), indices2(nx,1,1,2);

       CImg<floatT> values1(nx), values2(nx);

       float X = x0, Y = y0, nX = X + dx, nY = Y + dy;


       // Fill first line with values

       cimg_forX(values1,x) { values1(x) = (float)func(X,Y); X+=dx; }


       // Run the marching squares algorithm

       for (unsigned int yi = 0, nyi = 1; yi<nym1; ++yi, ++nyi, Y=nY, nY+=dy) {

         X = x0; nX = X + dx;

         indices2.fill(-1);

         for (unsigned int xi = 0, nxi = 1; xi<nxm1; ++xi, ++nxi, X=nX, nX+=dx) {


           // Determine square configuration

           const float

             val0 = values1(xi),

             val1 = values1(nxi),

             val2 = values2(nxi) = (float)func(nX,nY),

             val3 = values2(xi) = (float)func(X,nY);

           const unsigned int

             configuration = (val0<isovalue?1:0)  | (val1<isovalue?2:0)  | (val2<isovalue?4:0)  | (val3<isovalue?8:0),

             edge = edges[configuration];


           // Compute intersection vertices

           if (edge) {

             if ((edge&1) && indices1(xi,0)<0) {

               const float Xi = X + (isovalue-val0)*dx/(val1-val0);

               indices1(xi,0) = vertices.width;

               CImg<floatT>::vector(Xi,Y,0).transfer_to(vertices);

             }

             if ((edge&2) && indices1(nxi,1)<0) {

               const float Yi = Y + (isovalue-val1)*dy/(val2-val1);

               indices1(nxi,1) = vertices.width;

               CImg<floatT>::vector(nX,Yi,0).transfer_to(vertices);

             }

             if ((edge&4) && indices2(xi,0)<0) {

               const float Xi = X + (isovalue-val3)*dx/(val2-val3);

               indices2(xi,0) = vertices.width;

               CImg<floatT>::vector(Xi,nY,0).transfer_to(vertices);

             }

             if ((edge&8) && indices1(xi,1)<0) {

               const float Yi = Y + (isovalue-val0)*dy/(val3-val0);

               indices1(xi,1) = vertices.width;

               CImg<floatT>::vector(X,Yi,0).transfer_to(vertices);

             }


             // Create segments

             for (const int *segment = segments[configuration]; *segment!=-1; ) {

               const unsigned int p0 = *(segment++), p1 = *(segment++);

               const tf

                 i0 = (tf)(_marching2d_indice(p0,indices1,indices2,xi,nxi)),

                 i1 = (tf)(_marching2d_indice(p1,indices1,indices2,xi,nxi));

               CImg<tf>::vector(i0,i1).transfer_to(primitives);

             }

           }

         }

         values1.swap(values2);

         indices1.swap(indices2);

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> isocurve3d(CImgList<tf>& primitives, const char *const expression, const float isovalue,

                                    const float x0, const float y0, const float x1, const float y1,

                                    const int sizex=256, const int sizey=256) {

       const _marching2d_func_expr func(expression);

       return isocurve3d(primitives,func,isovalue,x0,y0,x1,y1,sizex,sizey);

     }


     template<typename t>

     static int _marching2d_indice(const unsigned int edge, const CImg<t>& indices1, const CImg<t>& indices2,

                                   const unsigned int x, const unsigned int nx) {

       switch (edge) {

       case 0 : return (int)indices1(x,0);

       case 1 : return (int)indices1(nx,1);

       case 2 : return (int)indices2(x,0);

       case 3 : return (int)indices1(x,1);

       }

       return 0;

     }


     struct _marching2d_func {

       const CImg<T>& ref;

       _marching2d_func(const CImg<T>& pref):ref(pref) {}

       float operator()(const float x, const float y) const {

         return (float)ref((int)x,(int)y);

       }

     };


     struct _marching2d_func_float {

       const CImg<T>& ref;

       _marching2d_func_float(const CImg<T>& pref):ref(pref) {}

       float operator()(const float x, const float y) const {

         return (float)ref._linear_atXY(x,y);

       }

     };


     struct _marching2d_func_expr {

       _cimg_math_parser *mp;

       _marching2d_func_expr(const char *const expr):mp(0) {

         mp = new _cimg_math_parser(expr,"isovalue2d");

       }

       float operator()(const float x, const float y) const {

         return (float)mp->eval(x,y,0,0);

       }

       ~_marching2d_func_expr() {

         if (mp) delete mp;

       }

     };


     template<typename tf, typename tfunc>

     static CImg<floatT> isosurface3d(CImgList<tf>& primitives, 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 int size_x=32, const int size_y=32, const int size_z=32) {

       static unsigned int edges[256] = {

         0x000, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,

         0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,

         0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,

         0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,

         0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,

         0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,

         0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c, 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,

         0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc , 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,

         0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,

         0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,

         0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,

         0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,

         0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,

         0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,

         0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,

         0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x000 };


       static int triangles[256][16] =

         {{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1 },

          { 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1 },

          { 3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1 },

          { 3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1 }, { 9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1 }, { 2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1 },

          { 8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1 }, { 4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1 },

          { 3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1 }, { 1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1 },

          { 4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1 }, { 4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1 }, { 2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1 },

          { 9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1 }, { 2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1 },

          { 10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1 }, { 4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1 },

          { 5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1 }, { 5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1 }, { 1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1 }, { 10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1 },

          { 8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1 }, { 2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1 },

          { 7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1 }, { 9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1 },

          { 2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1 }, { 11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1 }, { 5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1 },

          { 11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1 }, { 11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1 }, { 5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1 },

          { 2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1 }, { 5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1 },

          { 6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1 },

          { 3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1 }, { 6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1 },

          { 5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1 }, { 10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1 },

          { 6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1 }, { 1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1 },

          { 8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1 }, { 7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1 },

          { 3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1 }, { 5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1 },

          { 0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1 }, { 9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1 },

          { 8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1 }, { 5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1 },

          { 0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1 }, { 6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1 },

          { 10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1 },

          { 10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1 }, { 8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1 },

          { 1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1 }, { 3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1 },

          { 0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1 },

          { 3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1 }, { 6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1 },

          { 9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1 }, { 8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1 },

          { 3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1 }, { 6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1 }, { 0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1 },

          { 10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1 }, { 10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1 }, { 2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1 },

          { 7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1 }, { 7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1 }, { 2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1 },

          { 1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1 }, { 11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1 },

          { 8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1 }, { 0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1 }, { 7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1 }, { 6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1 },

          { 7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1 }, { 1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1 },

          { 10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1 }, { 10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1 },

          { 0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1 }, { 7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1 },

          { 6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1 }, { 9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1 },

          { 6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1 }, { 1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1 },

          { 4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1 }, { 10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1 },

          { 8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1 }, { 0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1 }, { 1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1 }, { 10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1 },

          { 4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1 }, { 10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1 },

          { 5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1 }, { 11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1 },

          { 9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1 }, { 6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1 },

          { 7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1 }, { 3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1 },

          { 7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1 }, { 9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1 },

          { 3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1 }, { 6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1 },

          { 9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1 }, { 1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1 },

          { 4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1 }, { 7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1 },

          { 6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1 }, { 3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1 },

          { 0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1 }, { 6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1 }, { 0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1 },

          { 11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1 }, { 6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1 },

          { 5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1 }, { 9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1 }, { 1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1 }, { 10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1 },

          { 0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1 },

          { 5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1 }, { 10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1 },

          { 11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1 },

          { 9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1 }, { 7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1 },

          { 2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1 }, { 8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1 },

          { 9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1 }, { 9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1 },

          { 1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1 }, { 9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1 }, { 5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1 },

          { 0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1 }, { 10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1 },

          { 2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1 }, { 0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1 },

          { 0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1 }, { 9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1 }, { 5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1 },

          { 3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1 }, { 5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1 },

          { 8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1 }, { 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1 }, { 0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1 },

          { 1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1 }, { 3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1 },

          { 4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1 }, { 9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1 },

          { 11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1 }, { 11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1 },

          { 2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1 }, { 9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1 },

          { 3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1 }, { 1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1 }, { 4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1 },

          { 4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1 }, { 3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1 }, { 3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1 },

          { 0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1 }, { 9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1 }, { 1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { 0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },

          { 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }};


       const unsigned int

         _nx = (unsigned int)(size_x>=0?size_x:((x1-x0)*-size_x/100 + 1)),

         _ny = (unsigned int)(size_y>=0?size_y:((y1-y0)*-size_y/100 + 1)),

         _nz = (unsigned int)(size_z>=0?size_y:((z1-z0)*-size_z/100 + 1)),

         nx = _nx?_nx:1,

         ny = _ny?_ny:1,

         nz = _nz?_nz:1,

         nxm1 = nx - 1,

         nym1 = ny - 1,

         nzm1 = nz - 1;

       primitives.assign();

       if (!nxm1 || !nym1 || !nzm1) return CImg<floatT>();

       const float dx = (x1 - x0)/nxm1, dy = (y1 - y0)/nym1, dz = (z1 - z0)/nzm1;

       CImgList<floatT> vertices;

       CImg<intT> indices1(nx,ny,1,3,-1), indices2(indices1);

       CImg<floatT> values1(nx,ny), values2(nx,ny);

       float X = 0, Y = 0, Z = 0, nX = 0, nY = 0, nZ = 0;


       // Fill the first plane with function values

       Y = y0;

       cimg_forY(values1,y) {

         X = x0;

         cimg_forX(values1,x) { values1(x,y) = (float)func(X,Y,z0); X+=dx; }

         Y+=dy;

       }


       // Run Marching Cubes algorithm

       Z = z0; nZ = Z + dz;

       for (unsigned int zi = 0; zi<nzm1; ++zi, Z = nZ, nZ+=dz) {

         Y = y0; nY = Y + dy;

         indices2.fill(-1);

         for (unsigned int yi = 0, nyi = 1; yi<nym1; ++yi, ++nyi, Y = nY, nY+=dy) {

           X = x0; nX = X + dx;

           for (unsigned int xi = 0, nxi = 1; xi<nxm1; ++xi, ++nxi, X = nX, nX+=dx) {


             // Determine cube configuration

             const float

               val0 = values1(xi,yi),

               val1 = values1(nxi,yi),

               val2 = values1(nxi,nyi),

               val3 = values1(xi,nyi),

               val4 = values2(xi,yi) = (float)func(X,Y,nZ),

               val5 = values2(nxi,yi) = (float)func(nX,Y,nZ),

               val6 = values2(nxi,nyi) = (float)func(nX,nY,nZ),

               val7 = values2(xi,nyi) = (float)func(X,nY,nZ);


             const unsigned int configuration =

               (val0<isovalue?1:0)  | (val1<isovalue?2:0)  | (val2<isovalue?4:0)  | (val3<isovalue?8:0) |

               (val4<isovalue?16:0) | (val5<isovalue?32:0) | (val6<isovalue?64:0) | (val7<isovalue?128:0),

               edge = edges[configuration];


             // Compute intersection vertices

             if (edge) {

               if ((edge&1) && indices1(xi,yi,0)<0) {

                 const float Xi = X + (isovalue-val0)*dx/(val1-val0);

                 indices1(xi,yi,0) = vertices.width;

                 CImg<floatT>::vector(Xi,Y,Z).transfer_to(vertices);

               }

               if ((edge&2) && indices1(nxi,yi,1)<0) {

                 const float Yi = Y + (isovalue-val1)*dy/(val2-val1);

                 indices1(nxi,yi,1) = vertices.width;

                 CImg<floatT>::vector(nX,Yi,Z).transfer_to(vertices);

               }

               if ((edge&4) && indices1(xi,nyi,0)<0) {

                 const float Xi = X + (isovalue-val3)*dx/(val2-val3);

                 indices1(xi,nyi,0) = vertices.width;

                 CImg<floatT>::vector(Xi,nY,Z).transfer_to(vertices);

               }

               if ((edge&8) && indices1(xi,yi,1)<0) {

                 const float Yi = Y + (isovalue-val0)*dy/(val3-val0);

                 indices1(xi,yi,1) = vertices.width;

                 CImg<floatT>::vector(X,Yi,Z).transfer_to(vertices);

               }

               if ((edge&16) && indices2(xi,yi,0)<0) {

                 const float Xi = X + (isovalue-val4)*dx/(val5-val4);

                 indices2(xi,yi,0) = vertices.width;

                 CImg<floatT>::vector(Xi,Y,nZ).transfer_to(vertices);

               }

               if ((edge&32) && indices2(nxi,yi,1)<0) {

                 const float Yi = Y + (isovalue-val5)*dy/(val6-val5);

                 indices2(nxi,yi,1) = vertices.width;

                 CImg<floatT>::vector(nX,Yi,nZ).transfer_to(vertices);

               }

               if ((edge&64) && indices2(xi,nyi,0)<0) {

                 const float Xi = X + (isovalue-val7)*dx/(val6-val7);

                 indices2(xi,nyi,0) = vertices.width;

                 CImg<floatT>::vector(Xi,nY,nZ).transfer_to(vertices);

               }

               if ((edge&128) && indices2(xi,yi,1)<0)  {

                 const float Yi = Y + (isovalue-val4)*dy/(val7-val4);

                 indices2(xi,yi,1) = vertices.width;

                 CImg<floatT>::vector(X,Yi,nZ).transfer_to(vertices);

               }

               if ((edge&256) && indices1(xi,yi,2)<0) {

                 const float Zi = Z+ (isovalue-val0)*dz/(val4-val0);

                 indices1(xi,yi,2) = vertices.width;

                 CImg<floatT>::vector(X,Y,Zi).transfer_to(vertices);

               }

               if ((edge&512) && indices1(nxi,yi,2)<0)  {

                 const float Zi = Z + (isovalue-val1)*dz/(val5-val1);

                 indices1(nxi,yi,2) = vertices.width;

                 CImg<floatT>::vector(nX,Y,Zi).transfer_to(vertices);

               }

               if ((edge&1024) && indices1(nxi,nyi,2)<0) {

                 const float Zi = Z + (isovalue-val2)*dz/(val6-val2);

                 indices1(nxi,nyi,2) = vertices.width;

                 CImg<floatT>::vector(nX,nY,Zi).transfer_to(vertices);

               }

               if ((edge&2048) && indices1(xi,nyi,2)<0) {

                 const float Zi = Z + (isovalue-val3)*dz/(val7-val3);

                 indices1(xi,nyi,2) = vertices.width;

                 CImg<floatT>::vector(X,nY,Zi).transfer_to(vertices);

               }


               // Create triangles

               for (const int *triangle = triangles[configuration]; *triangle!=-1; ) {

                 const unsigned int p0 = *(triangle++), p1 = *(triangle++), p2 = *(triangle++);

                 const tf

                   i0 = (tf)(_marching3d_indice(p0,indices1,indices2,xi,yi,nxi,nyi)),

                   i1 = (tf)(_marching3d_indice(p1,indices1,indices2,xi,yi,nxi,nyi)),

                   i2 = (tf)(_marching3d_indice(p2,indices1,indices2,xi,yi,nxi,nyi));

                 CImg<tf>::vector(i0,i2,i1).transfer_to(primitives);

               }

             }

           }

         }

         cimg::swap(values1,values2);

         cimg::swap(indices1,indices2);

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> isosurface3d(CImgList<tf>& primitives, const char *const expression, const float isovalue,

                                      const float x0, const float y0, const float z0,

                                      const float x1, const float y1, const float z1,

                                      const int dx=32, const int dy=32, const int dz=32) {

       const _marching3d_func_expr func(expression);

       return isosurface3d(primitives,func,isovalue,x0,y0,z0,x1,y1,z1,dx,dy,dz);

     }


     template<typename t>

     static int _marching3d_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) {

       switch (edge) {

       case 0 : return indices1(x,y,0);

       case 1 : return indices1(nx,y,1);

       case 2 : return indices1(x,ny,0);

       case 3 : return indices1(x,y,1);

       case 4 : return indices2(x,y,0);

       case 5 : return indices2(nx,y,1);

       case 6 : return indices2(x,ny,0);

       case 7 : return indices2(x,y,1);

       case 8 : return indices1(x,y,2);

       case 9 : return indices1(nx,y,2);

       case 10 : return indices1(nx,ny,2);

       case 11 : return indices1(x,ny,2);

       }

       return 0;

     }


     struct _marching3d_func {

       const CImg<T>& ref;

       _marching3d_func(const CImg<T>& pref):ref(pref) {}

       float operator()(const float x, const float y, const float z) const {

         return (float)ref((int)x,(int)y,(int)z);

       }

     };


     struct _marching3d_func_float {

       const CImg<T>& ref;

       _marching3d_func_float(const CImg<T>& pref):ref(pref) {}

       float operator()(const float x, const float y, const float z) const {

         return (float)ref._linear_atXYZ(x,y,z);

       }

     };


     struct _marching3d_func_expr {

       _cimg_math_parser *mp;

       _marching3d_func_expr(const char *const expr):mp(0) {

         mp = new _cimg_math_parser(expr,"isovalue3d");

       }

       float operator()(const float x, const float y, const float z) const {

         return (float)mp->eval(x,y,z,0);

       }

       ~_marching3d_func_expr() {

         if (mp) delete mp;

       }

     };


     template<typename tf>

     static CImg<floatT> box3d(CImgList<tf>& primitives,

                               const float size_x=200, const float size_y=100, const float size_z=100) {

       primitives.assign(6,1,4,1,1, 0,3,2,1, 4,5,6,7, 0,1,5,4, 3,7,6,2, 0,4,7,3, 1,2,6,5);

       return CImg<floatT>(8,3,1,1,

                           0.,size_x,size_x,    0.,    0.,size_x,size_x,    0.,

                           0.,    0.,size_y,size_y,    0.,    0.,size_y,size_y,

                           0.,    0.,    0.,    0.,size_z,size_z,size_z,size_z);

     }


     template<typename tf>

     static CImg<floatT> cone3d(CImgList<tf>& primitives,

                                const float radius=50, const float size_z=100, const unsigned int subdivisions=24) {

       primitives.assign();

       if (!subdivisions) return CImg<floatT>();

       CImgList<floatT> vertices(2,1,3,1,1,

                                 0.,0.,size_z,

                                 0.,0.,0.);

       for (float delta = 360.0f/subdivisions, angle = 0; angle<360; angle+=delta) {

         const float a = (float)(angle*cimg::valuePI/180);

         CImg<floatT>::vector((float)(radius*std::cos(a)),(float)(radius*std::sin(a)),0).transfer_to(vertices);

       }

       const unsigned int nbr = vertices.width - 2;

       for (unsigned int p = 0; p<nbr; ++p) {

         const unsigned int curr = 2 + p, next = 2 + ((p+1)%nbr);

         CImg<tf>::vector(1,next,curr).transfer_to(primitives);

         CImg<tf>::vector(0,curr,next).transfer_to(primitives);

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> cylinder3d(CImgList<tf>& primitives,

                                    const float radius=50, const float size_z=100, const unsigned int subdivisions=24) {

       primitives.assign();

       if (!subdivisions) return CImg<floatT>();

       CImgList<floatT> vertices(2,1,3,1,1,

                                 0.,0.,0.,

                                 0.,0.,size_z);

       for (float delta = 360.0f/subdivisions, angle = 0; angle<360; angle+=delta) {

         const float a = (float)(angle*cimg::valuePI/180);

         CImg<floatT>::vector((float)(radius*std::cos(a)),(float)(radius*std::sin(a)),0.0f).transfer_to(vertices);

         CImg<floatT>::vector((float)(radius*std::cos(a)),(float)(radius*std::sin(a)),size_z).transfer_to(vertices);

       }

       const unsigned int nbr = (vertices.width - 2)/2;

       for (unsigned int p = 0; p<nbr; ++p) {

         const unsigned int curr = 2+2*p, next = 2+(2*((p+1)%nbr));

         CImg<tf>::vector(0,next,curr).transfer_to(primitives);

         CImg<tf>::vector(1,curr+1,next+1).transfer_to(primitives);

         CImg<tf>::vector(curr,next,next+1,curr+1).transfer_to(primitives);

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> torus3d(CImgList<tf>& primitives,

                                 const float radius1=100, const float radius2=30,

                                 const unsigned int subdivisions1=24, const unsigned int subdivisions2=12) {

       primitives.assign();

       if (!subdivisions1 || !subdivisions2) return CImg<floatT>();

       CImgList<floatT> vertices;

       for (unsigned int v = 0; v<subdivisions1; ++v) {

         const float

           beta = (float)(v*2*cimg::valuePI/subdivisions1),

           xc = radius1*(float)std::cos(beta),

           yc = radius1*(float)std::sin(beta);

         for (unsigned int u = 0; u<subdivisions2; ++u) {

           const float

             alpha = (float)(u*2*cimg::valuePI/subdivisions2),

             x = xc + radius2*(float)(std::cos(alpha)*std::cos(beta)),

             y = yc + radius2*(float)(std::cos(alpha)*std::sin(beta)),

             z = radius2*(float)std::sin(alpha);

           CImg<floatT>::vector(x,y,z).transfer_to(vertices);

         }

       }

       for (unsigned int vv = 0; vv<subdivisions1; ++vv) {

         const unsigned int nv = (vv+1)%subdivisions1;

         for (unsigned int uu = 0; uu<subdivisions2; ++uu) {

           const unsigned int nu = (uu+1)%subdivisions2, svv = subdivisions2*vv, snv = subdivisions2*nv;

           CImg<tf>::vector(svv+nu,svv+uu,snv+uu).transfer_to(primitives);

           CImg<tf>::vector(svv+nu,snv+uu,snv+nu).transfer_to(primitives);

         }

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> plane3d(CImgList<tf>& primitives,

                                 const float size_x=100, const float size_y=100,

                                 const unsigned int subdivisions_x=10, const unsigned int subdivisions_y=10,

                                 const bool double_sided=false) {

       primitives.assign();

       if (!subdivisions_x || !subdivisions_y) return CImg<floatT>();

       CImgList<floatT> vertices;

       const unsigned int w = subdivisions_x + 1, h = subdivisions_y + 1;

       const float fx = (float)size_x/w, fy = (float)size_y/h;

       for (unsigned int y = 0; y<h; ++y) for (unsigned int x = 0; x<w; ++x)

         CImg<floatT>::vector(fx*x,fy*y,0).transfer_to(vertices);

       for (unsigned int y = 0; y<subdivisions_y; ++y) for (unsigned int x = 0; x<subdivisions_x; ++x) {

         const int off1 = x+y*w, off2 = x+1+y*w, off3 = x+1+(y+1)*w, off4 = x+(y+1)*w;

         CImg<tf>::vector(off1,off4,off3,off2).transfer_to(primitives);

         if (double_sided) CImg<tf>::vector(off1,off2,off3,off4).transfer_to(primitives);

       }

       return vertices>'x';

     }


     template<typename tf>

     static CImg<floatT> sphere3d(CImgList<tf>& primitives, const float radius=50, const unsigned int subdivisions=3) {


       // Create initial icosahedron

       primitives.assign();

       const double tmp = (1+std::sqrt(5.0f))/2, a = 1.0/std::sqrt(1+tmp*tmp), b = tmp*a;

       CImgList<floatT> vertices(12,1,3,1,1, b,a,0.0, -b,a,0.0, -b,-a,0.0, b,-a,0.0, a,0.0,b, a,0.0,-b,

                                 -a,0.0,-b, -a,0.0,b, 0.0,b,a, 0.0,-b,a, 0.0,-b,-a, 0.0,b,-a);

       primitives.assign(20,1,3,1,1, 4,8,7, 4,7,9, 5,6,11, 5,10,6, 0,4,3, 0,3,5, 2,7,1, 2,1,6,

                         8,0,11, 8,11,1, 9,10,3, 9,2,10, 8,4,0, 11,0,5, 4,9,3,

                         5,3,10, 7,8,1, 6,1,11, 7,2,9, 6,10,2);


       // Recurse subdivisions

       for (unsigned int i = 0; i<subdivisions; ++i) {

         const unsigned int L = primitives.width;

         for (unsigned int l = 0; l<L; ++l) {

           const unsigned int

             p0 = (unsigned int)primitives(0,0), p1 = (unsigned int)primitives(0,1), p2 = (unsigned int)primitives(0,2);

           const float

             x0 = vertices(p0,0), y0 = vertices(p0,1), z0 = vertices(p0,2),

             x1 = vertices(p1,0), y1 = vertices(p1,1), z1 = vertices(p1,2),

             x2 = vertices(p2,0), y2 = vertices(p2,1), z2 = vertices(p2,2),

             tnx0 = (x0+x1)/2, tny0 = (y0+y1)/2, tnz0 = (z0+z1)/2, nn0 = (float)std::sqrt(tnx0*tnx0+tny0*tny0+tnz0*tnz0),

             tnx1 = (x0+x2)/2, tny1 = (y0+y2)/2, tnz1 = (z0+z2)/2, nn1 = (float)std::sqrt(tnx1*tnx1+tny1*tny1+tnz1*tnz1),

             tnx2 = (x1+x2)/2, tny2 = (y1+y2)/2, tnz2 = (z1+z2)/2, nn2 = (float)std::sqrt(tnx2*tnx2+tny2*tny2+tnz2*tnz2),

             nx0 = tnx0/nn0, ny0 = tny0/nn0, nz0 = tnz0/nn0,

             nx1 = tnx1/nn1, ny1 = tny1/nn1, nz1 = tnz1/nn1,

             nx2 = tnx2/nn2, ny2 = tny2/nn2, nz2 = tnz2/nn2;

           int i0 = -1, i1 = -1, i2 = -1;

           cimglist_for(vertices,p) {

             const float x = (float)vertices(p,0), y = (float)vertices(p,1), z = (float)vertices(p,2);

             if (x==nx0 && y==ny0 && z==nz0) i0 = p;

             if (x==nx1 && y==ny1 && z==nz1) i1 = p;

             if (x==nx2 && y==ny2 && z==nz2) i2 = p;

           }

           if (i0<0) { CImg<floatT>::vector(nx0,ny0,nz0).transfer_to(vertices); i0 = vertices.width - 1; }

           if (i1<0) { CImg<floatT>::vector(nx1,ny1,nz1).transfer_to(vertices); i1 = vertices.width - 1; }

           if (i2<0) { CImg<floatT>::vector(nx2,ny2,nz2).transfer_to(vertices); i2 = vertices.width - 1; }

           primitives.remove(0);

           CImg<tf>::vector(p0,i0,i1).transfer_to(primitives);

           CImg<tf>::vector((tf)i0,(tf)p1,(tf)i2).transfer_to(primitives);

           CImg<tf>::vector((tf)i1,(tf)i2,(tf)p2).transfer_to(primitives);

           CImg<tf>::vector((tf)i1,(tf)i0,(tf)i2).transfer_to(primitives);

         }

       }

       return (vertices>'x')*=radius;

     }


     template<typename tf, typename t>

     static CImg<floatT> ellipsoid3d(CImgList<tf>& primitives,

                                     const CImg<t>& tensor, const unsigned int subdivisions=3) {

       primitives.assign();

       if (!subdivisions) return CImg<floatT>();

       CImg<floatT> S,V;

       tensor.symmetric_eigen(S,V);

       const float l0 = S[0], l1 = S[1], l2 = S[2];

       CImg<floatT> vertices = sphere(primitives,subdivisions);

       vertices.get_shared_line(0)*=l0;

       vertices.get_shared_line(1)*=l1;

       vertices.get_shared_line(2)*=l2;

       return V.transpose()*vertices;

     }


     //---------------------------

     //


     //---------------------------


     // The following _draw_scanline() routines are *non user-friendly functions*, used only for internal purpose.

     // Pre-requisites : x0<x1, y-coordinate is valid, col is valid.

     template<typename tc>

     CImg<T>& _draw_scanline(const int x0, const int x1, const int y,

                             const tc *const color, const float opacity=1,

                             const float brightness=1, const bool init=false) {

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       static float nopacity = 0, copacity = 0;

       static unsigned int whz = 0;

       static const tc *col = 0;

       if (init) {

         nopacity = cimg::abs(opacity);

         copacity = 1 - cimg::max(opacity,0);

         whz = width*height*depth;

       } else {

         const int nx0 = x0>0?x0:0, nx1 = x1<dimx()?x1:dimx()-1, dx = nx1 - nx0;

         if (dx>=0) {

           col = color;

           const unsigned int off = whz-dx-1;

           T *ptrd = ptr(nx0,y);

           if (opacity>=1) { // ** Opaque drawing **

             if (brightness==1) { // Brightness==1

               if (sizeof(T)!=1) cimg_forV(*this,k) {

                 const T val = (T)*(col++);

                 for (int x = dx; x>=0; --x) *(ptrd++) = val;

                 ptrd+=off;

               } else cimg_forV(*this,k) {

                 const T val = (T)*(col++);

                 std::memset(ptrd,(int)val,dx+1);

                 ptrd+=whz;

               }

             } else if (brightness<1) { // Brightness<1

               if (sizeof(T)!=1) cimg_forV(*this,k) {

                 const T val = (T)(*(col++)*brightness);

                 for (int x = dx; x>=0; --x) *(ptrd++) = val;

                 ptrd+=off;

               } else cimg_forV(*this,k) {

                 const T val = (T)(*(col++)*brightness);

                 std::memset(ptrd,(int)val,dx+1);

                 ptrd+=whz;

               }

             } else { // Brightness>1

               if (sizeof(T)!=1) cimg_forV(*this,k) {

                 const T val = (T)((2-brightness)**(col++) + (brightness-1)*maxval);

                 for (int x = dx; x>=0; --x) *(ptrd++) = val;

                 ptrd+=off;

               } else cimg_forV(*this,k) {

                 const T val = (T)((2-brightness)**(col++) + (brightness-1)*maxval);

                 std::memset(ptrd,(int)val,dx+1);

                 ptrd+=whz;

               }

             }

           } else { // ** Transparent drawing **

             if (brightness==1) { // Brightness==1

               cimg_forV(*this,k) {

                 const T val = (T)*(col++);

                 for (int x = dx; x>=0; --x) { *ptrd = (T)(val*nopacity + *ptrd*copacity); ++ptrd; }

                 ptrd+=off;

               }

             } else if (brightness<=1) { // Brightness<1

               cimg_forV(*this,k) {

                 const T val = (T)(*(col++)*brightness);

                 for (int x = dx; x>=0; --x) { *ptrd = (T)(val*nopacity + *ptrd*copacity); ++ptrd; }

                 ptrd+=off;

               }

             } else { // Brightness>1

               cimg_forV(*this,k) {

                 const T val = (T)((2-brightness)**(col++) + (brightness-1)*maxval);

                 for (int x = dx; x>=0; --x) { *ptrd = (T)(val*nopacity + *ptrd*copacity); ++ptrd; }

                 ptrd+=off;

               }

             }

           }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& _draw_scanline(const tc *const color, const float opacity=1) {

       return _draw_scanline(0,0,0,color,opacity,0,true);

     }


     template<typename tc>

     CImg<T>& draw_point(const int x0, const int y0,

                         const tc *const color, const float opacity=1) {

       return draw_point(x0,y0,0,color,opacity);

     }


     template<typename tc>

     CImg<T>& draw_point(const int x0, const int y0,

                         const CImg<tc>& color, const float opacity=1) {

       return draw_point(x0,y0,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_point(const int x0, const int y0, const int z0,

                         const tc *const color, const float opacity=1) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_point() : Specified color is (null)",

                                     pixel_type());

       if (x0>=0 && y0>=0 && z0>=0 && x0<dimx() && y0<dimy() && z0<dimz()) {

         const unsigned int whz = width*height*depth;

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         T *ptrd = ptr(x0,y0,z0,0);

         const tc *col = color;

         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; }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_point(const int x0, const int y0, const int z0,

                         const CImg<tc>& color, const float opacity=1) {

       return draw_point(x0,y0,z0,color.data,opacity);

     }


     // Draw a cloud of colored point (internal).

     template<typename t, typename tc>

     CImg<T>& _draw_point(const t& points, const unsigned int W, const unsigned int H,

                          const tc *const color, const float opacity) {

       if (is_empty() || !points || !W) return *this;

       switch (H) {

       case 0 : case 1 :

         throw CImgArgumentException("CImg<%s>::draw_point() : Given list of points is not valid.",

                                     pixel_type());

       case 2 : {

         for (unsigned int i = 0; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1);

           draw_point(x,y,color,opacity);

         }

       } break;

       default : {

         for (unsigned int i = 0; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1), z = (int)points(i,2);

           draw_point(x,y,z,color,opacity);

         }

       }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_point(const CImgList<t>& points,

                         const tc *const color, const float opacity=1) {

       unsigned int H = ~0U; cimglist_for(points,p) H = cimg::min(H,(unsigned int)(points[p].size()));

       return _draw_point(points,points.width,H,color,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_point(const CImgList<t>& points,

                         const CImg<tc>& color, const float opacity=1) {

       return draw_point(points,color.data,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_point(const CImg<t>& points,

                         const tc *const color, const float opacity=1) {

       return _draw_point(points,points.width,points.height,color,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_point(const CImg<t>& points,

                         const CImg<tc>& color, const float opacity=1) {

       return draw_point(points,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0,

                        const int x1, const int y1,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified color is (null)",

                                     pixel_type());

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       const bool xdir = x0<x1, ydir = y0<y1;

       int

         nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1,

         &xleft = xdir?nx0:nx1, &yleft = xdir?ny0:ny1,

         &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,

         &xup = ydir?nx0:nx1, &yup = ydir?ny0:ny1,

         &xdown = ydir?nx1:nx0, &ydown = ydir?ny1:ny0;

       if (xright<0 || xleft>=dimx()) return *this;

       if (xleft<0) { yleft-=xleft*(yright - yleft)/(xright - xleft); xleft = 0; }

       if (xright>=dimx()) { yright-=(xright - dimx())*(yright - yleft)/(xright - xleft); xright = dimx()-1; }

       if (ydown<0 || yup>=dimy()) return *this;

       if (yup<0) { xup-=yup*(xdown - xup)/(ydown - yup); yup = 0; }

       if (ydown>=dimy()) { xdown-=(ydown - dimy())*(xdown - xup)/(ydown - yup); ydown = dimy()-1; }

       T *ptrd0 = ptr(nx0,ny0);

       int dx = xright - xleft, dy = ydown - yup;

       const bool steep = dy>dx;

       if (steep) cimg::swap(nx0,ny0,nx1,ny1,dx,dy);

       const int

         offx = (nx0<nx1?1:-1)*(steep?width:1),

         offy = (ny0<ny1?1:-1)*(steep?1:width),

         wh = width*height;

       if (opacity>=1) {

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) { T *ptrd = ptrd0; const tc* col = color; cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=wh; }}

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           T *ptrd = ptrd0; const tc* col = color; cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             T *ptrd = ptrd0; const tc* col = color;

             cimg_forV(*this,k) { *ptrd = (T)(nopacity**(col++) + *ptrd*copacity); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           T *ptrd = ptrd0; const tc* col = color; cimg_forV(*this,k) { *ptrd = (T)(nopacity**(col++) + *ptrd*copacity); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0,

                        const int x1, const int y1,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_line(x0,y0,x1,y1,color.data,opacity,pattern,init_hatch);

     }


     template<typename tc>

     CImg<T>& draw_line(CImg<floatT>& zbuffer,

                        const int x0, const int y0, const float z0,

                        const int x1, const int y1, const float z1,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty() || z0<=0 || z1<=0) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified color is (null).",

                                     pixel_type());

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       const bool xdir = x0<x1, ydir = y0<y1;

       int

         nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1,

         &xleft = xdir?nx0:nx1, &yleft = xdir?ny0:ny1,

         &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,

         &xup = ydir?nx0:nx1, &yup = ydir?ny0:ny1,

         &xdown = ydir?nx1:nx0, &ydown = ydir?ny1:ny0;

       float

         Z0 = 1/z0, Z1 = 1/z1, nz0 = Z0, nz1 = Z1, dz = Z1 - Z0,

         &zleft = xdir?nz0:nz1,

         &zright = xdir?nz1:nz0,

         &zup = ydir?nz0:nz1,

         &zdown = ydir?nz1:nz0;

       if (xright<0 || xleft>=dimx()) return *this;

       if (xleft<0) {

         const int D = xright - xleft;

         yleft-=xleft*(yright - yleft)/D;

         zleft-=xleft*(zright - zleft)/D;

         xleft = 0;

       }

       if (xright>=dimx()) {

         const int d = xright - dimx(), D = xright - xleft;

         yright-=d*(yright - yleft)/D;

         zright-=d*(zright - zleft)/D;

         xright = dimx()-1;

       }

       if (ydown<0 || yup>=dimy()) return *this;

       if (yup<0) {

         const int D = ydown - yup;

         xup-=yup*(xdown - xup)/D;

         zup-=yup*(zdown - zup)/D;

         yup = 0;

       }

       if (ydown>=dimy()) {

         const int d = ydown - dimy(), D = ydown - yup;

         xdown-=d*(xdown - xup)/D;

         zdown-=d*(zdown - zup)/D;

         ydown = dimy()-1;

       }

       T *ptrd0 = ptr(nx0,ny0);

       float *ptrz = zbuffer.ptr(nx0,ny0);

       int dx = xright - xleft, dy = ydown - yup;

       const bool steep = dy>dx;

       if (steep) cimg::swap(nx0,ny0,nx1,ny1,dx,dy);

       const int

         offx = (nx0<nx1?1:-1)*(steep?width:1),

         offy = (ny0<ny1?1:-1)*(steep?1:width),

         wh = width*height,

         ndx = dx>0?dx:1;

       if (opacity>=1) {

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz && pattern&hatch) {

             *ptrz = z;

             T *ptrd = ptrd0; const tc *col = color;

             cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz) {

             *ptrz = z;

             T *ptrd = ptrd0; const tc *col = color;

             cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=wh; }

           }

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz && pattern&hatch) {

             *ptrz = z;

             T *ptrd = ptrd0; const tc *col = color;

             cimg_forV(*this,k) { *ptrd = (T)(nopacity**(col++) + *ptrd*copacity); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz) {

             *ptrz = z;

             T *ptrd = ptrd0; const tc *col = color;

             cimg_forV(*this,k) { *ptrd = (T)(nopacity**(col++) + *ptrd*copacity); ptrd+=wh; }

           }

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_line(CImg<floatT>& zbuffer,

                        const int x0, const int y0, const float z0,

                        const int x1, const int y1, const float z1,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color.data,opacity,pattern,init_hatch);

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0, const int z0,

                        const int x1, const int y1, const int z1,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified color is (null)",

                                     pixel_type());

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       int nx0 = x0, ny0 = y0, nz0 = z0, nx1 = x1, ny1 = y1, nz1 = z1;

       if (nx0>nx1) cimg::swap(nx0,nx1,ny0,ny1,nz0,nz1);

       if (nx1<0 || nx0>=dimx()) return *this;

       if (nx0<0) { const int D = 1 + nx1 - nx0; ny0-=nx0*(1 + ny1 - ny0)/D; nz0-=nx0*(1 + nz1 - nz0)/D; nx0 = 0; }

       if (nx1>=dimx()) { const int d = nx1-dimx(), D = 1 + nx1 - nx0; ny1+=d*(1 + ny0 - ny1)/D; nz1+=d*(1 + nz0 - nz1)/D; nx1 = dimx()-1; }

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nz0,nz1);

       if (ny1<0 || ny0>=dimy()) return *this;

       if (ny0<0) { const int D = 1 + ny1 - ny0; nx0-=ny0*(1 + nx1 - nx0)/D; nz0-=ny0*(1 + nz1 - nz0)/D; ny0 = 0; }

       if (ny1>=dimy()) { const int d = ny1-dimy(), D = 1 + ny1 - ny0; nx1+=d*(1 + nx0 - nx1)/D; nz1+=d*(1 + nz0 - nz1)/D; ny1 = dimy()-1; }

       if (nz0>nz1) cimg::swap(nx0,nx1,ny0,ny1,nz0,nz1);

       if (nz1<0 || nz0>=dimz()) return *this;

       if (nz0<0) { const int D = 1 + nz1 - nz0; nx0-=nz0*(1 + nx1 - nx0)/D; ny0-=nz0*(1 + ny1 - ny0)/D; nz0 = 0; }

       if (nz1>=dimz()) { const int d = nz1-dimz(), D = 1 + nz1 - nz0; nx1+=d*(1 + nx0 - nx1)/D; ny1+=d*(1 + ny0 - ny1)/D; nz1 = dimz()-1; }

       const unsigned int dmax = cimg::max(cimg::abs(nx1 - nx0),cimg::abs(ny1 - ny0),nz1 - nz0), whz = width*height*depth;

       const float px = (nx1 - nx0)/(float)dmax, py = (ny1 - ny0)/(float)dmax, pz = (nz1 - nz0)/(float)dmax;

       float x = (float)nx0, y = (float)ny0, z = (float)nz0;

       if (opacity>=1) for (unsigned int t = 0; t<=dmax; ++t) {

         if (!(~pattern) || (~pattern && pattern&hatch)) {

           T* ptrd = ptr((unsigned int)x,(unsigned int)y,(unsigned int)z);

           const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=whz; }

         }

         x+=px; y+=py; z+=pz; if (pattern) { hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1); }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         for (unsigned int t = 0; t<=dmax; ++t) {

           if (!(~pattern) || (~pattern && pattern&hatch)) {

             T* ptrd = ptr((unsigned int)x,(unsigned int)y,(unsigned int)z);

             const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)(*(col++)*nopacity + *ptrd*copacity); ptrd+=whz; }

           }

           x+=px; y+=py; z+=pz; if (pattern) { hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1); }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0, const int z0,

                        const int x1, const int y1, const int z1,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_line(x0,y0,z0,x1,y1,z1,color.data,opacity,pattern,init_hatch);

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0,

                        const int x1, const int y1,

                        const CImg<tc>& texture,

                        const int tx0, const int ty0,

                        const int tx1, const int ty1,

                        const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_line(x0,y0,x1,y1,+texture,tx0,ty0,tx1,ty1,opacity,pattern,init_hatch);

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       const bool xdir = x0<x1, ydir = y0<y1;

       int

         dtx = tx1-tx0, dty = ty1-ty0,

         nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1,

         tnx0 = tx0, tnx1 = tx1, tny0 = ty0, tny1 = ty1,

         &xleft = xdir?nx0:nx1, &yleft = xdir?ny0:ny1, &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,

         &txleft = xdir?tnx0:tnx1, &tyleft = xdir?tny0:tny1, &txright = xdir?tnx1:tnx0, &tyright = xdir?tny1:tny0,

         &xup = ydir?nx0:nx1, &yup = ydir?ny0:ny1, &xdown = ydir?nx1:nx0, &ydown = ydir?ny1:ny0,

         &txup = ydir?tnx0:tnx1, &tyup = ydir?tny0:tny1, &txdown = ydir?tnx1:tnx0, &tydown = ydir?tny1:tny0;

       if (xright<0 || xleft>=dimx()) return *this;

       if (xleft<0) {

         const int D = xright - xleft;

         yleft-=xleft*(yright - yleft)/D;

         txleft-=xleft*(txright - txleft)/D;

         tyleft-=xleft*(tyright - tyleft)/D;

         xleft = 0;

       }

       if (xright>=dimx()) {

         const int d = xright - dimx(), D = xright - xleft;

         yright-=d*(yright - yleft)/D;

         txright-=d*(txright - txleft)/D;

         tyright-=d*(tyright - tyleft)/D;

         xright = dimx()-1;

       }

       if (ydown<0 || yup>=dimy()) return *this;

       if (yup<0) {

         const int D = ydown - yup;

         xup-=yup*(xdown - xup)/D;

         txup-=yup*(txdown - txup)/D;

         tyup-=yup*(tydown - tyup)/D;

         yup = 0;

       }

       if (ydown>=dimy()) {

         const int d = ydown - dimy(), D = ydown - yup;

         xdown-=d*(xdown - xup)/D;

         txdown-=d*(txdown - txup)/D;

         tydown-=d*(tydown - tyup)/D;

         ydown = dimy()-1;

       }

       T *ptrd0 = ptr(nx0,ny0);

       int dx = xright - xleft, dy = ydown - yup;

       const bool steep = dy>dx;

       if (steep) cimg::swap(nx0,ny0,nx1,ny1,dx,dy);

       const int

         offx = (nx0<nx1?1:-1)*(steep?width:1),

         offy = (ny0<ny1?1:-1)*(steep?1:width),

         wh = width*height,

         ndx = dx>0?dx:1;

       if (opacity>=1) {

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             T *ptrd = ptrd0;

             const int tx = tx0 + x*dtx/ndx, ty = ty0 + x*dty/ndx;

             cimg_forV(*this,k) { *ptrd = (T)texture(tx,ty,0,k); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           T *ptrd = ptrd0;

           const int tx = tx0 + x*dtx/ndx, ty = ty0 + x*dty/ndx;

           cimg_forV(*this,k) { *ptrd = (T)texture(tx,ty,0,k); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           T *ptrd = ptrd0;

           if (pattern&hatch) {

             const int tx = tx0 + x*dtx/ndx, ty = ty0 + x*dty/ndx;

             cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture(tx,ty,0,k) + *ptrd*copacity); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           T *ptrd = ptrd0;

           const int tx = tx0 + x*dtx/ndx, ty = ty0 + x*dty/ndx;

           cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture(tx,ty,0,k) + *ptrd*copacity); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_line(const int x0, const int y0, const float z0,

                        const int x1, const int y1, const float z1,

                        const CImg<tc>& texture,

                        const int tx0, const int ty0,

                        const int tx1, const int ty1,

                        const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty() && z0<=0 && z1<=0) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_line(x0,y0,z0,x1,y1,z1,+texture,tx0,ty0,tx1,ty1,opacity,pattern,init_hatch);

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       const bool xdir = x0<x1, ydir = y0<y1;

       int

         nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1,

         &xleft = xdir?nx0:nx1, &yleft = xdir?ny0:ny1,

         &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,

         &xup = ydir?nx0:nx1, &yup = ydir?ny0:ny1,

         &xdown = ydir?nx1:nx0, &ydown = ydir?ny1:ny0;

       float

         Tx0 = tx0/z0, Tx1 = tx1/z1,

         Ty0 = ty0/z0, Ty1 = ty1/z1,

         Z0 = 1/z0, Z1 = 1/z1,

         dz = Z1 - Z0, dtx = Tx1 - Tx0, dty = Ty1 - Ty0,

         tnx0 = Tx0, tnx1 = Tx1, tny0 = Ty0, tny1 = Ty1, nz0 = Z0, nz1 = Z1,

         &zleft = xdir?nz0:nz1, &txleft = xdir?tnx0:tnx1, &tyleft = xdir?tny0:tny1,

         &zright = xdir?nz1:nz0, &txright = xdir?tnx1:tnx0, &tyright = xdir?tny1:tny0,

         &zup = ydir?nz0:nz1, &txup = ydir?tnx0:tnx1, &tyup = ydir?tny0:tny1,

         &zdown = ydir?nz1:nz0, &txdown = ydir?tnx1:tnx0, &tydown = ydir?tny1:tny0;

       if (xright<0 || xleft>=dimx()) return *this;

       if (xleft<0) {

         const int D = xright - xleft;

         yleft-=xleft*(yright - yleft)/D;

         zleft-=xleft*(zright - zleft)/D;

         txleft-=xleft*(txright - txleft)/D;

         tyleft-=xleft*(tyright - tyleft)/D;

         xleft = 0;

       }

       if (xright>=dimx()) {

         const int d = xright - dimx(), D = xright - xleft;

         yright-=d*(yright - yleft)/D;

         zright-=d*(zright - zleft)/D;

         txright-=d*(txright - txleft)/D;

         tyright-=d*(tyright - tyleft)/D;

         xright = dimx()-1;

       }

       if (ydown<0 || yup>=dimy()) return *this;

       if (yup<0) {

         const int D = ydown - yup;

         xup-=yup*(xdown - xup)/D;

         zup-=yup*(zdown - zup)/D;

         txup-=yup*(txdown - txup)/D;

         tyup-=yup*(tydown - tyup)/D;

         yup = 0;

       }

       if (ydown>=dimy()) {

         const int d = ydown - dimy(), D = ydown - yup;

         xdown-=d*(xdown - xup)/D;

         zdown-=d*(zdown - zup)/D;

         txdown-=d*(txdown - txup)/D;

         tydown-=d*(tydown - tyup)/D;

         ydown = dimy()-1;

       }

       T *ptrd0 = ptr(nx0,ny0);

       int dx = xright - xleft, dy = ydown - yup;

       const bool steep = dy>dx;

       if (steep) cimg::swap(nx0,ny0,nx1,ny1,dx,dy);

       const int

         offx = (nx0<nx1?1:-1)*(steep?width:1),

         offy = (ny0<ny1?1:-1)*(steep?1:width),

         wh = width*height,

         ndx = dx>0?dx:1;

       if (opacity>=1) {

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             const float z = Z0 + x*dz/ndx, tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

             T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)texture((int)(tx/z),(int)(ty/z),0,k); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx, tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

           T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)texture((int)(tx/z),(int)(ty/z),0,k); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             const float z = Z0 + x*dz/ndx, tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

             T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture((int)(tx/z),(int)(ty/z),0,k) + *ptrd*copacity); ptrd+=wh; }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx, tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

           T *ptrd = ptrd0;

           cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture((int)(tx/z),(int)(ty/z),0,k) + *ptrd*copacity); ptrd+=wh; }

           ptrd0+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; error+=dx; }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_line(CImg<floatT>& zbuffer,

                        const int x0, const int y0, const float z0,

                        const int x1, const int y1, const float z1,

                        const CImg<tc>& texture,

                        const int tx0, const int ty0,

                        const int tx1, const int ty1,

                        const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       if (is_empty() || z0<=0 || z1<=0) return *this;

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_line(zbuffer,x0,y0,z0,x1,y1,z1,+texture,tx0,ty0,tx1,ty1,opacity,pattern,init_hatch);

       static unsigned int hatch = ~0U - (~0U>>1);

       if (init_hatch) hatch = ~0U - (~0U>>1);

       const bool xdir = x0<x1, ydir = y0<y1;

       int

         nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1,

         &xleft = xdir?nx0:nx1, &yleft = xdir?ny0:ny1,

         &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,

         &xup = ydir?nx0:nx1, &yup = ydir?ny0:ny1,

         &xdown = ydir?nx1:nx0, &ydown = ydir?ny1:ny0;

       float

         Tx0 = tx0/z0, Tx1 = tx1/z1,

         Ty0 = ty0/z0, Ty1 = ty1/z1,

         Z0 = 1/z0, Z1 = 1/z1,

         dz = Z1 - Z0, dtx = Tx1 - Tx0, dty = Ty1 - Ty0,

         tnx0 = Tx0, tnx1 = Tx1, tny0 = Ty0, tny1 = Ty1, nz0 = Z0, nz1 = Z1,

         &zleft = xdir?nz0:nz1, &txleft = xdir?tnx0:tnx1, &tyleft = xdir?tny0:tny1,

         &zright = xdir?nz1:nz0, &txright = xdir?tnx1:tnx0, &tyright = xdir?tny1:tny0,

         &zup = ydir?nz0:nz1, &txup = ydir?tnx0:tnx1, &tyup = ydir?tny0:tny1,

         &zdown = ydir?nz1:nz0, &txdown = ydir?tnx1:tnx0, &tydown = ydir?tny1:tny0;

       if (xright<0 || xleft>=dimx()) return *this;

       if (xleft<0) {

         const int D = xright - xleft;

         yleft-=xleft*(yright - yleft)/D;

         zleft-=xleft*(zright - zleft)/D;

         txleft-=xleft*(txright - txleft)/D;

         tyleft-=xleft*(tyright - tyleft)/D;

         xleft = 0;

       }

       if (xright>=dimx()) {

         const int d = xright - dimx(), D = xright - xleft;

         yright-=d*(yright - yleft)/D;

         zright-=d*(zright - zleft)/D;

         txright-=d*(txright - txleft)/D;

         tyright-=d*(tyright - tyleft)/D;

         xright = dimx()-1;

       }

       if (ydown<0 || yup>=dimy()) return *this;

       if (yup<0) {

         const int D = ydown - yup;

         xup-=yup*(xdown - xup)/D;

         zup-=yup*(zdown - zup)/D;

         txup-=yup*(txdown - txup)/D;

         tyup-=yup*(tydown - tyup)/D;

         yup = 0;

       }

       if (ydown>=dimy()) {

         const int d = ydown - dimy(), D = ydown - yup;

         xdown-=d*(xdown - xup)/D;

         zdown-=d*(zdown - zup)/D;

         txdown-=d*(txdown - txup)/D;

         tydown-=d*(tydown - tyup)/D;

         ydown = dimy()-1;

       }

       T *ptrd0 = ptr(nx0,ny0);

       float *ptrz = zbuffer.ptr(nx0,ny0);

       int dx = xright - xleft, dy = ydown - yup;

       const bool steep = dy>dx;

       if (steep) cimg::swap(nx0,ny0,nx1,ny1,dx,dy);

       const int

         offx = (nx0<nx1?1:-1)*(steep?width:1),

         offy = (ny0<ny1?1:-1)*(steep?1:width),

         wh = width*height,

         ndx = dx>0?dx:1;

       if (opacity>=1) {

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             const float z = Z0 + x*dz/ndx;

             if (z>*ptrz) {

               *ptrz = z;

               const float tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

               T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)texture((int)(tx/z),(int)(ty/z),0,k); ptrd+=wh; }

             }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz) {

             *ptrz = z;

             const float tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

             T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)texture((int)(tx/z),(int)(ty/z),0,k); ptrd+=wh; }

           }

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         }

       } else {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         if (~pattern) for (int error = dx>>1, x = 0; x<=dx; ++x) {

           if (pattern&hatch) {

             const float z = Z0 + x*dz/ndx;

             if (z>*ptrz) {

               *ptrz = z;

               const float tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

               T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture((int)(tx/z),(int)(ty/z),0,k) + *ptrd*copacity); ptrd+=wh; }

             }

           }

           hatch>>=1; if (!hatch) hatch = ~0U - (~0U>>1);

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offy; error+=dx; }

         } else for (int error = dx>>1, x = 0; x<=dx; ++x) {

           const float z = Z0 + x*dz/ndx;

           if (z>*ptrz) {

             *ptrz = z;

             const float tx = Tx0 + x*dtx/ndx, ty = Ty0 + x*dty/ndx;

             T *ptrd = ptrd0; cimg_forV(*this,k) { *ptrd = (T)(nopacity*texture((int)(tx/z),(int)(ty/z),0,k) + *ptrd*copacity); ptrd+=wh; }

           }

           ptrd0+=offx; ptrz+=offx;

           if ((error-=dy)<0) { ptrd0+=offy; ptrz+=offx; error+=dx; }

         }

       }

       return *this;

     }


     // Inner routine for drawing set of consecutive lines with generic type for coordinates.

     template<typename t, typename tc>

     CImg<T>& _draw_line(const t& points, const unsigned int W, const unsigned int H,

                         const tc *const color, const float opacity,

                         const unsigned int pattern, const bool init_hatch) {

       if (is_empty() || !points || W<2) return *this;

       bool ninit_hatch = init_hatch;

       switch (H) {

       case 0 : case 1 :

         throw CImgArgumentException("CImg<%s>::draw_line() : Given list of points is not valid.",

                                     pixel_type());

       case 2 : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1);

         int ox = x0, oy = y0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1);

           draw_line(ox,oy,x,y,color,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y;

         }

       } break;

       default : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1), z0 = (int)points(0,2);

         int ox = x0, oy = y0, oz = z0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1), z = (int)points(i,2);

           draw_line(ox,oy,oz,x,y,z,color,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y; oz = z;

         }

       }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_line(const CImgList<t>& points,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       unsigned int H = ~0U; cimglist_for(points,p) H = cimg::min(H,(unsigned int)(points[p].size()));

       return _draw_line(points,points.width,H,color,opacity,pattern,init_hatch);

     }


     template<typename t, typename tc>

     CImg<T>& draw_line(const CImgList<t>& points,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_line(points,color.data,opacity,pattern,init_hatch);

     }


     template<typename t, typename tc>

     CImg<T>& draw_line(const CImg<t>& points,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return _draw_line(points,points.width,points.height,color,opacity,pattern,init_hatch);

     }


     template<typename t, typename tc>

     CImg<T>& draw_line(const CImg<t>& points,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_line(points,color.data,opacity,pattern,init_hatch);

     }


     template<typename tc>

     CImg<T>& draw_arrow(const int x0, const int y0,

                         const int x1, const int y1,

                         const tc *const color, const float opacity=1,

                         const float angle=30, const float length=-10,

                         const unsigned int pattern=~0U) {

       if (is_empty()) return *this;

       const float u = (float)(x0 - x1), v = (float)(y0 - y1), sq = u*u + v*v,

         deg = (float)(angle*cimg::valuePI/180), ang = (sq>0)?(float)std::atan2(v,u):0.0f,

         l = (length>=0)?length:-length*(float)std::sqrt(sq)/100;

       if (sq>0) {

         const float

             cl = (float)std::cos(ang - deg), sl = (float)std::sin(ang - deg),

             cr = (float)std::cos(ang + deg), sr = (float)std::sin(ang + deg);

         const int

           xl = x1 + (int)(l*cl), yl = y1 + (int)(l*sl),

           xr = x1 + (int)(l*cr), yr = y1 + (int)(l*sr),

           xc = x1 + (int)((l+1)*(cl+cr))/2, yc = y1 + (int)((l+1)*(sl+sr))/2;

         draw_line(x0,y0,xc,yc,color,opacity,pattern).draw_triangle(x1,y1,xl,yl,xr,yr,color,opacity);

       } else draw_point(x0,y0,color,opacity);

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_arrow(const int x0, const int y0,

                         const int x1, const int y1,

                         const CImg<tc>& color, const float opacity=1,

                         const float angle=30, const float length=-10,

                         const unsigned int pattern=~0U) {

       return draw_arrow(x0,y0,x1,y1,color.data,opacity,angle,length,pattern);

     }


     template<typename tc>

     CImg<T>& draw_spline(const int x0, const int y0, const float u0, const float v0,

                          const int x1, const int y1, const float u1, const float v1,

                          const tc *const color, const float opacity=1,

                          const float precision=4, const unsigned int pattern=~0U,

                          const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_spline() : Specified color is (null)",

                                     pixel_type());

       bool ninit_hatch = init_hatch;

       const float

         dx = (float)(x1 - x0),

         dy = (float)(y1 - y0),

         dmax = cimg::max(cimg::abs(dx),cimg::abs(dy)),

         ax = -2*dx + u0 + u1,

         bx = 3*dx - 2*u0 - u1,

         ay = -2*dy + v0 + v1,

         by = 3*dy - 2*v0 - v1,

         xprecision = dmax>0?precision/dmax:1.0f,

         tmax = 1 + (dmax>0?xprecision:0.0f);

       int ox = x0, oy = y0;

       for (float t = 0; t<tmax; t+=xprecision) {

         const float

           t2 = t*t,

           t3 = t2*t;

         const int

           nx = (int)(ax*t3 + bx*t2 + u0*t + x0),

           ny = (int)(ay*t3 + by*t2 + v0*t + y0);

         draw_line(ox,oy,nx,ny,color,opacity,pattern,ninit_hatch);

         ninit_hatch = false;

         ox = nx; oy = ny;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_spline(const int x0, const int y0, const float u0, const float v0,

                          const int x1, const int y1, const float u1, const float v1,

                          const CImg<tc>& color, const float opacity=1,

                          const float precision=4, const unsigned int pattern=~0U,

                          const bool init_hatch=true) {

       return draw_spline(x0,y0,u0,v0,x1,y1,u1,v1,color.data,opacity,precision,pattern,init_hatch);

     }


     template<typename tc>

     CImg<T>& draw_spline(const int x0, const int y0, const int z0, const float u0, const float v0, const float w0,

                          const int x1, const int y1, const int z1, const float u1, const float v1, const float w1,

                          const tc *const color, const float opacity=1,

                          const float precision=4, const unsigned int pattern=~0U,

                          const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_spline() : Specified color is (null)",

                                     pixel_type());

       bool ninit_hatch = init_hatch;

       const float

         dx = (float)(x1 - x0),

         dy = (float)(y1 - y0),

         dz = (float)(z1 - z0),

         dmax = cimg::max(cimg::abs(dx),cimg::abs(dy),cimg::abs(dz)),

         ax = -2*dx + u0 + u1,

         bx = 3*dx - 2*u0 - u1,

         ay = -2*dy + v0 + v1,

         by = 3*dy - 2*v0 - v1,

         az = -2*dz + w0 + w1,

         bz = 3*dz - 2*w0 - w1,

         xprecision = dmax>0?precision/dmax:1.0f,

         tmax = 1 + (dmax>0?xprecision:0.0f);

       int ox = x0, oy = y0, oz = z0;

       for (float t = 0; t<tmax; t+=xprecision) {

         const float

           t2 = t*t,

           t3 = t2*t;

         const int

           nx = (int)(ax*t3 + bx*t2 + u0*t + x0),

           ny = (int)(ay*t3 + by*t2 + v0*t + y0),

           nz = (int)(az*t3 + bz*t2 + w0*t + z0);

         draw_line(ox,oy,oz,nx,ny,nz,color,opacity,pattern,ninit_hatch);

         ninit_hatch = false;

         ox = nx; oy = ny; oz = nz;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_spline(const int x0, const int y0, const int z0, const float u0, const float v0, const float w0,

                          const int x1, const int y1, const int z1, const float u1, const float v1, const float w1,

                          const CImg<tc>& color, const float opacity=1,

                          const float precision=4, const unsigned int pattern=~0U,

                          const bool init_hatch=true) {

       return draw_spline(x0,y0,z0,u0,v0,w0,x1,y1,z1,u1,v1,w1,color.data,opacity,precision,pattern,init_hatch);

     }


     template<typename t>

     CImg<T>& draw_spline(const int x0, const int y0, const float u0, const float v0,

                          const int x1, const int y1, const float u1, const float v1,

                          const CImg<t>& texture,

                          const int tx0, const int ty0, const int tx1, const int ty1,

                          const float opacity=1,

                          const float precision=4, const unsigned int pattern=~0U,

                          const bool init_hatch=true) {

       if (is_empty()) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_line() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_spline(x0,y0,u0,v0,x1,y1,u1,v1,+texture,tx0,ty0,tx1,ty1,precision,opacity,pattern,init_hatch);

       bool ninit_hatch = true;

       const float

         dx = (float)(x1 - x0),

         dy = (float)(y1 - y0),

         dmax = cimg::max(cimg::abs(dx),cimg::abs(dy)),

         ax = -2*dx + u0 + u1,

         bx = 3*dx - 2*u0 - u1,

         ay = -2*dy + v0 + v1,

         by = 3*dy - 2*v0 - v1,

         xprecision = dmax>0?precision/dmax:1.0f,

         tmax = 1 + (dmax>0?xprecision:0.0f);

       int ox = x0, oy = y0, otx = tx0, oty = ty0;

       for (float t1 = 0; t1<tmax; t1+=xprecision) {

         const float

           t2 = t1*t1,

           t3 = t2*t1;

         const int

           nx = (int)(ax*t3 + bx*t2 + u0*t1 + x0),

           ny = (int)(ay*t3 + by*t2 + v0*t1 + y0),

           ntx = tx0 + (int)((tx1-tx0)*t1/tmax),

           nty = ty0 + (int)((ty1-ty0)*t1/tmax);

         draw_line(ox,oy,nx,ny,texture,otx,oty,ntx,nty,opacity,pattern,ninit_hatch);

         ninit_hatch = false;

         ox = nx; oy = ny; otx = ntx; oty = nty;

       }

       return *this;

     }


     // Draw a set of connected spline curves in the instance image (internal).

     template<typename tp, typename tt, typename tc>

     CImg<T>& _draw_spline(const tp& points, const tt& tangents, const unsigned int W, const unsigned int H,

                           const tc *const color, const float opacity,

                           const bool close_set, const float precision,

                           const unsigned int pattern, const bool init_hatch) {

       if (is_empty() || !points || !tangents || W<2) return *this;

       bool ninit_hatch = init_hatch;

       switch (H) {

       case 0 : case 1 :

         throw CImgArgumentException("CImg<%s>::draw_spline() : Given list of points or tangents is not valid.",

                                     pixel_type());

       case 2 : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1);

         const float u0 = (float)tangents(0,0), v0 = (float)tangents(0,1);

         int ox = x0, oy = y0;

         float ou = u0, ov = v0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1);

           const float u = (float)tangents(i,0), v = (float)tangents(i,1);

           draw_spline(ox,oy,ou,ov,x,y,u,v,color,precision,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y; ou = u; ov = v;

         }

         if (close_set) draw_spline(ox,oy,ou,ov,x0,y0,u0,v0,color,precision,opacity,pattern,false);

       } break;

       default : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1), z0 = (int)points(0,2);

         const float u0 = (float)tangents(0,0), v0 = (float)tangents(0,1), w0 = (float)tangents(0,2);

         int ox = x0, oy = y0, oz = z0;

         float ou = u0, ov = v0, ow = w0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1), z = (int)points(i,2);

           const float u = (float)tangents(i,0), v = (float)tangents(i,1), w = (float)tangents(i,2);

           draw_spline(ox,oy,oz,ou,ov,ow,x,y,z,u,v,w,color,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y; oz = z; ou = u; ov = v; ow = w;

         }

         if (close_set) draw_spline(ox,oy,oz,ou,ov,ow,x0,y0,z0,u0,v0,w0,color,precision,opacity,pattern,false);

       }

       }

       return *this;

     }


     // Draw a set of connected spline curves in the instance image (internal).

     template<typename tp, typename tc>

     CImg<T>& _draw_spline(const tp& points, const unsigned int W, const unsigned int H,

                           const tc *const color, const float opacity,

                           const bool close_set, const float precision,

                           const unsigned int pattern, const bool init_hatch) {

       if (is_empty() || !points || W<2) return *this;

       CImg<Tfloat> tangents;

       switch (H) {

       case 0 : case 1 :

         throw CImgArgumentException("CImg<%s>::draw_spline() : Given list of points or tangents is not valid.",

                                     pixel_type());

       case 2 : {

         tangents.assign(W,H);

         for (unsigned int p = 0; p<W; ++p) {

           const unsigned int

             p0 = close_set?(p+W-1)%W:(p?p-1:0),

             p1 = close_set?(p+1)%W:(p+1<W?p+1:p);

           const float

             x = (float)points(p,0),

             y = (float)points(p,1),

             x0 = (float)points(p0,0),

             y0 = (float)points(p0,1),

             x1 = (float)points(p1,0),

             y1 = (float)points(p1,1),

             u0 = x - x0,

             v0 = y - y0,

             n0 = 1e-8f + (float)std::sqrt(u0*u0 + v0*v0),

             u1 = x1 - x,

             v1 = y1 - y,

             n1 = 1e-8f + (float)std::sqrt(u1*u1 + v1*v1),

             u = u0/n0 + u1/n1,

             v = v0/n0 + v1/n1,

             n = 1e-8f + (float)std::sqrt(u*u + v*v),

             fact = 0.5f*(n0 + n1);

           tangents(p,0) = (Tfloat)(fact*u/n);

           tangents(p,1) = (Tfloat)(fact*v/n);

         }

       } break;

       default : {

         tangents.assign(W,H);

         for (unsigned int p = 0; p<W; ++p) {

           const unsigned int

             p0 = close_set?(p+W-1)%W:(p?p-1:0),

             p1 = close_set?(p+1)%W:(p+1<W?p+1:p);

           const float

             x = (float)points(p,0),

             y = (float)points(p,1),

             z = (float)points(p,2),

             x0 = (float)points(p0,0),

             y0 = (float)points(p0,1),

             z0 = (float)points(p0,2),

             x1 = (float)points(p1,0),

             y1 = (float)points(p1,1),

             z1 = (float)points(p1,2),

             u0 = x - x0,

             v0 = y - y0,

             w0 = z - z0,

             n0 = 1e-8f + (float)std::sqrt(u0*u0 + v0*v0 + w0*w0),

             u1 = x1 - x,

             v1 = y1 - y,

             w1 = z1 - z,

             n1 = 1e-8f + (float)std::sqrt(u1*u1 + v1*v1 + w1*w1),

             u = u0/n0 + u1/n1,

             v = v0/n0 + v1/n1,

             w = w0/n0 + w1/n1,

             n = 1e-8f + (float)std::sqrt(u*u + v*v + w*w),

             fact = 0.5f*(n0 + n1);

           tangents(p,0) = (Tfloat)(fact*u/n);

           tangents(p,1) = (Tfloat)(fact*v/n);

           tangents(p,2) = (Tfloat)(fact*w/n);

         }

       }

       }

       return _draw_spline(points,tangents,W,H,color,opacity,close_set,precision,pattern,init_hatch);

     }


     template<typename tp, typename tt, typename tc>

     CImg<T>& draw_spline(const CImgList<tp>& points, const CImgList<tt>& tangents,

                          const tc *const color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       unsigned int H = ~0U; cimglist_for(points,p) H = cimg::min(H,(unsigned int)(points[p].size()),(unsigned int)(tangents[p].size()));

       return _draw_spline(points,tangents,color,opacity,close_set,precision,pattern,init_hatch,points.width,H);

     }


     template<typename tp, typename tt, typename tc>

     CImg<T>& draw_spline(const CImgList<tp>& points, const CImgList<tt>& tangents,

                          const CImg<tc>& color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_spline(points,tangents,color.data,opacity,close_set,precision,pattern,init_hatch);

     }


     template<typename tp, typename tt, typename tc>

     CImg<T>& draw_spline(const CImg<tp>& points, const CImg<tt>& tangents,

                          const tc *const color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return _draw_spline(points,tangents,color,opacity,close_set,precision,pattern,init_hatch,points.width,points.height);

     }


     template<typename tp, typename tt, typename tc>

     CImg<T>& draw_spline(const CImg<tp>& points, const CImg<tt>& tangents,

                          const CImg<tc>& color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_spline(points,tangents,color.data,opacity,close_set,precision,pattern,init_hatch);

     }


     template<typename t, typename tc>

     CImg<T>& draw_spline(const CImgList<t>& points,

                          const tc *const color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       unsigned int H = ~0U;

       cimglist_for(points,p) { const unsigned int s = points[p].size(); if (s<H) H = s; }

       return _draw_spline(points,color,opacity,close_set,precision,pattern,init_hatch,points.width,H);

     }


     template<typename t, typename tc>

     CImg<T>& draw_spline(const CImgList<t>& points,

                          CImg<tc>& color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_spline(points,color.data,opacity,close_set,precision,pattern,init_hatch);

     }


     template<typename t, typename tc>

     CImg<T>& draw_spline(const CImg<t>& points,

                          const tc *const color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return _draw_spline(points,color,opacity,close_set,precision,pattern,init_hatch,points.width,points.height);

     }


     template<typename t, typename tc>

     CImg<T>& draw_spline(const CImg<t>& points,

                          const CImg<tc>& color, const float opacity=1,

                          const bool close_set=false, const float precision=4,

                          const unsigned int pattern=~0U, const bool init_hatch=true) {

       return draw_spline(points,color.data,opacity,close_set,precision,pattern,init_hatch);

     }


     // Inner macro for drawing triangles.

 #define _cimg_for_triangle1(img,xl,xr,y,x0,y0,x1,y1,x2,y2) \

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


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

         for (int y = y0<0?0:y0, \

                xr = y0>=0?x0:(x0-y0*(x2-x0)/(y2-y0)), \

                cr = y0>=0?c0:(c0-y0*(c2-c0)/(y2-y0)), \

                xl = y1>=0?(y0>=0?(y0==y1?x1:x0):(x0-y0*(x1-x0)/(y1-y0))):(x1-y1*(x2-x1)/(y2-y1)), \

                cl = y1>=0?(y0>=0?(y0==y1?c1:c0):(c0-y0*(c1-c0)/(y1-y0))):(c1-y1*(c2-c1)/(y2-y1)), \

                _sxn=1, _scn=1, \

                _sxr=1, _scr=1, \

                _sxl=1, _scl=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), \

                _dcn = c2>c1?c2-c1:(_scn=-1,c1-c2), \

                _dcr = c2>c0?c2-c0:(_scr=-1,c0-c2), \

                _dcl = c1>c0?c1-c0:(_scl=-1,c0-c1), \

                _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, \

                           _dcn-=_dyn?_dyn*(_dcn/_dyn):0, \

                           _dcr-=_dyr?_dyr*(_dcr/_dyr):0, \

                           _dcl-=_dyl?_dyl*(_dcl/_dyl):0, \

                           cimg::min((int)(img).height-y-1,y2-y)), \

                _errn = _dyn/2, _errcn = _errn, \

                _errr = _dyr/2, _errcr = _errr, \

                _errl = _dyl/2, _errcl = _errl, \

                _rxn = _dyn?(x2-x1)/_dyn:0, \

                _rcn = _dyn?(c2-c1)/_dyn:0, \

                _rxr = _dyr?(x2-x0)/_dyr:0, \

                _rcr = _dyr?(c2-c0)/_dyr:0, \

                _rxl = (y0!=y1 && y1>0)?(_dyl?(x1-x0)/_dyl:0): \

                                        (_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxn), \

                _rcl = (y0!=y1 && y1>0)?(_dyl?(c1-c0)/_dyl:0): \

                                        (_errcl=_errcn, _dcl=_dcn, _dyl=_dyn, _scl=_scn, _rcn ); \

              _counter>=0; --_counter, ++y, \

                xr+=_rxr+((_errr-=_dxr)<0?_errr+=_dyr,_sxr:0), \

                cr+=_rcr+((_errcr-=_dcr)<0?_errcr+=_dyr,_scr:0), \

                xl+=(y!=y1)?(cl+=_rcl+((_errcl-=_dcl)<0?(_errcl+=_dyl,_scl):0), \

                            _rxl+((_errl-=_dxl)<0?(_errl+=_dyl,_sxl):0)): \

                (_errcl=_errcn, _dcl=_dcn, _dyl=_dyn, _scl=_scn, _rcl=_rcn, cl=c1, \

                 _errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxl=_rxn, x1-xl))


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

         for (int y = y0<0?0:y0, \

                xr = y0>=0?x0:(x0-y0*(x2-x0)/(y2-y0)), \

                txr = y0>=0?tx0:(tx0-y0*(tx2-tx0)/(y2-y0)), \

                tyr = y0>=0?ty0:(ty0-y0*(ty2-ty0)/(y2-y0)), \

                xl = y1>=0?(y0>=0?(y0==y1?x1:x0):(x0-y0*(x1-x0)/(y1-y0))):(x1-y1*(x2-x1)/(y2-y1)), \

                txl = y1>=0?(y0>=0?(y0==y1?tx1:tx0):(tx0-y0*(tx1-tx0)/(y1-y0))):(tx1-y1*(tx2-tx1)/(y2-y1)), \

                tyl = y1>=0?(y0>=0?(y0==y1?ty1:ty0):(ty0-y0*(ty1-ty0)/(y1-y0))):(ty1-y1*(ty2-ty1)/(y2-y1)), \

                _sxn=1, _stxn=1, _styn=1, \

                _sxr=1, _stxr=1, _styr=1, \

                _sxl=1, _stxl=1, _styl=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), \

                _dtxn = tx2>tx1?tx2-tx1:(_stxn=-1,tx1-tx2), \

                _dtxr = tx2>tx0?tx2-tx0:(_stxr=-1,tx0-tx2), \

                _dtxl = tx1>tx0?tx1-tx0:(_stxl=-1,tx0-tx1), \

                _dtyn = ty2>ty1?ty2-ty1:(_styn=-1,ty1-ty2), \

                _dtyr = ty2>ty0?ty2-ty0:(_styr=-1,ty0-ty2), \

                _dtyl = ty1>ty0?ty1-ty0:(_styl=-1,ty0-ty1), \

                _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, \

                           _dtxn-=_dyn?_dyn*(_dtxn/_dyn):0, \

                           _dtxr-=_dyr?_dyr*(_dtxr/_dyr):0, \

                           _dtxl-=_dyl?_dyl*(_dtxl/_dyl):0, \

                           _dtyn-=_dyn?_dyn*(_dtyn/_dyn):0, \

                           _dtyr-=_dyr?_dyr*(_dtyr/_dyr):0, \

                           _dtyl-=_dyl?_dyl*(_dtyl/_dyl):0, \

                           cimg::min((int)(img).height-y-1,y2-y)), \

                _errn = _dyn/2, _errtxn = _errn, _errtyn = _errn, \

                _errr = _dyr/2, _errtxr = _errr, _errtyr = _errr, \

                _errl = _dyl/2, _errtxl = _errl, _errtyl = _errl, \

                _rxn = _dyn?(x2-x1)/_dyn:0, \

                _rtxn = _dyn?(tx2-tx1)/_dyn:0, \

                _rtyn = _dyn?(ty2-ty1)/_dyn:0, \

                _rxr = _dyr?(x2-x0)/_dyr:0, \

                _rtxr = _dyr?(tx2-tx0)/_dyr:0, \

                _rtyr = _dyr?(ty2-ty0)/_dyr:0, \

                _rxl = (y0!=y1 && y1>0)?(_dyl?(x1-x0)/_dyl:0): \

                                        (_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxn), \

                _rtxl = (y0!=y1 && y1>0)?(_dyl?(tx1-tx0)/_dyl:0): \

                                        (_errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxn ), \

                _rtyl = (y0!=y1 && y1>0)?(_dyl?(ty1-ty0)/_dyl:0): \

                                        (_errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyn ); \

              _counter>=0; --_counter, ++y, \

                xr+=_rxr+((_errr-=_dxr)<0?_errr+=_dyr,_sxr:0), \

                txr+=_rtxr+((_errtxr-=_dtxr)<0?_errtxr+=_dyr,_stxr:0), \

                tyr+=_rtyr+((_errtyr-=_dtyr)<0?_errtyr+=_dyr,_styr:0), \

                xl+=(y!=y1)?(txl+=_rtxl+((_errtxl-=_dtxl)<0?(_errtxl+=_dyl,_stxl):0), \

                             tyl+=_rtyl+((_errtyl-=_dtyl)<0?(_errtyl+=_dyl,_styl):0), \

                            _rxl+((_errl-=_dxl)<0?(_errl+=_dyl,_sxl):0)): \

                (_errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxl=_rtxn, txl=tx1, \

                 _errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyl=_rtyn, tyl=ty1,\

                 _errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxl=_rxn, x1-xl))


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

         for (int y = y0<0?0:y0, \

                xr = y0>=0?x0:(x0-y0*(x2-x0)/(y2-y0)), \

                cr = y0>=0?c0:(c0-y0*(c2-c0)/(y2-y0)), \

                txr = y0>=0?tx0:(tx0-y0*(tx2-tx0)/(y2-y0)), \

                tyr = y0>=0?ty0:(ty0-y0*(ty2-ty0)/(y2-y0)), \

                xl = y1>=0?(y0>=0?(y0==y1?x1:x0):(x0-y0*(x1-x0)/(y1-y0))):(x1-y1*(x2-x1)/(y2-y1)), \

                cl = y1>=0?(y0>=0?(y0==y1?c1:c0):(c0-y0*(c1-c0)/(y1-y0))):(c1-y1*(c2-c1)/(y2-y1)), \

                txl = y1>=0?(y0>=0?(y0==y1?tx1:tx0):(tx0-y0*(tx1-tx0)/(y1-y0))):(tx1-y1*(tx2-tx1)/(y2-y1)), \

                tyl = y1>=0?(y0>=0?(y0==y1?ty1:ty0):(ty0-y0*(ty1-ty0)/(y1-y0))):(ty1-y1*(ty2-ty1)/(y2-y1)), \

                _sxn=1, _scn=1, _stxn=1, _styn=1, \

                _sxr=1, _scr=1, _stxr=1, _styr=1, \

                _sxl=1, _scl=1, _stxl=1, _styl=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), \

                _dcn = c2>c1?c2-c1:(_scn=-1,c1-c2), \

                _dcr = c2>c0?c2-c0:(_scr=-1,c0-c2), \

                _dcl = c1>c0?c1-c0:(_scl=-1,c0-c1), \

                _dtxn = tx2>tx1?tx2-tx1:(_stxn=-1,tx1-tx2), \

                _dtxr = tx2>tx0?tx2-tx0:(_stxr=-1,tx0-tx2), \

                _dtxl = tx1>tx0?tx1-tx0:(_stxl=-1,tx0-tx1), \

                _dtyn = ty2>ty1?ty2-ty1:(_styn=-1,ty1-ty2), \

                _dtyr = ty2>ty0?ty2-ty0:(_styr=-1,ty0-ty2), \

                _dtyl = ty1>ty0?ty1-ty0:(_styl=-1,ty0-ty1), \

                _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, \

                           _dcn-=_dyn?_dyn*(_dcn/_dyn):0, \

                           _dcr-=_dyr?_dyr*(_dcr/_dyr):0, \

                           _dcl-=_dyl?_dyl*(_dcl/_dyl):0, \

                           _dtxn-=_dyn?_dyn*(_dtxn/_dyn):0, \

                           _dtxr-=_dyr?_dyr*(_dtxr/_dyr):0, \

                           _dtxl-=_dyl?_dyl*(_dtxl/_dyl):0, \

                           _dtyn-=_dyn?_dyn*(_dtyn/_dyn):0, \

                           _dtyr-=_dyr?_dyr*(_dtyr/_dyr):0, \

                           _dtyl-=_dyl?_dyl*(_dtyl/_dyl):0, \

                           cimg::min((int)(img).height-y-1,y2-y)), \

                _errn = _dyn/2, _errcn = _errn, _errtxn = _errn, _errtyn = _errn, \

                _errr = _dyr/2, _errcr = _errr, _errtxr = _errr, _errtyr = _errr, \

                _errl = _dyl/2, _errcl = _errl, _errtxl = _errl, _errtyl = _errl, \

                _rxn = _dyn?(x2-x1)/_dyn:0, \

                _rcn = _dyn?(c2-c1)/_dyn:0, \

                _rtxn = _dyn?(tx2-tx1)/_dyn:0, \

                _rtyn = _dyn?(ty2-ty1)/_dyn:0, \

                _rxr = _dyr?(x2-x0)/_dyr:0, \

                _rcr = _dyr?(c2-c0)/_dyr:0, \

                _rtxr = _dyr?(tx2-tx0)/_dyr:0, \

                _rtyr = _dyr?(ty2-ty0)/_dyr:0, \

                _rxl = (y0!=y1 && y1>0)?(_dyl?(x1-x0)/_dyl:0): \

                                        (_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxn), \

                _rcl = (y0!=y1 && y1>0)?(_dyl?(c1-c0)/_dyl:0): \

                                        (_errcl=_errcn, _dcl=_dcn, _dyl=_dyn, _scl=_scn, _rcn ), \

                _rtxl = (y0!=y1 && y1>0)?(_dyl?(tx1-tx0)/_dyl:0): \

                                         (_errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxn ), \

                _rtyl = (y0!=y1 && y1>0)?(_dyl?(ty1-ty0)/_dyl:0): \

                                         (_errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyn ); \

              _counter>=0; --_counter, ++y, \

                xr+=_rxr+((_errr-=_dxr)<0?_errr+=_dyr,_sxr:0), \

                cr+=_rcr+((_errcr-=_dcr)<0?_errcr+=_dyr,_scr:0), \

                txr+=_rtxr+((_errtxr-=_dtxr)<0?_errtxr+=_dyr,_stxr:0), \

                tyr+=_rtyr+((_errtyr-=_dtyr)<0?_errtyr+=_dyr,_styr:0), \

                xl+=(y!=y1)?(cl+=_rcl+((_errcl-=_dcl)<0?(_errcl+=_dyl,_scl):0), \

                             txl+=_rtxl+((_errtxl-=_dtxl)<0?(_errtxl+=_dyl,_stxl):0), \

                             tyl+=_rtyl+((_errtyl-=_dtyl)<0?(_errtyl+=_dyl,_styl):0), \

                             _rxl+((_errl-=_dxl)<0?(_errl+=_dyl,_sxl):0)): \

                (_errcl=_errcn, _dcl=_dcn, _dyl=_dyn, _scl=_scn, _rcl=_rcn, cl=c1, \

                 _errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxl=_rtxn, txl=tx1, \

                 _errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyl=_rtyn, tyl=ty1, \

                 _errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxl=_rxn, x1-xl))


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

         for (int y = y0<0?0:y0, \

                xr = y0>=0?x0:(x0-y0*(x2-x0)/(y2-y0)), \

                txr = y0>=0?tx0:(tx0-y0*(tx2-tx0)/(y2-y0)), \

                tyr = y0>=0?ty0:(ty0-y0*(ty2-ty0)/(y2-y0)), \

                lxr = y0>=0?lx0:(lx0-y0*(lx2-lx0)/(y2-y0)), \

                lyr = y0>=0?ly0:(ly0-y0*(ly2-ly0)/(y2-y0)), \

                xl = y1>=0?(y0>=0?(y0==y1?x1:x0):(x0-y0*(x1-x0)/(y1-y0))):(x1-y1*(x2-x1)/(y2-y1)), \

                txl = y1>=0?(y0>=0?(y0==y1?tx1:tx0):(tx0-y0*(tx1-tx0)/(y1-y0))):(tx1-y1*(tx2-tx1)/(y2-y1)), \

                tyl = y1>=0?(y0>=0?(y0==y1?ty1:ty0):(ty0-y0*(ty1-ty0)/(y1-y0))):(ty1-y1*(ty2-ty1)/(y2-y1)), \

                lxl = y1>=0?(y0>=0?(y0==y1?lx1:lx0):(lx0-y0*(lx1-lx0)/(y1-y0))):(lx1-y1*(lx2-lx1)/(y2-y1)), \

                lyl = y1>=0?(y0>=0?(y0==y1?ly1:ly0):(ly0-y0*(ly1-ly0)/(y1-y0))):(ly1-y1*(ly2-ly1)/(y2-y1)), \

                _sxn=1, _stxn=1, _styn=1, _slxn=1, _slyn=1, \

                _sxr=1, _stxr=1, _styr=1, _slxr=1, _slyr=1, \

                _sxl=1, _stxl=1, _styl=1, _slxl=1, _slyl=1, \

                _dxn = x2>x1?x2-x1:(_sxn=-1,x1-x2), _dyn = y2-y1, \

                _dxr = x2>x0?x2-x0:(_sxr=-1,x0-x2), _dyr = y2-y0, \

                _dxl = x1>x0?x1-x0:(_sxl=-1,x0-x1), _dyl = y1-y0, \

                _dtxn = tx2>tx1?tx2-tx1:(_stxn=-1,tx1-tx2), \

                _dtxr = tx2>tx0?tx2-tx0:(_stxr=-1,tx0-tx2), \

                _dtxl = tx1>tx0?tx1-tx0:(_stxl=-1,tx0-tx1), \

                _dtyn = ty2>ty1?ty2-ty1:(_styn=-1,ty1-ty2), \

                _dtyr = ty2>ty0?ty2-ty0:(_styr=-1,ty0-ty2), \

                _dtyl = ty1>ty0?ty1-ty0:(_styl=-1,ty0-ty1), \

                _dlxn = lx2>lx1?lx2-lx1:(_slxn=-1,lx1-lx2), \

                _dlxr = lx2>lx0?lx2-lx0:(_slxr=-1,lx0-lx2), \

                _dlxl = lx1>lx0?lx1-lx0:(_slxl=-1,lx0-lx1), \

                _dlyn = ly2>ly1?ly2-ly1:(_slyn=-1,ly1-ly2), \

                _dlyr = ly2>ly0?ly2-ly0:(_slyr=-1,ly0-ly2), \

                _dlyl = ly1>ly0?ly1-ly0:(_slyl=-1,ly0-ly1), \

                _counter =(_dxn-=_dyn?_dyn*(_dxn/_dyn):0, \

                           _dxr-=_dyr?_dyr*(_dxr/_dyr):0, \

                           _dxl-=_dyl?_dyl*(_dxl/_dyl):0, \

                           _dtxn-=_dyn?_dyn*(_dtxn/_dyn):0, \

                           _dtxr-=_dyr?_dyr*(_dtxr/_dyr):0, \

                           _dtxl-=_dyl?_dyl*(_dtxl/_dyl):0, \

                           _dtyn-=_dyn?_dyn*(_dtyn/_dyn):0, \

                           _dtyr-=_dyr?_dyr*(_dtyr/_dyr):0, \

                           _dtyl-=_dyl?_dyl*(_dtyl/_dyl):0, \

                           _dlxn-=_dyn?_dyn*(_dlxn/_dyn):0, \

                           _dlxr-=_dyr?_dyr*(_dlxr/_dyr):0, \

                           _dlxl-=_dyl?_dyl*(_dlxl/_dyl):0, \

                           _dlyn-=_dyn?_dyn*(_dlyn/_dyn):0, \

                           _dlyr-=_dyr?_dyr*(_dlyr/_dyr):0, \

                           _dlyl-=_dyl?_dyl*(_dlyl/_dyl):0, \

                           cimg::min((int)(img).height-y-1,y2-y)), \

                _errn = _dyn/2, _errtxn = _errn, _errtyn = _errn, _errlxn = _errn, _errlyn = _errn, \

                _errr = _dyr/2, _errtxr = _errr, _errtyr = _errr, _errlxr = _errr, _errlyr = _errr, \

                _errl = _dyl/2, _errtxl = _errl, _errtyl = _errl, _errlxl = _errl, _errlyl = _errl, \

                _rxn = _dyn?(x2-x1)/_dyn:0, \

                _rtxn = _dyn?(tx2-tx1)/_dyn:0, \

                _rtyn = _dyn?(ty2-ty1)/_dyn:0, \

                _rlxn = _dyn?(lx2-lx1)/_dyn:0, \

                _rlyn = _dyn?(ly2-ly1)/_dyn:0, \

                _rxr = _dyr?(x2-x0)/_dyr:0, \

                _rtxr = _dyr?(tx2-tx0)/_dyr:0, \

                _rtyr = _dyr?(ty2-ty0)/_dyr:0, \

                _rlxr = _dyr?(lx2-lx0)/_dyr:0, \

                _rlyr = _dyr?(ly2-ly0)/_dyr:0, \

                _rxl = (y0!=y1 && y1>0)?(_dyl?(x1-x0)/_dyl:0): \

                                        (_errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxn), \

                _rtxl = (y0!=y1 && y1>0)?(_dyl?(tx1-tx0)/_dyl:0): \

                                         (_errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxn ), \

                _rtyl = (y0!=y1 && y1>0)?(_dyl?(ty1-ty0)/_dyl:0): \

                                         (_errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyn ), \

                _rlxl = (y0!=y1 && y1>0)?(_dyl?(lx1-lx0)/_dyl:0): \

                                         (_errlxl=_errlxn, _dlxl=_dlxn, _dyl=_dyn, _slxl=_slxn, _rlxn ), \

                _rlyl = (y0!=y1 && y1>0)?(_dyl?(ly1-ly0)/_dyl:0): \

                                         (_errlyl=_errlyn, _dlyl=_dlyn, _dyl=_dyn, _slyl=_slyn, _rlyn ); \

              _counter>=0; --_counter, ++y, \

                xr+=_rxr+((_errr-=_dxr)<0?_errr+=_dyr,_sxr:0), \

                txr+=_rtxr+((_errtxr-=_dtxr)<0?_errtxr+=_dyr,_stxr:0), \

                tyr+=_rtyr+((_errtyr-=_dtyr)<0?_errtyr+=_dyr,_styr:0), \

                lxr+=_rlxr+((_errlxr-=_dlxr)<0?_errlxr+=_dyr,_slxr:0), \

                lyr+=_rlyr+((_errlyr-=_dlyr)<0?_errlyr+=_dyr,_slyr:0), \

                xl+=(y!=y1)?(txl+=_rtxl+((_errtxl-=_dtxl)<0?(_errtxl+=_dyl,_stxl):0), \

                             tyl+=_rtyl+((_errtyl-=_dtyl)<0?(_errtyl+=_dyl,_styl):0), \

                             lxl+=_rlxl+((_errlxl-=_dlxl)<0?(_errlxl+=_dyl,_slxl):0), \

                             lyl+=_rlyl+((_errlyl-=_dlyl)<0?(_errlyl+=_dyl,_slyl):0), \

                             _rxl+((_errl-=_dxl)<0?(_errl+=_dyl,_sxl):0)): \

                (_errtxl=_errtxn, _dtxl=_dtxn, _dyl=_dyn, _stxl=_stxn, _rtxl=_rtxn, txl=tx1, \

                 _errtyl=_errtyn, _dtyl=_dtyn, _dyl=_dyn, _styl=_styn, _rtyl=_rtyn, tyl=ty1, \

                 _errlxl=_errlxn, _dlxl=_dlxn, _dyl=_dyn, _slxl=_slxn, _rlxl=_rlxn, lxl=lx1, \

                 _errlyl=_errlyn, _dlyl=_dlyn, _dyl=_dyn, _slyl=_slyn, _rlyl=_rlyn, lyl=ly1, \

                 _errl=_errn, _dxl=_dxn, _dyl=_dyn, _sxl=_sxn, _rxl=_rxn, x1-xl))


     // Draw a colored triangle (inner routine, uses bresenham's algorithm).

     template<typename tc>

     CImg<T>& _draw_triangle(const int x0, const int y0,

                             const int x1, const int y1,

                             const int x2, const int y2,

                             const tc *const color, const float opacity,

                             const float brightness) {

       _draw_scanline(color,opacity);

       const float nbrightness = brightness<0?0:(brightness>2?2:brightness);

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2);

       if (ny0<dimy() && ny2>=0) {

         if ((nx1 - nx0)*(ny2 - ny0) - (nx2 - nx0)*(ny1 - ny0)<0)

           _cimg_for_triangle1(*this,xl,xr,y,nx0,ny0,nx1,ny1,nx2,ny2) _draw_scanline(xl,xr,y,color,opacity,nbrightness);

         else

           _cimg_for_triangle1(*this,xl,xr,y,nx0,ny0,nx1,ny1,nx2,ny2) _draw_scanline(xr,xl,y,color,opacity,nbrightness);

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const tc *const color, const float opacity=1) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle : Specified color is (null).",

                                     pixel_type());

       _draw_triangle(x0,y0,x1,y1,x2,y2,color,opacity,1);

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_triangle(x0,y0,x1,y1,x2,y2,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const tc *const color, const float opacity,

                            const unsigned int pattern) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle : Specified color is (null).",

                                     pixel_type());

       draw_line(x0,y0,x1,y1,color,opacity,pattern,true).

         draw_line(x1,y1,x2,y2,color,opacity,pattern,false).

         draw_line(x2,y2,x0,y0,color,opacity,pattern,false);

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& color, const float opacity,

                            const unsigned int pattern) {

       return draw_triangle(x0,y0,x1,y1,x2,y2,color.data,opacity,pattern);

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const tc *const color, const float opacity=1,

                            const float brightness=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified color is (null).",

                                     pixel_type());

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float

         nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0),

         nbrightness = brightness<0?0:(brightness>2?2:brightness);

       const int whz = width*height*depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2;

       float nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1)));

       _cimg_for_triangle1(*this,xleft0,xright0,y,nx0,ny0,nx1,ny1,nx2,ny2) {

         if (y==ny1) { zl = nz1; pzl = pzn; }

         int xleft = xleft0, xright = xright0;

         float zleft = zl, zright = zr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright);

         const int dx = xright - xleft;

         const float pentez = (zright - zleft)/dx;

         if (xleft<0 && dx) zleft-=xleft*(zright - zleft)/dx;

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)*(col++); ptrd+=whz; }

               ptrd-=offx;

             }

             zleft+=pentez;

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)(nbrightness*(*col++)); ptrd+=whz; }

               ptrd-=offx;

             }

             zleft+=pentez;

           } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)((2-nbrightness)**(col++) + (nbrightness-1)*maxval); ptrd+=whz; }

               ptrd-=offx;

             }

             zleft+=pentez;

           }

         } else {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)(nopacity**(col++) + *ptrd*copacity); ptrd+=whz; }

               ptrd-=offx;

             }

             zleft+=pentez;

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color; cimg_forV(*this,k) { *ptrd = (T)(nopacity*nbrightness**(col++) + *ptrd*copacity); ptrd+=whz; }

               ptrd-=offx;

             }

             zleft+=pentez;

           } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const tc *col = color;

               cimg_forV(*this,k) {

                 const T val = (T)((2-nbrightness)**(col++) + (nbrightness-1)*maxval);

                 *ptrd = (T)(nopacity*val + *ptrd*copacity);

                 ptrd+=whz;

               }

               ptrd-=offx;

             }

             zleft+=pentez;

           }

         }

         zr+=pzr; zl+=pzl;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& color, const float opacity=1,

                            const float brightness=1) {

       return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color.data,opacity,brightness);

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const tc *const color,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle : Specified color is (null).",

                                     pixel_type());

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nc0 = (int)((brightness0<0.0f?0.0f:(brightness0>2.0f?2.0f:brightness0))*256.0f),

         nc1 = (int)((brightness1<0.0f?0.0f:(brightness1>2.0f?2.0f:brightness1))*256.0f),

         nc2 = (int)((brightness2<0.0f?0.0f:(brightness2>2.0f?2.0f:brightness2))*256.0f);

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nc0,nc1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,nc0,nc2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,nc1,nc2);

       if (ny0>=dimy() || ny2<0) return *this;

       _cimg_for_triangle2(*this,xleft0,cleft0,xright0,cright0,y,nx0,ny0,nc0,nx1,ny1,nc1,nx2,ny2,nc2) {

         int xleft = xleft0, xright = xright0, cleft = cleft0, cright = cright0;

         if (xright<xleft) cimg::swap(xleft,xright,cleft,cright);

         const int

           dx = xright - xleft,

           dc = cright>cleft?cright - cleft:cleft - cright,

           rc = dx?(cright - cleft)/dx:0,

           sc = cright>cleft?1:-1,

           ndc = dc-(dx?dx*(dc/dx):0);

         int errc = dx>>1;

         if (xleft<0 && dx) cleft-=xleft*(cright - cleft)/dx;

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const tc *col = color;

           cimg_forV(*this,k) {

             *ptrd = (T)(cleft<256?cleft**(col++)/256:((512-cleft)**(col++)+(cleft-256)*maxval)/256);

             ptrd+=whz;

           }

           ptrd-=offx;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         } else for (int x = xleft; x<=xright; ++x) {

           const tc *col = color;

           cimg_forV(*this,k) {

             const T val = (T)(cleft<256?cleft**(col++)/256:((512-cleft)**(col++)+(cleft-256)*maxval)/256);

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz;

           }

           ptrd-=offx;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& color,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       return draw_triangle(x0,y0,x1,y1,x2,y2,color.data,brightness0,brightness1,brightness2,opacity);

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const tc *const color,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified color is (null).",

                                     pixel_type());

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nc0 = (int)((brightness0<0.0f?0.0f:(brightness0>2.0f?2.0f:brightness0))*256.0f),

         nc1 = (int)((brightness1<0.0f?0.0f:(brightness1>2.0f?2.0f:brightness1))*256.0f),

         nc2 = (int)((brightness2<0.0f?0.0f:(brightness2>2.0f?2.0f:brightness2))*256.0f);

       float nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nz0,nz1,nc0,nc1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,nz0,nz2,nc0,nc2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,nz1,nz2,nc1,nc2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1)));

       _cimg_for_triangle2(*this,xleft0,cleft0,xright0,cright0,y,nx0,ny0,nc0,nx1,ny1,nc1,nx2,ny2,nc2) {

         if (y==ny1) { zl = nz1; pzl = pzn; }

         int xleft = xleft0, xright = xright0, cleft = cleft0, cright = cright0;

         float zleft = zl, zright = zr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,cleft,cright);

         const int

           dx = xright - xleft,

           dc = cright>cleft?cright - cleft:cleft - cright,

           rc = dx?(cright-cleft)/dx:0,

           sc = cright>cleft?1:-1,

           ndc = dc-(dx?dx*(dc/dx):0);

         const float pentez = (zright - zleft)/dx;

         int errc = dx>>1;

         if (xleft<0 && dx) {

           cleft-=xleft*(cright - cleft)/dx;

           zleft-=xleft*(zright - zleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T *ptrd = ptr(xleft,y);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x, ++ptrd, ++ptrz) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const tc *col = color;

             cimg_forV(*this,k) {

               *ptrd = (T)(cleft<256?cleft**(col++)/256:((512-cleft)**(col++)+(cleft-256)*maxval)/256);

               ptrd+=whz;

             }

             ptrd-=offx;

           }

           zleft+=pentez;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         } else for (int x = xleft; x<=xright; ++x, ++ptrd, ++ptrz) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const tc *col = color;

             cimg_forV(*this,k) {

               const T val = (T)(cleft<256?cleft**(col++)/256:((512-cleft)**(col++)+(cleft-256)*maxval)/256);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz;

             }

             ptrd-=offx;

           }

           zleft+=pentez;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         }

         zr+=pzr; zl+=pzl;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& color,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color.data,brightness0,brightness1,brightness2,opacity);

     }


     template<typename tc1, typename tc2, typename tc3>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const tc1 *const color1,

                            const tc2 *const color2,

                            const tc3 *const color3,

                            const float opacity=1) {

       const unsigned char one = 1;

       cimg_forV(*this,k) get_shared_channel(k).draw_triangle(x0,y0,x1,y1,x2,y2,&one,color1[k],color2[k],color3[k],opacity);

       return *this;

     }


     template<typename tc1, typename tc2, typename tc3>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc1>& color1,

                            const CImg<tc2>& color2,

                            const CImg<tc3>& color3,

                            const float opacity=1) {

       return draw_triangle(x0,y0,x1,y1,x2,y2,color1.data,color2.data,color3.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float opacity=1,

                            const float brightness=1) {

       if (is_empty()) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_triangle(x0,y0,x1,y1,x2,y2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,opacity,brightness);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float

         nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0),

         nbrightness = brightness<0?0:(brightness>2?2:brightness);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         ntx0 = tx0, nty0 = ty0, ntx1 = tx1, nty1 = ty1, ntx2 = tx2, nty2 = ty2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2);

       if (ny0>=dimy() || ny2<0) return *this;

       _cimg_for_triangle3(*this,xleft0,txleft0,tyleft0,xright0,txright0,tyright0,y,

                           nx0,ny0,ntx0,nty0,nx1,ny1,ntx1,nty1,nx2,ny2,ntx2,nty2) {

         int

           xleft = xleft0, xright = xright0,

           txleft = txleft0, txright = txright0,

           tyleft = tyleft0, tyright = tyright0;

         if (xright<xleft) cimg::swap(xleft,xright,txleft,txright,tyleft,tyright);

         const int

           dx = xright - xleft,

           dtx = txright>txleft?txright - txleft:txleft - txright,

           dty = tyright>tyleft?tyright - tyleft:tyleft - tyright,

           rtx = dx?(txright - txleft)/dx:0,

           rty = dx?(tyright - tyleft)/dx:0,

           stx = txright>txleft?1:-1,

           sty = tyright>tyleft?1:-1,

           ndtx = dtx - (dx?dx*(dtx/dx):0),

           ndty = dty - (dx?dx*(dty/dx):0);

         int errtx = dx>>1, errty = errtx;

         if (xleft<0 && dx) {

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               *ptrd = (T)*col;

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               *ptrd = (T)(nbrightness**col);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           } else for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               *ptrd = (T)((2-nbrightness)**(col++) + (nbrightness-1)*maxval);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           }

         } else {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               *ptrd = (T)(nopacity**col + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               *ptrd = (T)(nopacity*nbrightness**col + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           } else for (int x = xleft; x<=xright; ++x) {

             const tc *col = texture.ptr(txleft,tyleft);

             cimg_forV(*this,k) {

               const T val = (T)((2-nbrightness)**(col++) + (nbrightness-1)*maxval);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

             txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

             tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

           }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float opacity=1,

                            const float brightness=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,opacity,brightness);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float

         nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0),

         nbrightness = brightness<0?0:(brightness>2?2:brightness);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2;

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle1(*this,xleft0,xright0,y,nx0,ny0,nx1,ny1,nx2,ny2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int xleft = xleft0, xright = xright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright);

         const int dx = xright - xleft;

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         if (xleft<0 && dx) {

           zleft-=xleft*(zright - zleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)*col;

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else if (nbrightness<1) for (int x=xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)(nbrightness**col);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else for (int x = xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)((2-nbrightness)**col + (nbrightness-1)*maxval);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           }

         } else {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)(nopacity**col + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)(nopacity*nbrightness**col + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else for (int x = xleft; x<=xright; ++x) {

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               const T val = (T)((2-nbrightness)**col + (nbrightness-1)*maxval);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           }

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float opacity=1,

                            const float brightness=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,opacity,brightness);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float

         nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0),

         nbrightness = brightness<0?0:(brightness>2?2:brightness);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2;

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle1(*this,xleft0,xright0,y,nx0,ny0,nx1,ny1,nx2,ny2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int xleft = xleft0, xright = xright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright);

         const int dx = xright - xleft;

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         if (xleft<0 && dx) {

           zleft-=xleft*(zright - zleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T *ptrd = ptr(xleft,y,0,0);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 *ptrd = (T)*col;

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 *ptrd = (T)(nbrightness**col);

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 *ptrd = (T)((2-nbrightness)**col + (nbrightness-1)*maxval);

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           }

         } else {

           if (nbrightness==1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 *ptrd = (T)(nopacity**col + *ptrd*copacity);

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else if (nbrightness<1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 *ptrd = (T)(nopacity*nbrightness**col + *ptrd*copacity);

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

             if (zleft>*ptrz) {

               *ptrz = zleft;

               const float invz = 1/zleft;

               const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

               cimg_forV(*this,k) {

                 const T val = (T)((2-nbrightness)**col + (nbrightness-1)*maxval);

                 *ptrd = (T)(nopacity*val + *ptrd*copacity);

                 ptrd+=whz; col+=twhz;

               }

               ptrd-=offx;

             }

             zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           }

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const tc *const color,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle : Specified color is (null).",

                                     pixel_type());

       if (!light)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified light texture (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),light.width,light.height,light.depth,light.dim,light.data);

       if (is_overlapped(light)) return draw_triangle(x0,y0,x1,y1,x2,y2,color,+light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nlx0 = lx0, nly0 = ly0, nlx1 = lx1, nly1 = ly1, nlx2 = lx2, nly2 = ly2;

       const int whz = width*height*depth, offx = dim*whz-1;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nlx0,nlx1,nly0,nly1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,nlx0,nlx2,nly0,nly2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,nlx1,nlx2,nly1,nly2);

       if (ny0>=dimy() || ny2<0) return *this;

       _cimg_for_triangle3(*this,xleft0,lxleft0,lyleft0,xright0,lxright0,lyright0,y,

                           nx0,ny0,nlx0,nly0,nx1,ny1,nlx1,nly1,nx2,ny2,nlx2,nly2) {

         int

           xleft = xleft0, xright = xright0,

           lxleft = lxleft0, lxright = lxright0,

           lyleft = lyleft0, lyright = lyright0;

         if (xright<xleft) cimg::swap(xleft,xright,lxleft,lxright,lyleft,lyright);

         const int

           dx = xright - xleft,

           dlx = lxright>lxleft?lxright - lxleft:lxleft - lxright,

           dly = lyright>lyleft?lyright - lyleft:lyleft - lyright,

           rlx = dx?(lxright - lxleft)/dx:0,

           rly = dx?(lyright - lyleft)/dx:0,

           slx = lxright>lxleft?1:-1,

           sly = lyright>lyleft?1:-1,

           ndlx = dlx - (dx?dx*(dlx/dx):0),

           ndly = dly - (dx?dx*(dly/dx):0);

         int errlx = dx>>1, errly = errlx;

         if (xleft<0 && dx) {

           lxleft-=xleft*(lxright - lxleft)/dx;

           lyleft-=xleft*(lyright - lyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const tl l = light(lxleft,lyleft);

           const tc *col = color;

           cimg_forV(*this,k) {

             *ptrd = (T)(l<1?l**(col++):((2-l)**(col++)+(l-1)*maxval));

             ptrd+=whz;

           }

           ptrd-=offx;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         } else  for (int x = xleft; x<=xright; ++x) {

           const tl l = light(lxleft,lyleft);

           const tc *col = color;

           cimg_forV(*this,k) {

             const T val = (T)(l<1?l**(col++):((2-l)**(col++)+(l-1)*maxval));

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz;

           }

           ptrd-=offx;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         }

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& color,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       return draw_triangle(x0,y0,x1,y1,x2,y2,color.data,light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const tc *const color,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified color is (null).",

                                     pixel_type());

       if (!light)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified light texture (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),light.width,light.height,light.depth,light.dim,light.data);

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       if (is_overlapped(light)) return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,

                                                      +light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nlx0 = lx0, nly0 = ly0, nlx1 = lx1, nly1 = ly1, nlx2 = lx2, nly2 = ly2;

       float nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,nlx0,nlx1,nly0,nly1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,nlx0,nlx2,nly0,nly2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,nlx1,nlx2,nly1,nly2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1)));

       _cimg_for_triangle3(*this,xleft0,lxleft0,lyleft0,xright0,lxright0,lyright0,y,

                           nx0,ny0,nlx0,nly0,nx1,ny1,nlx1,nly1,nx2,ny2,nlx2,nly2) {

         if (y==ny1) { zl = nz1; pzl = pzn; }

         int

           xleft = xleft0, xright = xright0,

           lxleft = lxleft0, lxright = lxright0,

           lyleft = lyleft0, lyright = lyright0;

         float zleft = zl, zright = zr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,lxleft,lxright,lyleft,lyright);

         const int

           dx = xright - xleft,

           dlx = lxright>lxleft?lxright - lxleft:lxleft - lxright,

           dly = lyright>lyleft?lyright - lyleft:lyleft - lyright,

           rlx = dx?(lxright - lxleft)/dx:0,

           rly = dx?(lyright - lyleft)/dx:0,

           slx = lxright>lxleft?1:-1,

           sly = lyright>lyleft?1:-1,

           ndlx = dlx - (dx?dx*(dlx/dx):0),

           ndly = dly - (dx?dx*(dly/dx):0);

         const float pentez = (zright - zleft)/dx;

         int errlx = dx>>1, errly = errlx;

         if (xleft<0 && dx) {

           zleft-=xleft*(zright - zleft)/dx;

           lxleft-=xleft*(lxright - lxleft)/dx;

           lyleft-=xleft*(lyright - lyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T *ptrd = ptr(xleft,y,0,0);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const tl l = light(lxleft,lyleft);

             const tc *col = color;

             cimg_forV(*this,k) {

               const tc cval = *(col++);

               *ptrd = (T)(l<1?l*cval:(2-l)*cval+(l-1)*maxval);

               ptrd+=whz;

             }

             ptrd-=offx;

           }

           zleft+=pentez;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const tl l = light(lxleft,lyleft);

             const tc *col = color;

             cimg_forV(*this,k) {

               const tc cval = *(col++);

               const T val = (T)(l<1?l*cval:(2-l)*cval+(l-1)*maxval);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz;

             }

             ptrd-=offx;

           }

           zleft+=pentez;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         }

         zr+=pzr; zl+=pzl;

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& color,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color.data,light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       if (is_empty()) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture))

         return draw_triangle(x0,y0,x1,y1,x2,y2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,brightness0,brightness1,brightness2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         ntx0 = tx0, nty0 = ty0, ntx1 = tx1, nty1 = ty1, ntx2 = tx2, nty2 = ty2,

         nc0 = (int)((brightness0<0.0f?0.0f:(brightness0>2.0f?2.0f:brightness0))*256.0f),

         nc1 = (int)((brightness1<0.0f?0.0f:(brightness1>2.0f?2.0f:brightness1))*256.0f),

         nc2 = (int)((brightness2<0.0f?0.0f:(brightness2>2.0f?2.0f:brightness2))*256.0f);

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nc0,nc1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nc0,nc2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nc1,nc2);

       if (ny0>=dimy() || ny2<0) return *this;

       _cimg_for_triangle4(*this,xleft0,cleft0,txleft0,tyleft0,xright0,cright0,txright0,tyright0,y,

                           nx0,ny0,nc0,ntx0,nty0,nx1,ny1,nc1,ntx1,nty1,nx2,ny2,nc2,ntx2,nty2) {

         int

           xleft = xleft0, xright = xright0,

           cleft = cleft0, cright = cright0,

           txleft = txleft0, txright = txright0,

           tyleft = tyleft0, tyright = tyright0;

         if (xright<xleft) cimg::swap(xleft,xright,cleft,cright,txleft,txright,tyleft,tyright);

         const int

           dx = xright - xleft,

           dc = cright>cleft?cright - cleft:cleft - cright,

           dtx = txright>txleft?txright - txleft:txleft - txright,

           dty = tyright>tyleft?tyright - tyleft:tyleft - tyright,

           rc = dx?(cright - cleft)/dx:0,

           rtx = dx?(txright - txleft)/dx:0,

           rty = dx?(tyright - tyleft)/dx:0,

           sc = cright>cleft?1:-1,

           stx = txright>txleft?1:-1,

           sty = tyright>tyleft?1:-1,

           ndc = dc - (dx?dx*(dc/dx):0),

           ndtx = dtx - (dx?dx*(dtx/dx):0),

           ndty = dty - (dx?dx*(dty/dx):0);

         int errc = dx>>1, errtx = errc, errty = errc;

         if (xleft<0 && dx) {

           cleft-=xleft*(cright - cleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const tc *col = texture.ptr(txleft,tyleft);

           cimg_forV(*this,k) {

             *ptrd = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

           txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

           tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

         } else for (int x = xleft; x<=xright; ++x) {

           const tc *col = texture.ptr(txleft,tyleft);

           cimg_forV(*this,k) {

             const T val = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

           txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

           tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,

                                                        brightness0,brightness1,brightness2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nc0 = (int)((brightness0<0.0f?0.0f:(brightness0>2.0f?2.0f:brightness0))*256.0f),

         nc1 = (int)((brightness1<0.0f?0.0f:(brightness1>2.0f?2.0f:brightness1))*256.0f),

         nc2 = (int)((brightness2<0.0f?0.0f:(brightness2>2.0f?2.0f:brightness2))*256.0f);

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nz0,nz1,nc0,nc1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nz0,nz2,nc0,nc2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nz1,nz2,nc1,nc2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle2(*this,xleft0,cleft0,xright0,cright0,y,nx0,ny0,nc0,nx1,ny1,nc1,nx2,ny2,nc2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int

           xleft = xleft0, xright = xright0,

           cleft = cleft0, cright = cright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright,cleft,cright);

         const int

           dx = xright - xleft,

           dc = cright>cleft?cright - cleft:cleft - cright,

           rc = dx?(cright - cleft)/dx:0,

           sc = cright>cleft?1:-1,

           ndc = dc - (dx?dx*(dc/dx):0);

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         int errc = dx>>1;

         if (xleft<0 && dx) {

           cleft-=xleft*(cright - cleft)/dx;

           zleft-=xleft*(zright - zleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const float invz = 1/zleft;

           const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

           cimg_forV(*this,k) {

             *ptrd = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         } else for (int x = xleft; x<=xright; ++x) {

           const float invz = 1/zleft;

           const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

           cimg_forV(*this,k) {

             const T val = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const float brightness0,

                            const float brightness1,

                            const float brightness2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_line() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (is_overlapped(texture)) return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,

                                                        brightness0,brightness1,brightness2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nc0 = (int)((brightness0<0.0f?0.0f:(brightness0>2.0f?2.0f:brightness0))*256.0f),

         nc1 = (int)((brightness1<0.0f?0.0f:(brightness1>2.0f?2.0f:brightness1))*256.0f),

         nc2 = (int)((brightness2<0.0f?0.0f:(brightness2>2.0f?2.0f:brightness2))*256.0f);

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nz0,nz1,nc0,nc1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nz0,nz2,nc0,nc2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nz1,nz2,nc1,nc2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle2(*this,xleft0,cleft0,xright0,cright0,y,nx0,ny0,nc0,nx1,ny1,nc1,nx2,ny2,nc2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int

           xleft = xleft0, xright = xright0,

           cleft = cleft0, cright = cright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright,cleft,cright);

         const int

           dx = xright - xleft,

           dc = cright>cleft?cright - cleft:cleft - cright,

           rc = dx?(cright - cleft)/dx:0,

           sc = cright>cleft?1:-1,

           ndc = dc - (dx?dx*(dc/dx):0);

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         int errc = dx>>1;

         if (xleft<0 && dx) {

           cleft-=xleft*(cright - cleft)/dx;

           zleft-=xleft*(zright - zleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x, ++ptrd, ++ptrz) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

           }

           zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         } else for (int x = xleft; x<=xright; ++x, ++ptrd, ++ptrz) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const float invz = 1/zleft;

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               const T val = (T)(cleft<256?cleft**col/256:((512-cleft)**col+(cleft-256)*maxval)/256);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

           }

           zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           cleft+=rc+((errc-=ndc)<0?errc+=dx,sc:0);

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(const int x0, const int y0,

                            const int x1, const int y1,

                            const int x2, const int y2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       if (is_empty()) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (!light)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified light texture (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),light.width,light.height,light.depth,light.dim,light.data);

       if (is_overlapped(texture)) return draw_triangle(x0,y0,x1,y1,x2,y2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       if (is_overlapped(light))   return draw_triangle(x0,y0,x1,y1,x2,y2,texture,tx0,ty0,tx1,ty1,tx2,ty2,+light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         ntx0 = tx0, nty0 = ty0, ntx1 = tx1, nty1 = ty1, ntx2 = tx2, nty2 = ty2,

         nlx0 = lx0, nly0 = ly0, nlx1 = lx1, nly1 = ly1, nlx2 = lx2, nly2 = ly2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nlx0,nlx1,nly0,nly1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nlx0,nlx2,nly0,nly2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nlx1,nlx2,nly1,nly2);

       if (ny0>=dimy() || ny2<0) return *this;

       _cimg_for_triangle5(*this,xleft0,lxleft0,lyleft0,txleft0,tyleft0,xright0,lxright0,lyright0,txright0,tyright0,y,

                           nx0,ny0,nlx0,nly0,ntx0,nty0,nx1,ny1,nlx1,nly1,ntx1,nty1,nx2,ny2,nlx2,nly2,ntx2,nty2) {

         int

           xleft = xleft0, xright = xright0,

           lxleft = lxleft0, lxright = lxright0,

           lyleft = lyleft0, lyright = lyright0,

           txleft = txleft0, txright = txright0,

           tyleft = tyleft0, tyright = tyright0;

         if (xright<xleft) cimg::swap(xleft,xright,lxleft,lxright,lyleft,lyright,txleft,txright,tyleft,tyright);

         const int

           dx = xright - xleft,

           dlx = lxright>lxleft?lxright - lxleft:lxleft - lxright,

           dly = lyright>lyleft?lyright - lyleft:lyleft - lyright,

           dtx = txright>txleft?txright - txleft:txleft - txright,

           dty = tyright>tyleft?tyright - tyleft:tyleft - tyright,

           rlx = dx?(lxright - lxleft)/dx:0,

           rly = dx?(lyright - lyleft)/dx:0,

           rtx = dx?(txright - txleft)/dx:0,

           rty = dx?(tyright - tyleft)/dx:0,

           slx = lxright>lxleft?1:-1,

           sly = lyright>lyleft?1:-1,

           stx = txright>txleft?1:-1,

           sty = tyright>tyleft?1:-1,

           ndlx = dlx - (dx?dx*(dlx/dx):0),

           ndly = dly - (dx?dx*(dly/dx):0),

           ndtx = dtx - (dx?dx*(dtx/dx):0),

           ndty = dty - (dx?dx*(dty/dx):0);

         int errlx = dx>>1, errly = errlx, errtx = errlx, errty = errlx;

         if (xleft<0 && dx) {

           lxleft-=xleft*(lxright - lxleft)/dx;

           lyleft-=xleft*(lyright - lyleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const tl l = light(lxleft,lyleft);

           const tc *col = texture.ptr(txleft,tyleft);

           cimg_forV(*this,k) {

             *ptrd = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

           txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

           tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

         } else for (int x = xleft; x<=xright; ++x) {

           const tl l = light(lxleft,lyleft);

           const tc *col = texture.ptr(txleft,tyleft);

           cimg_forV(*this,k) {

             const T val = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

           txleft+=rtx+((errtx-=ndtx)<0?errtx+=dx,stx:0);

           tyleft+=rty+((errty-=ndty)<0?errty+=dx,sty:0);

         }

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (!light)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified light texture (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),light.width,light.height,light.depth,light.dim,light.data);

       if (is_overlapped(texture)) return draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,+texture,tx0,ty0,tx1,ty1,tx2,ty2,light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       if (is_overlapped(light)) return draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,texture,tx0,ty0,tx1,ty1,tx2,ty2,+light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz-1;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nlx0 = lx0, nly0 = ly0, nlx1 = lx1, nly1 = ly1, nlx2 = lx2, nly2 = ly2;

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nlx0,nlx1,nly0,nly1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nlx0,nlx2,nly0,nly2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nlx1,nlx2,nly1,nly2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle3(*this,xleft0,lxleft0,lyleft0,xright0,lxright0,lyright0,y,

                           nx0,ny0,nlx0,nly0,nx1,ny1,nlx1,nly1,nx2,ny2,nlx2,nly2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int

           xleft = xleft0, xright = xright0,

           lxleft = lxleft0, lxright = lxright0,

           lyleft = lyleft0, lyright = lyright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright,lxleft,lxright,lyleft,lyright);

         const int

           dx = xright - xleft,

           dlx = lxright>lxleft?lxright - lxleft:lxleft - lxright,

           dly = lyright>lyleft?lyright - lyleft:lyleft - lyright,

           rlx = dx?(lxright - lxleft)/dx:0,

           rly = dx?(lyright - lyleft)/dx:0,

           slx = lxright>lxleft?1:-1,

           sly = lyright>lyleft?1:-1,

           ndlx = dlx - (dx?dx*(dlx/dx):0),

           ndly = dly - (dx?dx*(dly/dx):0);

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         int errlx = dx>>1, errly = errlx;

         if (xleft<0 && dx) {

           zleft-=xleft*(zright - zleft)/dx;

           lxleft-=xleft*(lxright - lxleft)/dx;

           lyleft-=xleft*(lyright - lyleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y,0,0);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x) {

           const float invz = 1/zleft;

           const tl l = light(lxleft,lyleft);

           const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

           cimg_forV(*this,k) {

             *ptrd = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         } else for (int x = xleft; x<=xright; ++x) {

           const float invz = 1/zleft;

           const tl l = light(lxleft,lyleft);

           const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

           cimg_forV(*this,k) {

             const T val = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

             *ptrd = (T)(nopacity*val + *ptrd*copacity);

             ptrd+=whz; col+=twhz;

           }

           ptrd-=offx; zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     template<typename tc, typename tl>

     CImg<T>& draw_triangle(CImg<floatT>& zbuffer,

                            const int x0, const int y0, const float z0,

                            const int x1, const int y1, const float z1,

                            const int x2, const int y2, const float z2,

                            const CImg<tc>& texture,

                            const int tx0, const int ty0,

                            const int tx1, const int ty1,

                            const int tx2, const int ty2,

                            const CImg<tl>& light,

                            const int lx0, const int ly0,

                            const int lx1, const int ly1,

                            const int lx2, const int ly2,

                            const float opacity=1) {

       if (is_empty() || z0<=0 || z1<=0 || z2<=0) return *this;

       if (!is_sameXY(zbuffer))

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Z-buffer (%u,%u,%u,%u,%p) and instance image (%u,%u,%u,%u,%p) have different dimensions.",

                                     pixel_type(),zbuffer.width,zbuffer.height,zbuffer.depth,zbuffer.dim,zbuffer.data,width,height,depth,dim,data);

       if (!texture || texture.dim<dim)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified texture (%u,%u,%u,%u,%p) is not a valid argument.",

                                     pixel_type(),texture.width,texture.height,texture.depth,texture.dim,texture.data);

       if (!light)

         throw CImgArgumentException("CImg<%s>::draw_triangle() : Specified light texture (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),light.width,light.height,light.depth,light.dim,light.data);

       if (is_overlapped(texture)) return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,

                                                        +texture,tx0,ty0,tx1,ty1,tx2,ty2,light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       if (is_overlapped(light)) return draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,

                                                      texture,tx0,ty0,tx1,ty1,tx2,ty2,+light,lx0,ly0,lx1,ly1,lx2,ly2,opacity);

       static const T maxval = (T)cimg::min(cimg::type<T>::max(),cimg::type<tc>::max());

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const int whz = width*height*depth, twhz = texture.width*texture.height*texture.depth, offx = dim*whz;

       int nx0 = x0, ny0 = y0, nx1 = x1, ny1 = y1, nx2 = x2, ny2 = y2,

         nlx0 = lx0, nly0 = ly0, nlx1 = lx1, nly1 = ly1, nlx2 = lx2, nly2 = ly2;

       float

         ntx0 = tx0/z0, nty0 = ty0/z0,

         ntx1 = tx1/z1, nty1 = ty1/z1,

         ntx2 = tx2/z2, nty2 = ty2/z2,

         nz0 = 1/z0, nz1 = 1/z1, nz2 = 1/z2;

       if (ny0>ny1) cimg::swap(nx0,nx1,ny0,ny1,ntx0,ntx1,nty0,nty1,nlx0,nlx1,nly0,nly1,nz0,nz1);

       if (ny0>ny2) cimg::swap(nx0,nx2,ny0,ny2,ntx0,ntx2,nty0,nty2,nlx0,nlx2,nly0,nly2,nz0,nz2);

       if (ny1>ny2) cimg::swap(nx1,nx2,ny1,ny2,ntx1,ntx2,nty1,nty2,nlx1,nlx2,nly1,nly2,nz1,nz2);

       if (ny0>=dimy() || ny2<0) return *this;

       float

         ptxl = (ntx1 - ntx0)/(ny1 - ny0),

         ptxr = (ntx2 - ntx0)/(ny2 - ny0),

         ptxn = (ntx2 - ntx1)/(ny2 - ny1),

         ptyl = (nty1 - nty0)/(ny1 - ny0),

         ptyr = (nty2 - nty0)/(ny2 - ny0),

         ptyn = (nty2 - nty1)/(ny2 - ny1),

         pzl = (nz1 - nz0)/(ny1 - ny0),

         pzr = (nz2 - nz0)/(ny2 - ny0),

         pzn = (nz2 - nz1)/(ny2 - ny1),

         zr = ny0>=0?nz0:(nz0 - ny0*(nz2 - nz0)/(ny2 - ny0)),

         txr = ny0>=0?ntx0:(ntx0 - ny0*(ntx2 - ntx0)/(ny2 - ny0)),

         tyr = ny0>=0?nty0:(nty0 - ny0*(nty2 - nty0)/(ny2 - ny0)),

         zl = ny1>=0?(ny0>=0?nz0:(nz0 - ny0*(nz1 - nz0)/(ny1 - ny0))):(pzl=pzn,(nz1 - ny1*(nz2 - nz1)/(ny2 - ny1))),

         txl = ny1>=0?(ny0>=0?ntx0:(ntx0 - ny0*(ntx1 - ntx0)/(ny1 - ny0))):(ptxl=ptxn,(ntx1 - ny1*(ntx2 - ntx1)/(ny2 - ny1))),

         tyl = ny1>=0?(ny0>=0?nty0:(nty0 - ny0*(nty1 - nty0)/(ny1 - ny0))):(ptyl=ptyn,(nty1 - ny1*(nty2 - nty1)/(ny2 - ny1)));

       _cimg_for_triangle3(*this,xleft0,lxleft0,lyleft0,xright0,lxright0,lyright0,y,

                           nx0,ny0,nlx0,nly0,nx1,ny1,nlx1,nly1,nx2,ny2,nlx2,nly2) {

         if (y==ny1) { zl = nz1; txl = ntx1; tyl = nty1; pzl = pzn; ptxl = ptxn; ptyl = ptyn; }

         int

           xleft = xleft0, xright = xright0,

           lxleft = lxleft0, lxright = lxright0,

           lyleft = lyleft0, lyright = lyright0;

         float

           zleft = zl, zright = zr,

           txleft = txl, txright = txr,

           tyleft = tyl, tyright = tyr;

         if (xright<xleft) cimg::swap(xleft,xright,zleft,zright,txleft,txright,tyleft,tyright,lxleft,lxright,lyleft,lyright);

         const int

           dx = xright - xleft,

           dlx = lxright>lxleft?lxright - lxleft:lxleft - lxright,

           dly = lyright>lyleft?lyright - lyleft:lyleft - lyright,

           rlx = dx?(lxright - lxleft)/dx:0,

           rly = dx?(lyright - lyleft)/dx:0,

           slx = lxright>lxleft?1:-1,

           sly = lyright>lyleft?1:-1,

           ndlx = dlx - (dx?dx*(dlx/dx):0),

           ndly = dly - (dx?dx*(dly/dx):0);

         const float

           pentez = (zright - zleft)/dx,

           pentetx = (txright - txleft)/dx,

           pentety = (tyright - tyleft)/dx;

         int errlx = dx>>1, errly = errlx;

         if (xleft<0 && dx) {

           zleft-=xleft*(zright - zleft)/dx;

           lxleft-=xleft*(lxright - lxleft)/dx;

           lyleft-=xleft*(lyright - lyleft)/dx;

           txleft-=xleft*(txright - txleft)/dx;

           tyleft-=xleft*(tyright - tyleft)/dx;

         }

         if (xleft<0) xleft = 0;

         if (xright>=dimx()-1) xright = dimx()-1;

         T* ptrd = ptr(xleft,y);

         float *ptrz = zbuffer.ptr(xleft,y);

         if (opacity>=1) for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const float invz = 1/zleft;

             const tl l = light(lxleft,lyleft);

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               *ptrd = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

           }

           zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         } else for (int x = xleft; x<=xright; ++x, ++ptrz, ++ptrd) {

           if (zleft>*ptrz) {

             *ptrz = zleft;

             const float invz = 1/zleft;

             const tl l = light(lxleft,lyleft);

             const tc *col = texture.ptr((int)(txleft*invz),(int)(tyleft*invz));

             cimg_forV(*this,k) {

               const T val = (T)(l<1?l**col:(2-l)**col+(l-1)*maxval);

               *ptrd = (T)(nopacity*val + *ptrd*copacity);

               ptrd+=whz; col+=twhz;

             }

             ptrd-=offx;

           }

           zleft+=pentez; txleft+=pentetx; tyleft+=pentety;

           lxleft+=rlx+((errlx-=ndlx)<0?errlx+=dx,slx:0);

           lyleft+=rly+((errly-=ndly)<0?errly+=dx,sly:0);

         }

         zr+=pzr; txr+=ptxr; tyr+=ptyr; zl+=pzl; txl+=ptxl; tyl+=ptyl;

       }

       return *this;

     }


     CImg<T>& draw_rectangle(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 T val, const float opacity=1) {

       if (is_empty()) return *this;

       const bool bx = (x0<x1), by = (y0<y1), bz = (z0<z1), bv = (v0<v1);

       const int

         nx0 = bx?x0:x1, nx1 = bx?x1:x0,

         ny0 = by?y0:y1, ny1 = by?y1:y0,

         nz0 = bz?z0:z1, nz1 = bz?z1:z0,

         nv0 = bv?v0:v1, nv1 = bv?v1:v0;

       const int

         lX = (1 + nx1 - nx0) + (nx1>=dimx()?dimx() - 1 - nx1:0) + (nx0<0?nx0:0),

         lY = (1 + ny1 - ny0) + (ny1>=dimy()?dimy() - 1 - ny1:0) + (ny0<0?ny0:0),

         lZ = (1 + nz1 - nz0) + (nz1>=dimz()?dimz() - 1 - nz1:0) + (nz0<0?nz0:0),

         lV = (1 + nv1 - nv0) + (nv1>=dimv()?dimv() - 1 - nv1:0) + (nv0<0?nv0:0);

       const unsigned int offX = width - lX, offY = width*(height - lY), offZ = width*height*(depth - lZ);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       T *ptrd = ptr(nx0<0?0:nx0,ny0<0?0:ny0,nz0<0?0:nz0,nv0<0?0:nv0);

       if (lX>0 && lY>0 && lZ>0 && lV>0)

         for (int v = 0; v<lV; ++v) {

           for (int z = 0; z<lZ; ++z) {

             for (int y = 0; y<lY; ++y) {

               if (opacity>=1) {

                 if (sizeof(T)!=1) { for (int x = 0; x<lX; ++x) *(ptrd++) = val; ptrd+=offX; }

                 else { std::memset(ptrd,(int)val,lX); ptrd+=width; }

               } else { for (int x = 0; x<lX; ++x) { *ptrd = (T)(nopacity*val + *ptrd*copacity); ++ptrd; } ptrd+=offX; }

             }

             ptrd+=offY;

           }

           ptrd+=offZ;

         }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0, const int z0,

                             const int x1, const int y1, const int z1,

                             const tc *const color, const float opacity=1) {

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_rectangle : specified color is (null)",

                                     pixel_type());

       cimg_forV(*this,k) draw_rectangle(x0,y0,z0,k,x1,y1,z1,k,color[k],opacity);

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0, const int z0,

                             const int x1, const int y1, const int z1,

                             const CImg<tc>& color, const float opacity=1) {

       return draw_rectangle(x0,y0,z0,x1,y1,z1,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0, const int z0,

                             const int x1, const int y1, const int z1,

                             const tc *const color, const float opacity,

                             const unsigned int pattern) {

       return draw_line(x0,y0,z0,x1,y0,z0,color,opacity,pattern,true).

         draw_line(x1,y0,z0,x1,y1,z0,color,opacity,pattern,false).

         draw_line(x1,y1,z0,x0,y1,z0,color,opacity,pattern,false).

         draw_line(x0,y1,z0,x0,y0,z0,color,opacity,pattern,false).

         draw_line(x0,y0,z1,x1,y0,z1,color,opacity,pattern,true).

         draw_line(x1,y0,z1,x1,y1,z1,color,opacity,pattern,false).

         draw_line(x1,y1,z1,x0,y1,z1,color,opacity,pattern,false).

         draw_line(x0,y1,z1,x0,y0,z1,color,opacity,pattern,false).

         draw_line(x0,y0,z0,x0,y0,z1,color,opacity,pattern,true).

         draw_line(x1,y0,z0,x1,y0,z1,color,opacity,pattern,true).

         draw_line(x1,y1,z0,x1,y1,z1,color,opacity,pattern,true).

         draw_line(x0,y1,z0,x0,y1,z1,color,opacity,pattern,true);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0, const int z0,

                             const int x1, const int y1, const int z1,

                             const CImg<tc>& color, const float opacity,

                             const unsigned int pattern) {

       return draw_rectangle(x0,y0,z0,x1,y1,z1,color.data,opacity,pattern);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0,

                             const int x1, const int y1,

                             const tc *const color, const float opacity=1) {

       return draw_rectangle(x0,y0,0,x1,y1,depth-1,color,opacity);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0,

                             const int x1, const int y1,

                             const CImg<tc>& color, const float opacity=1) {

       return draw_rectangle(x0,y0,x1,y1,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0,

                             const int x1, const int y1,

                             const tc *const color, const float opacity,

                             const unsigned int pattern) {

       if (is_empty()) return *this;

       if (y0==y1) return draw_line(x0,y0,x1,y0,color,opacity,pattern,true);

       if (x0==x1) return draw_line(x0,y0,x0,y1,color,opacity,pattern,true);

       const bool bx = (x0<x1), by = (y0<y1);

       const int

         nx0 = bx?x0:x1, nx1 = bx?x1:x0,

         ny0 = by?y0:y1, ny1 = by?y1:y0;

       if (ny1==ny0+1) return draw_line(nx0,ny0,nx1,ny0,color,opacity,pattern,true).

                       draw_line(nx1,ny1,nx0,ny1,color,opacity,pattern,false);

       return draw_line(nx0,ny0,nx1,ny0,color,opacity,pattern,true).

         draw_line(nx1,ny0+1,nx1,ny1-1,color,opacity,pattern,false).

         draw_line(nx1,ny1,nx0,ny1,color,opacity,pattern,false).

         draw_line(nx0,ny1-1,nx0,ny0+1,color,opacity,pattern,false);

     }


     template<typename tc>

     CImg<T>& draw_rectangle(const int x0, const int y0,

                             const int x1, const int y1,

                             const CImg<tc>& color, const float opacity,

                             const unsigned int pattern) {

       return draw_rectangle(x0,y0,x1,y1,color.data,opacity,pattern);

     }


     // Inner routine for a drawing filled polygon with generic type for coordinates.

     template<typename t, typename tc>

     CImg<T>& _draw_polygon(const t& points, const unsigned int N,

                            const tc *const color, const float opacity) {

       if (is_empty() || !points || N<3) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_polygon() : Specified color is (null).",

                                     pixel_type());

       _draw_scanline(color,opacity);

       int xmin = (int)(~0U>>1), xmax = 0, ymin = (int)(~0U>>1), ymax = 0;

       for (unsigned int p = 0; p<N; ++p) {

         const int x = (int)points(p,0), y = (int)points(p,1);

         if (x<xmin) xmin = x;

         if (x>xmax) xmax = x;

         if (y<ymin) ymin = y;

         if (y>ymax) ymax = y;

       }

       if (xmax<0 || xmin>=dimx() || ymax<0 || ymin>=dimy()) return *this;

       const unsigned int

         nymin = ymin<0?0:(unsigned int)ymin,

         nymax = ymax>=dimy()?height-1:(unsigned int)ymax,

         dy = 1 + nymax - nymin;

       CImg<intT> X(1+2*N,dy,1,1,0), tmp;

       int cx = (int)points(0,0), cy = (int)points(0,1);

       for (unsigned int cp = 0, p = 0; p<N; ++p) {

         const unsigned int np = (p!=N-1)?p+1:0, ap = (np!=N-1)?np+1:0;

         const int

           nx = (int)points(np,0), ny = (int)points(np,1), ay = (int)points(ap,1),

           y0 = cy - nymin, y1 = ny - nymin;

         if (y0!=y1) {

           const int countermin = ((ny<ay && cy<ny) || (ny>ay && cy>ny))?1:0;

           for (int x = cx, y = y0, _sx = 1, _sy = 1,

                  _dx = nx>cx?nx-cx:((_sx=-1),cx-nx),

                  _dy = y1>y0?y1-y0:((_sy=-1),y0-y1),

                  _counter = ((_dx-=_dy?_dy*(_dx/_dy):0),_dy),

                  _err = _dx>>1,

                  _rx = _dy?(nx-cx)/_dy:0;

                _counter>=countermin;

                --_counter, y+=_sy, x+=_rx + ((_err-=_dx)<0?_err+=_dy,_sx:0))

             if (y>=0 && y<(int)dy) X(++X(0,y),y) = x;

           cp = np; cx = nx; cy = ny;

         } else {

           const int pp = (cp?cp-1:N-1), py = (int)points(pp,1);

           if ((cy>py && ay>cy) || (cy<py && ay<cy)) X(++X(0,y0),y0) = nx;

           if (cy!=ay) { cp = np; cx = nx; cy = ny; }

         }

       }

       for (int y = 0; y<(int)dy; ++y) {

         tmp.assign(X.ptr(1,y),X(0,y),1,1,1,true).sort();

         for (int i = 1; i<=X(0,y); ) {

           const int xb = X(i++,y), xe = X(i++,y);

           _draw_scanline(xb,xe,nymin+y,color,opacity);

         }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImgList<t>& points,

                           const tc *const color, const float opacity=1) {

       if (!points.is_sameY(2))

         throw CImgArgumentException("CImg<%s>::draw_polygon() : Given list of points is not valid.",

                                     pixel_type());

       return _draw_polygon(points,points.width,color,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImgList<t>& points,

                           const CImg<tc>& color, const float opacity=1) {

       return draw_polygon(points,color.data,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImg<t>& points,

                           const tc *const color, const float opacity=1) {

       if (points.height<2)

         throw CImgArgumentException("CImg<%s>::draw_polygon() : Given list of points is not valid.",

                                     pixel_type());

       return _draw_polygon(points,points.width,color,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImg<t>& points,

                           const CImg<tc>& color, const float opacity=1) {

       return draw_polygon(points,color.data,opacity);

     }


     // Inner routine for drawing an outlined polygon with generic point coordinates.

     template<typename t, typename tc>

     CImg<T>& _draw_polygon(const t& points, const unsigned int W, const unsigned int H,

                            const tc *const color, const float opacity,

                            const unsigned int pattern) {

       if (is_empty() || !points || W<3) return *this;

       bool ninit_hatch = true;

       switch (H) {

       case 0 : case 1 :

         throw CImgArgumentException("CImg<%s>::draw_polygon() : Given list of points is not valid.",

                                     pixel_type());

       case 2 : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1);

         int ox = x0, oy = y0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1);

           draw_line(ox,oy,x,y,color,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y;

         }

         draw_line(ox,oy,x0,y0,color,opacity,pattern,false);

       } break;

       default : {

         const int x0 = (int)points(0,0), y0 = (int)points(0,1), z0 = (int)points(0,2);

         int ox = x0, oy = y0, oz = z0;

         for (unsigned int i = 1; i<W; ++i) {

           const int x = (int)points(i,0), y = (int)points(i,1), z = (int)points(i,2);

           draw_line(ox,oy,oz,x,y,z,color,opacity,pattern,ninit_hatch);

           ninit_hatch = false;

           ox = x; oy = y; oz = z;

         }

         draw_line(ox,oy,oz,x0,y0,z0,color,opacity,pattern,false);

       }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImgList<t>& points,

                           const tc *const color, const float opacity,

                           const unsigned int pattern) {

       unsigned int H = ~0U; cimglist_for(points,p) H = cimg::min(H,(unsigned int)(points[p].size()));

       return _draw_polygon(points,points.width,H,color,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImgList<t>& points,

                           const CImg<tc>& color, const float opacity,

                           const unsigned int pattern) {

       return draw_polygon(points,color.data,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImg<t>& points,

                           const tc *const color, const float opacity,

                           const unsigned int pattern) {

       return _draw_polygon(points,points.width,points.height,color,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_polygon(const CImg<t>& points,

                           const CImg<tc>& color, const float opacity,

                           const unsigned int pattern) {

       return draw_polygon(points,color.data,opacity,pattern);

     }


     template<typename tc>

     CImg<T>& draw_circle(const int x0, const int y0, int radius,

                          const tc *const color, const float opacity=1) {

       if (!is_empty()) {

         if (!color)

           throw CImgArgumentException("CImg<%s>::draw_circle : Specified color is (null).",

                                       pixel_type());

         _draw_scanline(color,opacity);

         if (radius<0 || x0-radius>=dimx() || y0+radius<0 || y0-radius>=dimy()) return *this;

         if (y0>=0 && y0<dimy()) _draw_scanline(x0-radius,x0+radius,y0,color,opacity);

         for (int f = 1-radius, ddFx = 0, ddFy = -(radius<<1), x = 0, y = radius; x<y; ) {

           if (f>=0) {

             const int x1 = x0-x, x2 = x0+x, y1 = y0-y, y2 = y0+y;

             if (y1>=0 && y1<dimy()) _draw_scanline(x1,x2,y1,color,opacity);

             if (y2>=0 && y2<dimy()) _draw_scanline(x1,x2,y2,color,opacity);

             f+=(ddFy+=2); --y;

           }

           const bool no_diag = y!=(x++);

           ++(f+=(ddFx+=2));

           const int x1 = x0-y, x2 = x0+y, y1 = y0-x, y2 = y0+x;

           if (no_diag) {

             if (y1>=0 && y1<dimy()) _draw_scanline(x1,x2,y1,color,opacity);

             if (y2>=0 && y2<dimy()) _draw_scanline(x1,x2,y2,color,opacity);

           }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_circle(const int x0, const int y0, int radius,

                          const CImg<tc>& color, const float opacity=1) {

       return draw_circle(x0,y0,radius,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_circle(const int x0, const int y0, int radius,

                          const tc *const color, const float opacity,

                          const unsigned int) {

       if (!is_empty()) {

         if (!color)

           throw CImgArgumentException("CImg<%s>::draw_circle : Specified color is (null).",

                                       pixel_type());

         if (radius<0 || x0-radius>=dimx() || y0+radius<0 || y0-radius>=dimy()) return *this;

         if (!radius) return draw_point(x0,y0,color,opacity);

         draw_point(x0-radius,y0,color,opacity).draw_point(x0+radius,y0,color,opacity).

           draw_point(x0,y0-radius,color,opacity).draw_point(x0,y0+radius,color,opacity);

         if (radius==1) return *this;

         for (int f = 1-radius, ddFx = 0, ddFy = -(radius<<1), x = 0, y = radius; x<y; ) {

           if (f>=0) { f+=(ddFy+=2); --y; }

           ++x; ++(f+=(ddFx+=2));

           if (x!=y+1) {

             const int x1 = x0-y, x2 = x0+y, y1 = y0-x, y2 = y0+x, x3 = x0-x, x4 = x0+x, y3 = y0-y, y4 = y0+y;

             draw_point(x1,y1,color,opacity).draw_point(x1,y2,color,opacity).

               draw_point(x2,y1,color,opacity).draw_point(x2,y2,color,opacity);

             if (x!=y)

               draw_point(x3,y3,color,opacity).draw_point(x4,y4,color,opacity).

                 draw_point(x4,y3,color,opacity).draw_point(x3,y4,color,opacity);

           }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_circle(const int x0, const int y0, int radius, const CImg<tc>& color,

                          const float opacity,

                          const unsigned int pattern) {

       return draw_circle(x0,y0,radius,color.data,opacity,pattern);

     }


     // Draw a 2D ellipse (inner routine).

     template<typename tc>

     CImg<T>& _draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle,

                            const tc *const color, const float opacity,

                            const unsigned int pattern) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_ellipse : Specified color is (null).",

                                     pixel_type());

       _draw_scanline(color,opacity);

       const float

         nr1 = cimg::abs(r1), nr2 = cimg::abs(r2),

         nangle = (float)(angle*cimg::valuePI/180),

         u = (float)std::cos(nangle),

         v = (float)std::sin(nangle),

         rmax = cimg::max(nr1,nr2),

         l1 = (float)std::pow(rmax/(nr1>0?nr1:1e-6),2),

         l2 = (float)std::pow(rmax/(nr2>0?nr2:1e-6),2),

         a = l1*u*u + l2*v*v,

         b = u*v*(l1-l2),

         c = l1*v*v + l2*u*u;

       const int

         yb = (int)std::sqrt(a*rmax*rmax/(a*c-b*b)),

         tymin = y0 - yb - 1,

         tymax = y0 + yb + 1,

         ymin = tymin<0?0:tymin,

         ymax = tymax>=dimy()?height-1:tymax;

       int oxmin = 0, oxmax = 0;

       bool first_line = true;

       for (int y = ymin; y<=ymax; ++y) {

         const float

           Y = y-y0 + (y<y0?0.5f:-0.5f),

           delta = b*b*Y*Y-a*(c*Y*Y-rmax*rmax),

           sdelta = delta>0?(float)std::sqrt(delta)/a:0.0f,

           bY = b*Y/a,

           fxmin = x0-0.5f-bY-sdelta,

           fxmax = x0+0.5f-bY+sdelta;

         const int xmin = (int)fxmin, xmax = (int)fxmax;

         if (!pattern) _draw_scanline(xmin,xmax,y,color,opacity);

         else {

           if (first_line) {

             if (y0-yb>=0) _draw_scanline(xmin,xmax,y,color,opacity);

             else draw_point(xmin,y,color,opacity).draw_point(xmax,y,color,opacity);

             first_line = false;

           } else {

             if (xmin<oxmin) _draw_scanline(xmin,oxmin-1,y,color,opacity);

             else _draw_scanline(oxmin+(oxmin==xmin?0:1),xmin,y,color,opacity);

             if (xmax<oxmax) _draw_scanline(xmax,oxmax-1,y,color,opacity);

             else _draw_scanline(oxmax+(oxmax==xmax?0:1),xmax,y,color,opacity);

             if (y==tymax) _draw_scanline(xmin+1,xmax-1,y,color,opacity);

           }

         }

         oxmin = xmin; oxmax = xmax;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle,

                           const tc *const color, const float opacity=1) {

       return _draw_ellipse(x0,y0,r1,r2,angle,color,opacity,0U);

     }


     template<typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle,

                           const CImg<tc>& color, const float opacity=1) {

       return draw_ellipse(x0,y0,r1,r2,angle,color.data,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const CImg<t> &tensor,

                           const tc *const color, const float opacity=1) {

       CImgList<t> eig = tensor.get_symmetric_eigen();

       const CImg<t> &val = eig[0], &vec = eig[1];

       return draw_ellipse(x0,y0,val(0),val(1),vec(0,0),vec(0,1),color,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const CImg<t> &tensor,

                           const CImg<tc>& color, const float opacity=1) {

       return draw_ellipse(x0,y0,tensor,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle,

                           const tc *const color, const float opacity, const unsigned int pattern) {

       if (pattern) _draw_ellipse(x0,y0,r1,r2,angle,color,opacity,pattern);

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle,

                           const CImg<tc>& color, const float opacity, const unsigned int pattern) {

       return draw_ellipse(x0,y0,r1,r2,angle,color.data,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const CImg<t> &tensor,

                           const tc *const color, const float opacity,

                           const unsigned int pattern) {

       CImgList<t> eig = tensor.get_symmetric_eigen();

       const CImg<t> &val = eig[0], &vec = eig[1];

       return draw_ellipse(x0,y0,val(0),val(1),vec(0,0),vec(0,1),color,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_ellipse(const int x0, const int y0, const CImg<t> &tensor,

                           const CImg<tc>& color, const float opacity,

                           const unsigned int pattern) {

       return draw_ellipse(x0,y0,tensor,color.data,opacity,pattern);

     }


     template<typename t>

     CImg<T>& draw_image(const int x0, const int y0, const int z0, const int v0,

                         const CImg<t>& sprite, const float opacity=1) {

       if (is_empty()) return *this;

       if (!sprite)

         throw CImgArgumentException("CImg<%s>::draw_image() : Specified sprite image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),sprite.width,sprite.height,sprite.depth,sprite.dim,sprite.data);

       if (is_overlapped(sprite)) return draw_image(x0,y0,z0,v0,+sprite,opacity);

       const bool bx = (x0<0), by = (y0<0), bz = (z0<0), bv = (v0<0);

       const int

         lX = sprite.dimx() - (x0 + sprite.dimx()>dimx()?x0 + sprite.dimx() - dimx():0) + (bx?x0:0),

         lY = sprite.dimy() - (y0 + sprite.dimy()>dimy()?y0 + sprite.dimy() - dimy():0) + (by?y0:0),

         lZ = sprite.dimz() - (z0 + sprite.dimz()>dimz()?z0 + sprite.dimz() - dimz():0) + (bz?z0:0),

         lV = sprite.dimv() - (v0 + sprite.dimv()>dimv()?v0 + sprite.dimv() - dimv():0) + (bv?v0:0);

       const t

         *ptrs = sprite.data -

         (bx?x0:0) -

         (by?y0*sprite.dimx():0) -

         (bz?z0*sprite.dimx()*sprite.dimy():0) -

         (bv?v0*sprite.dimx()*sprite.dimy()*sprite.dimz():0);

       const unsigned int

         offX = width - lX,                soffX = sprite.width - lX,

         offY = width*(height - lY),       soffY = sprite.width*(sprite.height - lY),

         offZ = width*height*(depth - lZ), soffZ = sprite.width*sprite.height*(sprite.depth - lZ);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       if (lX>0 && lY>0 && lZ>0 && lV>0) {

         T *ptrd = ptr(x0<0?0:x0,y0<0?0:y0,z0<0?0:z0,v0<0?0:v0);

         for (int v = 0; v<lV; ++v) {

           for (int z = 0; z<lZ; ++z) {

             for (int y = 0; y<lY; ++y) {

               if (opacity>=1) for (int x = 0; x<lX; ++x) *(ptrd++) = (T)*(ptrs++);

               else for (int x = 0; x<lX; ++x) { *ptrd = (T)(nopacity*(*(ptrs++)) + *ptrd*copacity); ++ptrd; }

               ptrd+=offX; ptrs+=soffX;

             }

             ptrd+=offY; ptrs+=soffY;

           }

           ptrd+=offZ; ptrs+=soffZ;

         }

       }

       return *this;

     }


     // Optimized version (internal).

     CImg<T>& draw_image(const int x0, const int y0, const int z0, const int v0,

                         const CImg<T>& sprite, const float opacity=1) {

       if (is_empty()) return *this;

       if (!sprite)

         throw CImgArgumentException("CImg<%s>::draw_image() : Specified sprite image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),sprite.width,sprite.height,sprite.depth,sprite.dim,sprite.data);

       if (is_overlapped(sprite)) return draw_image(x0,y0,z0,v0,+sprite,opacity);

       const bool bx = (x0<0), by = (y0<0), bz = (z0<0), bv = (v0<0);

       const int

         lX = sprite.dimx() - (x0 + sprite.dimx()>dimx()?x0 + sprite.dimx() - dimx():0) + (bx?x0:0),

         lY = sprite.dimy() - (y0 + sprite.dimy()>dimy()?y0 + sprite.dimy() - dimy():0) + (by?y0:0),

         lZ = sprite.dimz() - (z0 + sprite.dimz()>dimz()?z0 + sprite.dimz() - dimz():0) + (bz?z0:0),

         lV = sprite.dimv() - (v0 + sprite.dimv()>dimv()?v0 + sprite.dimv() - dimv():0) + (bv?v0:0);

       const T

         *ptrs = sprite.data -

         (bx?x0:0) -

         (by?y0*sprite.dimx():0) -

         (bz?z0*sprite.dimx()*sprite.dimy():0) -

         (bv?v0*sprite.dimx()*sprite.dimy()*sprite.dimz():0);

       const unsigned int

         offX = width - lX,                soffX = sprite.width - lX,

         offY = width*(height - lY),       soffY = sprite.width*(sprite.height - lY),

         offZ = width*height*(depth - lZ), soffZ = sprite.width*sprite.height*(sprite.depth - lZ),

         slX = lX*sizeof(T);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       if (lX>0 && lY>0 && lZ>0 && lV>0) {

         T *ptrd = ptr(x0<0?0:x0,y0<0?0:y0,z0<0?0:z0,v0<0?0:v0);

         for (int v = 0; v<lV; ++v) {

           for (int z = 0; z<lZ; ++z) {

             if (opacity>=1) for (int y = 0; y<lY; ++y) { std::memcpy(ptrd,ptrs,slX); ptrd+=width; ptrs+=sprite.width; }

             else for (int y = 0; y<lY; ++y) {

               for (int x = 0; x<lX; ++x) { *ptrd = (T)(nopacity*(*(ptrs++)) + *ptrd*copacity); ++ptrd; }

               ptrd+=offX; ptrs+=soffX;

             }

             ptrd+=offY; ptrs+=soffY;

           }

           ptrd+=offZ; ptrs+=soffZ;

         }

       }

       return *this;

     }


     template<typename t>

     CImg<T>& draw_image(const int x0, const int y0, const int z0,

                         const CImg<t>& sprite, const float opacity=1) {

       return draw_image(x0,y0,z0,0,sprite,opacity);

     }


     template<typename t>

     CImg<T>& draw_image(const int x0, const int y0,

                         const CImg<t>& sprite, const float opacity=1) {

       return draw_image(x0,y0,0,sprite,opacity);

     }


     template<typename t>

     CImg<T>& draw_image(const int x0,

                         const CImg<t>& sprite, const float opacity=1) {

       return draw_image(x0,0,sprite,opacity);

     }


     template<typename t>

     CImg<T>& draw_image(const CImg<t>& sprite, const float opacity=1) {

       return draw_image(0,sprite,opacity);

     }


     template<typename ti, typename tm>

     CImg<T>& draw_image(const int x0, const int y0, const int z0, const int v0,

                         const CImg<ti>& sprite, const CImg<tm>& mask, const float opacity=1,

                         const float mask_valmax=1) {

       if (is_empty()) return *this;

       if (!sprite)

         throw CImgArgumentException("CImg<%s>::draw_image() : Specified sprite image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),sprite.width,sprite.height,sprite.depth,sprite.dim,sprite.data);

       if (!mask)

         throw CImgArgumentException("CImg<%s>::draw_image() : Specified mask image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);

       if (is_overlapped(sprite)) return draw_image(x0,y0,z0,v0,+sprite,mask,opacity,mask_valmax);

       if (is_overlapped(mask))   return draw_image(x0,y0,z0,v0,sprite,+mask,opacity,mask_valmax);

       if (mask.width!=sprite.width || mask.height!=sprite.height || mask.depth!=sprite.depth)

         throw CImgArgumentException("CImg<%s>::draw_image() : Mask dimension is (%u,%u,%u,%u), while sprite is (%u,%u,%u,%u)",

                                     pixel_type(),mask.width,mask.height,mask.depth,mask.dim,sprite.width,sprite.height,sprite.depth,sprite.dim);

       const bool bx = (x0<0), by = (y0<0), bz = (z0<0), bv = (v0<0);

       const int

         lX = sprite.dimx() - (x0 + sprite.dimx()>dimx()?x0 + sprite.dimx() - dimx():0) + (bx?x0:0),

         lY = sprite.dimy() - (y0 + sprite.dimy()>dimy()?y0 + sprite.dimy() - dimy():0) + (by?y0:0),

         lZ = sprite.dimz() - (z0 + sprite.dimz()>dimz()?z0 + sprite.dimz() - dimz():0) + (bz?z0:0),

         lV = sprite.dimv() - (v0 + sprite.dimv()>dimv()?v0 + sprite.dimv() - dimv():0) + (bv?v0:0);

       const int

         coff = -(bx?x0:0)-(by?y0*mask.dimx():0)-(bz?z0*mask.dimx()*mask.dimy():0)-(bv?v0*mask.dimx()*mask.dimy()*mask.dimz():0),

         ssize = mask.dimx()*mask.dimy()*mask.dimz();

       const ti *ptrs = sprite.data + coff;

       const tm *ptrm = mask.data   + coff;

       const unsigned int

         offX = width - lX,                soffX = sprite.width - lX,

         offY = width*(height - lY),       soffY = sprite.width*(sprite.height - lY),

         offZ = width*height*(depth - lZ), soffZ = sprite.width*sprite.height*(sprite.depth - lZ);

       if (lX>0 && lY>0 && lZ>0 && lV>0) {

         T *ptrd = ptr(x0<0?0:x0,y0<0?0:y0,z0<0?0:z0,v0<0?0:v0);

         for (int v = 0; v<lV; ++v) {

           ptrm = mask.data + (ptrm - mask.data)%ssize;

           for (int z = 0; z<lZ; ++z) {

             for (int y = 0; y<lY; ++y) {

               for (int x = 0; x<lX; ++x) {

                 const float mopacity = (float)(*(ptrm++)*opacity),

                   nopacity = cimg::abs(mopacity), copacity = mask_valmax - cimg::max(mopacity,0);

                 *ptrd = (T)((nopacity*(*(ptrs++)) + *ptrd*copacity)/mask_valmax);

                 ++ptrd;

               }

               ptrd+=offX; ptrs+=soffX; ptrm+=soffX;

             }

             ptrd+=offY; ptrs+=soffY; ptrm+=soffY;

           }

           ptrd+=offZ; ptrs+=soffZ; ptrm+=soffZ;

         }

       }

       return *this;

     }


     template<typename ti, typename tm>

     CImg<T>& draw_image(const int x0, const int y0, const int z0,

                         const CImg<ti>& sprite, const CImg<tm>& mask, const float opacity=1,

                         const float mask_valmax=1) {

       return draw_image(x0,y0,z0,0,sprite,mask,opacity,mask_valmax);

     }


     template<typename ti, typename tm>

     CImg<T>& draw_image(const int x0, const int y0,

                         const CImg<ti>& sprite, const CImg<tm>& mask, const float opacity=1,

                         const float mask_valmax=1) {

       return draw_image(x0,y0,0,sprite,mask,opacity,mask_valmax);

     }


     template<typename ti, typename tm>

     CImg<T>& draw_image(const int x0,

                         const CImg<ti>& sprite, const CImg<tm>& mask, const float opacity=1,

                         const float mask_valmax=1) {

       return draw_image(x0,0,sprite,mask,opacity,mask_valmax);

     }


     template<typename ti, typename tm>

     CImg<T>& draw_image(const CImg<ti>& sprite, const CImg<tm>& mask, const float opacity=1,

                         const float mask_valmax=1) {

       return draw_image(0,sprite,mask,opacity,mask_valmax);

     }


     template<typename tc1, typename tc2, typename t>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const tc1 *const foreground_color, const tc2 *const background_color,

                        const float opacity, const CImgList<t>& font, ...) {

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font);

       std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color,background_color,opacity,font);

     }


     template<typename tc1, typename tc2, typename t>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const CImg<tc1>& foreground_color, const CImg<tc2>& background_color,

                        const float opacity, const CImgList<t>& font, ...) {

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font);

       std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color,background_color,opacity,font);

     }


     template<typename tc, typename t>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const tc *const foreground_color, const int,

                        const float opacity, const CImgList<t>& font, ...) {

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font);

       std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color,(tc*)0,opacity,font);

     }


     template<typename tc, typename t>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const int, const tc *const background_color,

                        const float opacity, const CImgList<t>& font, ...) {

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font);

       std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,(tc*)0,background_color,opacity,font);

     }


     template<typename tc1, typename tc2>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const tc1 *const foreground_color, const tc2 *const background_color,

                        const float opacity=1, const unsigned int font_size=11, ...) {

       static CImgList<T> font;

       static unsigned int fsize = 0;

       if (fsize!=font_size) { font = CImgList<T>::font(font_size); fsize = font_size; }

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font_size); std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color,background_color,opacity,font);

     }


     template<typename tc1, typename tc2>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const CImg<tc1>& foreground_color, const CImg<tc2>& background_color,

                        const float opacity=1, const unsigned int font_size=11, ...) {

       static CImgList<T> font;

       static unsigned int fsize = 0;

       if (fsize!=font_size) { font = CImgList<T>::font(font_size); fsize = font_size; }

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font_size); std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color.data,background_color.data,opacity,font);

     }


     template<typename tc>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const tc *const foreground_color, const int background_color=0,

                        const float opacity=1, const unsigned int font_size=11, ...) {

       static CImgList<T> font;

       static unsigned int fsize = 0;

       if (fsize!=font_size) { font = CImgList<T>::font(font_size); fsize = font_size; }

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font_size); std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,foreground_color,(const tc*)background_color,opacity,font);

     }


     template<typename tc>

     CImg<T>& draw_text(const int x0, const int y0, const char *const text,

                        const int, const tc *const background_color,

                        const float opacity=1, const unsigned int font_size=11, ...) {

       static CImgList<T> font;

       static unsigned int fsize = 0;

       if (fsize!=font_size) { font = CImgList<T>::font(font_size); fsize = font_size; }

       char tmp[2048] = { 0 }; std::va_list ap; va_start(ap,font_size); std::vsprintf(tmp,text,ap); va_end(ap);

       return _draw_text(x0,y0,tmp,(tc*)0,background_color,opacity,font);

     }


     template<typename tc1, typename tc2, typename t>

     CImg<T>& _draw_text(const int x0, const int y0, const char *const text,

                         const tc1 *const foreground_color, const tc2 *const background_color,

                         const float opacity, const CImgList<t>& font) {

       if (!text) return *this;

       if (!font)

         throw CImgArgumentException("CImg<%s>::draw_text() : Specified font (%u,%p) is empty.",

                                     pixel_type(),font.width,font.data);

       const unsigned int text_length = std::strlen(text);


       if (is_empty()) {

         // If needed, pre-compute necessary size of the image

         int x = 0, y = 0, w = 0;

         unsigned char c = 0;

         for (unsigned int i = 0; i<text_length; ++i) {

           c = text[i];

           switch (c) {

           case '\n' : y+=font[' '].height; if (x>w) w = x; x = 0; break;

           case '\t' : x+=4*font[' '].width; break;

           default : if (c<font.width) x+=font[c].width;

           }

         }

         if (x!=0 || c=='\n') {

           if (x>w) w=x;

           y+=font[' '].height;

         }

         assign(x0+w,y0+y,1,font[' '].dim,0);

         if (background_color) cimg_forV(*this,k) get_shared_channel(k).fill((T)background_color[k]);

       }


       int x = x0, y = y0;

       CImg<T> letter;

       for (unsigned int i = 0; i<text_length; ++i) {

         const unsigned char c = text[i];

         switch (c) {

         case '\n' : y+=font[' '].height; x = x0; break;

         case '\t' : x+=4*font[' '].width; break;

         default : if (c<font.width) {

           letter = font[c];

           const CImg<T>& mask = (c+256)<(int)font.width?font[c+256]:font[c];

           if (foreground_color) for (unsigned int p = 0; p<letter.width*letter.height; ++p)

             if (mask(p)) cimg_forV(*this,k) letter(p,0,0,k) = (T)(letter(p,0,0,k)*foreground_color[k]);

           if (background_color) for (unsigned int p = 0; p<letter.width*letter.height; ++p)

             if (!mask(p)) cimg_forV(*this,k) letter(p,0,0,k) = (T)background_color[k];

           if (!background_color && font.width>=512) draw_image(x,y,letter,mask,opacity,(T)1);

           else draw_image(x,y,letter,opacity);

           x+=letter.width;

         }

         }

       }

       return *this;

     }


     template<typename t1, typename t2>

     CImg<T>& draw_quiver(const CImg<t1>& flow,

                          const t2 *const color, const float opacity=1,

                          const unsigned int sampling=25, const float factor=-20,

                          const bool arrows=true, const unsigned int pattern=~0U) {

       return draw_quiver(flow,CImg<t2>(color,dim,1,1,1,true),opacity,sampling,factor,arrows,pattern);

     }


     template<typename t1, typename t2>

     CImg<T>& draw_quiver(const CImg<t1>& flow,

                          const CImg<t2>& color, const float opacity=1,

                          const unsigned int sampling=25, const float factor=-20,

                          const bool arrows=true, const unsigned int pattern=~0U) {

       if (!is_empty()) {

         if (!flow || flow.dim!=2)

           throw CImgArgumentException("CImg<%s>::draw_quiver() : Specified flow (%u,%u,%u,%u,%p) has wrong dimensions.",

                                       pixel_type(),flow.width,flow.height,flow.depth,flow.dim,flow.data);

         if (sampling<=0)

           throw CImgArgumentException("CImg<%s>::draw_quiver() : Incorrect sampling value = %g",

                                       pixel_type(),sampling);

         const bool colorfield = (color.width==flow.width && color.height==flow.height && color.depth==1 && color.dim==dim);

         if (is_overlapped(flow)) return draw_quiver(+flow,color,opacity,sampling,factor,arrows,pattern);


         float vmax,fact;

         if (factor<=0) {

           float m, M = (float)flow.get_norm(2).maxmin(m);

           vmax = (float)cimg::max(cimg::abs(m),cimg::abs(M));

           fact = -factor;

         } else { fact = factor; vmax = 1; }


         for (unsigned int y=sampling/2; y<height; y+=sampling)

           for (unsigned int x=sampling/2; x<width; x+=sampling) {

             const unsigned int X = x*flow.width/width, Y = y*flow.height/height;

             float u = (float)flow(X,Y,0,0)*fact/vmax, v = (float)flow(X,Y,0,1)*fact/vmax;

             if (arrows) {

               const int xx = x+(int)u, yy = y+(int)v;

               if (colorfield) draw_arrow(x,y,xx,yy,color.get_vector_at(X,Y).data,opacity,45,sampling/5.0f,pattern);

               else draw_arrow(x,y,xx,yy,color,opacity,45,sampling/5.0f,pattern);

             } else {

               if (colorfield) draw_line((int)(x-0.5*u),(int)(y-0.5*v),(int)(x+0.5*u),(int)(y+0.5*v),color.get_vector_at(X,Y),opacity,pattern);

               else draw_line((int)(x-0.5*u),(int)(y-0.5*v),(int)(x+0.5*u),(int)(y+0.5*v),color,opacity,pattern);

             }

           }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_axis(const CImg<t>& xvalues, const int y,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U) {

       if (!is_empty()) {

         int siz = (int)xvalues.size()-1;

         if (siz<=0) draw_line(0,y,width-1,y,color,opacity,pattern);

         else {

           if (xvalues[0]<xvalues[siz]) draw_arrow(0,y,width-1,y,color,opacity,30,5,pattern);

           else draw_arrow(width-1,y,0,y,color,opacity,30,5,pattern);

           const int yt = (y+14)<dimy()?(y+3):(y-14);

           char txt[32] = { 0 };

           cimg_foroff(xvalues,x) {

             std::sprintf(txt,"%g",(double)xvalues(x));

             const int xi = (int)(x*(width-1)/siz), xt = xi-(int)std::strlen(txt)*3;

             draw_point(xi,y-1,color,opacity).draw_point(xi,y+1,color,opacity).

               draw_text(xt<0?0:xt,yt,txt,color,(tc*)0,opacity,11);

           }

         }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_axis(const CImg<t>& xvalues, const int y,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U) {

       return draw_axis(xvalues,y,color.data,opacity,pattern);

     }


     template<typename t, typename tc>

     CImg<T>& draw_axis(const int x, const CImg<t>& yvalues,

                        const tc *const color, const float opacity=1,

                        const unsigned int pattern=~0U) {

       if (!is_empty()) {

         int siz = (int)yvalues.size()-1;

         if (siz<=0) draw_line(x,0,x,height-1,color,opacity,pattern);

         else {

           if (yvalues[0]<yvalues[siz]) draw_arrow(x,0,x,height-1,color,opacity,30,5,pattern);

           else draw_arrow(x,height-1,x,0,color,opacity,30,5,pattern);

           char txt[32] = { 0 };

           cimg_foroff(yvalues,y) {

             std::sprintf(txt,"%g",(double)yvalues(y));

             const int

               yi = (int)(y*(height-1)/siz),

               tmp = yi-5,

               nyi = tmp<0?0:(tmp>=dimy()-11?dimy()-11:tmp),

               xt = x-(int)std::strlen(txt)*7;

             draw_point(x-1,yi,color,opacity).draw_point(x+1,yi,color,opacity);

             if (xt>0) draw_text(xt,nyi,txt,color,(tc*)0,opacity,11);

             else draw_text(x+3,nyi,txt,color,(tc*)0,opacity,11);

           }

         }

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_axis(const int x, const CImg<t>& yvalues,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int pattern=~0U) {

       return draw_axis(x,yvalues,color.data,opacity,pattern);

     }


     template<typename tx, typename ty, typename tc>

       CImg<T>& draw_axis(const CImg<tx>& xvalues, const CImg<ty>& yvalues,

                          const tc *const color, const float opacity=1,

                          const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       if (!is_empty()) {

         const CImg<tx> nxvalues(xvalues.data,xvalues.size(),1,1,1,true);

         const int sizx = (int)xvalues.size()-1, wm1 = (int)(width)-1;

         if (sizx>0) {

           float ox = (float)nxvalues[0];

           for (unsigned int x = 1; x<width; ++x) {

             const float nx = (float)nxvalues._linear_atX((float)x*sizx/wm1);

             if (nx*ox<=0) { draw_axis(nx==0?x:x-1,yvalues,color,opacity,patterny); break; }

             ox = nx;

           }

         }

         const CImg<ty> nyvalues(yvalues.data,yvalues.size(),1,1,1,true);

         const int sizy = (int)yvalues.size()-1, hm1 = (int)(height)-1;

         if (sizy>0) {

           float oy = (float)nyvalues[0];

           for (unsigned int y = 1; y<height; ++y) {

             const float ny = (float)nyvalues._linear_atX((float)y*sizy/hm1);

             if (ny*oy<=0) { draw_axis(xvalues,ny==0?y:y-1,color,opacity,patternx); break; }

             oy = ny;

           }

         }

       }

       return *this;

     }


     template<typename tx, typename ty, typename tc>

     CImg<T>& draw_axis(const CImg<tx>& xvalues, const CImg<ty>& yvalues,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       return draw_axis(xvalues,yvalues,color.data,opacity,patternx,patterny);

     }


     template<typename tc>

     CImg<T>& draw_axis(const float x0, const float x1, const float y0, const float y1,

                        const tc *const color, const float opacity=1,

                        const int subdivisionx=-60, const int subdivisiony=-60,

                        const float precisionx=0, const float precisiony=0,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       if (!is_empty()) {

         const float

           dx = cimg::abs(x1-x0), dy = cimg::abs(y1-y0),

           px = (precisionx==0)?(float)std::pow(10.0,(int)std::log10(dx)-2.0):precisionx,

           py = (precisiony==0)?(float)std::pow(10.0,(int)std::log10(dy)-2.0):precisiony;

         draw_axis(CImg<floatT>::sequence(subdivisionx>0?subdivisionx:1-dimx()/subdivisionx,x0,x1).round(px),

                   CImg<floatT>::sequence(subdivisiony>0?subdivisiony:1-dimy()/subdivisiony,y0,y1).round(py),

                   color,opacity,patternx,patterny);

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_axis(const float x0, const float x1, const float y0, const float y1,

                        const CImg<tc>& color, const float opacity=1,

                        const int subdivisionx=-60, const int subdivisiony=-60,

                        const float precisionx=0, const float precisiony=0,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       return draw_axis(x0,x1,y0,y1,color.data,opacity,subdivisionx,subdivisiony,precisionx,precisiony,patternx,patterny);

     }


     template<typename tx, typename ty, typename tc>

     CImg<T>& draw_grid(const CImg<tx>& xvalues, const CImg<ty>& yvalues,

                        const tc *const color, const float opacity=1,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       if (!is_empty()) {

         if (xvalues) cimg_foroff(xvalues,x) {

           const int xi = (int)xvalues[x];

           if (xi>=0 && xi<dimx()) draw_line(xi,0,xi,height-1,color,opacity,patternx);

         }

         if (yvalues) cimg_foroff(yvalues,y) {

           const int yi = (int)yvalues[y];

           if (yi>=0 && yi<dimy()) draw_line(0,yi,width-1,yi,color,opacity,patterny);

         }

       }

       return *this;

     }


     template<typename tx, typename ty, typename tc>

     CImg<T>& draw_grid(const CImg<tx>& xvalues, const CImg<ty>& yvalues,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       return draw_grid(xvalues,yvalues,color.data,opacity,patternx,patterny);

     }


     template<typename tc>

     CImg<T>& draw_grid(const float deltax,  const float deltay,

                        const float offsetx, const float offsety,

                        const bool invertx, const bool inverty,

                        const tc *const color, const float opacity=1,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       CImg<uintT> seqx, seqy;

       if (deltax!=0) {

         const float dx = deltax>0?deltax:width*-deltax/100;

         const unsigned int nx = (unsigned int)(width/dx);

         seqx = CImg<uintT>::sequence(1+nx,0,(unsigned int)(dx*nx));

         if (offsetx) cimg_foroff(seqx,x) seqx(x) = (unsigned int)cimg::mod(seqx(x)+offsetx,(float)width);

         if (invertx) cimg_foroff(seqx,x) seqx(x) = width-1-seqx(x);

       }


       if (deltay!=0) {

         const float dy = deltay>0?deltay:height*-deltay/100;

         const unsigned int ny = (unsigned int)(height/dy);

         seqy = CImg<uintT>::sequence(1+ny,0,(unsigned int)(dy*ny));

         if (offsety) cimg_foroff(seqy,y) seqy(y) = (unsigned int)cimg::mod(seqy(y)+offsety,(float)height);

         if (inverty) cimg_foroff(seqy,y) seqy(y) = height-1-seqy(y);

      }

       return draw_grid(seqx,seqy,color,opacity,patternx,patterny);

     }


     template<typename tc>

     CImg<T>& draw_grid(const float deltax,  const float deltay,

                        const float offsetx, const float offsety,

                        const bool invertx, const bool inverty,

                        const CImg<tc>& color, const float opacity=1,

                        const unsigned int patternx=~0U, const unsigned int patterny=~0U) {

       return draw_grid(deltax,deltay,offsetx,offsety,invertx,inverty,color.data,opacity,patternx,patterny);

     }


     template<typename t, typename tc>

     CImg<T>& draw_graph(const CImg<t>& data,

                         const tc *const color, const float opacity=1,

                         const unsigned int plot_type=1, const int vertex_type=1,

                         const double ymin=0, const double ymax=0, const bool expand=false,

                         const unsigned int pattern=~0U) {

       if (is_empty() || height<=1) return *this;

       const unsigned int siz = data.size();

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_graph() : Specified color is (null)",

                                     pixel_type());

       tc *color1 = 0, *color2 = 0;

       if (plot_type==3) {

         color1 = new tc[dim]; color2 = new tc[dim];

         cimg_forV(*this,k) { color1[k] = (tc)(color[k]*0.6f); color2[k] = (tc)(color[k]*0.3f); }

       }


       double m = ymin, M = ymax;

       if (ymin==ymax) m = (double)data.maxmin(M);

       if (m==M) { --m; ++M; }

       const float ca = (float)(M-m)/(height-1);

       bool init_hatch = true;

       const unsigned int xp = expand?1:0;


       // Draw graph edges

       switch (plot_type%4) {

       case 1 : { // Segments

         int oX = 0, oY = (int)((data[0]-m)/ca);

         for (unsigned int off = 1; off<siz; ++off) {

           const int

             X = (int)(off*width/(siz-xp)),

             Y = (int)((data[off]-m)/ca);

           draw_line(oX,oY,X,Y,color,opacity,pattern,init_hatch);

           oX = X; oY = Y;

           init_hatch = false;

         }

       } break;

       case 2 : { // Spline

         const CImg<t> ndata(data.data,siz,1,1,1,true);

         int oY = (int)((data[0]-m)/ca);

         cimg_forX(*this,x) {

           const int Y = (int)((ndata._cubic_atX((float)x*(ndata.width-xp)/width)-m)/ca);

           if (x>0) draw_line(x,oY,x+1,Y,color,opacity,pattern,init_hatch);

           init_hatch = false;

           oY = Y;

         }

       } break;

       case 3 : { // Bars

         const int Y0 = (int)(-m/ca);

         int oX = 0;

         cimg_foroff(data,off) {

           const int

             X = (off+1)*width/siz-1,

             Y = (int)((data[off]-m)/ca);

           draw_rectangle(oX,Y0,X,Y,color1,opacity).

             draw_line(oX,Y,oX,Y0,color2,opacity).

             draw_line(oX,Y0,X,Y0,Y<=Y0?color2:color,opacity).

             draw_line(X,Y,X,Y0,color,opacity).

             draw_line(oX,Y,X,Y,Y<=Y0?color:color2,opacity);

           oX = X+1;

         }

       } break;

       default : break; // No edges

       }


       // Draw graph points

       switch (vertex_type%8) {

       case 1 : { // Point

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_point(X,Y,color,opacity);

         }

       } break;

       case 2 : { // Straight Cross

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_line(X-3,Y,X+3,Y,color,opacity).draw_line(X,Y-3,X,Y+3,color,opacity);

         }

       } break;

       case 3 : { // Diagonal Cross

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_line(X-3,Y-3,X+3,Y+3,color,opacity).draw_line(X-3,Y+3,X+3,Y-3,color,opacity);

         }

       } break;

       case 4 : { // Filled Circle

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_circle(X,Y,3,color,opacity);

         }

       } break;

       case 5 : { // Outlined circle

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_circle(X,Y,3,color,opacity,0U);

         }

       } break;

       case 6 : { // Square

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_rectangle(X-3,Y-3,X+3,Y+3,color,opacity,~0U);

         }

       } break;

       case 7 : { // Diamond

         cimg_foroff(data,off) {

           const int X = off*width/(siz-xp), Y = (int)((data[off]-m)/ca);

           draw_line(X,Y-4,X+4,Y,color,opacity).

             draw_line(X+4,Y,X,Y+4,color,opacity).

             draw_line(X,Y+4,X-4,Y,color,opacity).

             draw_line(X-4,Y,X,Y-4,color,opacity);

         }

       } break;

       default : break; // No points

       }


       if (color1) delete[] color1; if (color2) delete[] color2;

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_graph(const CImg<t>& data,

                         const CImg<tc>& color, const float opacity=1,

                         const unsigned int plot_type=1, const unsigned int vertex_type=1,

                         const double ymin=0, const double ymax=0, const bool expand=false,

                         const unsigned int pattern=~0U) {

       return draw_graph(data,color.data,opacity,plot_type,vertex_type,ymin,ymax,expand,pattern);

     }


     template<typename tc, typename t>

     CImg<T>& draw_fill(const int x, const int y, const int z,

                        const tc *const color, const float opacity,

                        CImg<t>& region, const float sigma=0,

                        const bool high_connexity=false) {


 #define _cimg_draw_fill_test(x,y,z,res) 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); \

 }


 #define _cimg_draw_fill_set(x,y,z) { \

   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; } \

 }


 #define _cimg_draw_fill_insert(x,y,z) { \

   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_test_neighbor(x,y,z,cond) 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); \

 }


       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_fill() : Specified color is (null).",

                                     pixel_type());

       region.assign(width,height,depth,1,(t)0);

       if (x>=0 && x<dimx() && y>=0 && y<dimy() && z>=0 && z<dimz()) {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         const unsigned int whz = width*height*depth, siz = dim*whz, W1 = width-1, H1 = height-1, D1 = depth-1;

         const bool threed = depth>1;

         const CImg<T> reference_color = get_vector_at(x,y,z);

         CImg<uintT> remaining(3,512,1,1,0);

         remaining(0,0) = x; remaining(1,0) = y; remaining(2,0) = z;

         unsigned int posr0 = 0, posr1 = 1;

         region(x,y,z) = (t)1;

         const t noregion = ((t)1==(t)2)?(t)0:(t)(-1);

         if (threed) do { // 3D version of the filling algorithm

           const unsigned int *pcurr = remaining.ptr(0,posr0++), xc = *(pcurr++), yc = *(pcurr++), zc = *(pcurr++);

           if (posr0>=512) { remaining.translate(0,-(int)posr0); posr1-=posr0; posr0 = 0; }

           bool cont, res;

           unsigned int nxc = xc;

           do { // X-backward

             _cimg_draw_fill_set(nxc,yc,zc);

             _cimg_draw_fill_test_neighbor(nxc,yc-1,zc,yc!=0);

             _cimg_draw_fill_test_neighbor(nxc,yc+1,zc,yc<H1);

             _cimg_draw_fill_test_neighbor(nxc,yc,zc-1,zc!=0);

             _cimg_draw_fill_test_neighbor(nxc,yc,zc+1,zc<D1);

             if (nxc) { --nxc; _cimg_draw_fill_test(nxc,yc,zc,cont); } else cont = false;

           } while (cont);

           nxc = xc;

           do { // X-forward

             if ((++nxc)<=W1) { _cimg_draw_fill_test(nxc,yc,zc,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(nxc,yc,zc);

               _cimg_draw_fill_test_neighbor(nxc,yc-1,zc,yc!=0);

               _cimg_draw_fill_test_neighbor(nxc,yc+1,zc,yc<H1);

               _cimg_draw_fill_test_neighbor(nxc,yc,zc-1,zc!=0);

               _cimg_draw_fill_test_neighbor(nxc,yc,zc+1,zc<D1);

             }

           } while (cont);

           unsigned int nyc = yc;

           do { // Y-backward

             if (nyc) { --nyc; _cimg_draw_fill_test(xc,nyc,zc,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,nyc,zc);

               _cimg_draw_fill_test_neighbor(xc-1,nyc,zc,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,nyc,zc,xc<W1);

               _cimg_draw_fill_test_neighbor(xc,nyc,zc-1,zc!=0);

               _cimg_draw_fill_test_neighbor(xc,nyc,zc+1,zc<D1);

             }

           } while (cont);

           nyc = yc;

           do { // Y-forward

             if ((++nyc)<=H1) { _cimg_draw_fill_test(xc,nyc,zc,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,nyc,zc);

               _cimg_draw_fill_test_neighbor(xc-1,nyc,zc,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,nyc,zc,xc<W1);

               _cimg_draw_fill_test_neighbor(xc,nyc,zc-1,zc!=0);

               _cimg_draw_fill_test_neighbor(xc,nyc,zc+1,zc<D1);

             }

           } while (cont);

           unsigned int nzc = zc;

           do { // Z-backward

             if (nzc) { --nzc; _cimg_draw_fill_test(xc,yc,nzc,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,yc,nzc);

               _cimg_draw_fill_test_neighbor(xc-1,yc,nzc,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,yc,nzc,xc<W1);

               _cimg_draw_fill_test_neighbor(xc,yc-1,nzc,yc!=0);

               _cimg_draw_fill_test_neighbor(xc,yc+1,nzc,yc<H1);

             }

           } while (cont);

           nzc = zc;

           do { // Z-forward

             if ((++nzc)<=D1) { _cimg_draw_fill_test(xc,yc,nzc,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,nyc,zc);

               _cimg_draw_fill_test_neighbor(xc-1,yc,nzc,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,yc,nzc,xc<W1);

               _cimg_draw_fill_test_neighbor(xc,yc-1,nzc,yc!=0);

               _cimg_draw_fill_test_neighbor(xc,yc+1,nzc,yc<H1);

             }

           } while (cont);

         } while (posr1>posr0);

         else do { // 2D version of the filling algorithm

           const unsigned int *pcurr = remaining.ptr(0,posr0++), xc = *(pcurr++), yc = *(pcurr++);

           if (posr0>=512) { remaining.translate(0,-(int)posr0); posr1-=posr0; posr0 = 0; }

           bool cont, res;

           unsigned int nxc = xc;

           do { // X-backward

             _cimg_draw_fill_set(nxc,yc,0);

             _cimg_draw_fill_test_neighbor(nxc,yc-1,0,yc!=0);

             _cimg_draw_fill_test_neighbor(nxc,yc+1,0,yc<H1);

             if (high_connexity) {

               _cimg_draw_fill_test_neighbor(nxc-1,yc-1,0,(nxc!=0 && yc!=0));

               _cimg_draw_fill_test_neighbor(nxc+1,yc-1,0,(nxc<W1 && yc!=0));

               _cimg_draw_fill_test_neighbor(nxc-1,yc+1,0,(nxc!=0 && yc<H1));

               _cimg_draw_fill_test_neighbor(nxc+1,yc+1,0,(nxc<W1 && yc<H1));

             }

             if (nxc) { --nxc; _cimg_draw_fill_test(nxc,yc,0,cont); } else cont = false;

           } while (cont);

           nxc = xc;

           do { // X-forward

             if ((++nxc)<=W1) { _cimg_draw_fill_test(nxc,yc,0,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(nxc,yc,0);

               _cimg_draw_fill_test_neighbor(nxc,yc-1,0,yc!=0);

               _cimg_draw_fill_test_neighbor(nxc,yc+1,0,yc<H1);

               if (high_connexity) {

                 _cimg_draw_fill_test_neighbor(nxc-1,yc-1,0,(nxc!=0 && yc!=0));

                 _cimg_draw_fill_test_neighbor(nxc+1,yc-1,0,(nxc<W1 && yc!=0));

                 _cimg_draw_fill_test_neighbor(nxc-1,yc+1,0,(nxc!=0 && yc<H1));

                 _cimg_draw_fill_test_neighbor(nxc+1,yc+1,0,(nxc<W1 && yc<H1));

               }

             }

           } while (cont);

           unsigned int nyc = yc;

           do { // Y-backward

             if (nyc) { --nyc; _cimg_draw_fill_test(xc,nyc,0,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,nyc,0);

               _cimg_draw_fill_test_neighbor(xc-1,nyc,0,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,nyc,0,xc<W1);

               if (high_connexity) {

                 _cimg_draw_fill_test_neighbor(xc-1,nyc-1,0,(xc!=0 && nyc!=0));

                 _cimg_draw_fill_test_neighbor(xc+1,nyc-1,0,(xc<W1 && nyc!=0));

                 _cimg_draw_fill_test_neighbor(xc-1,nyc+1,0,(xc!=0 && nyc<H1));

                 _cimg_draw_fill_test_neighbor(xc+1,nyc+1,0,(xc<W1 && nyc<H1));

               }

             }

           } while (cont);

           nyc = yc;

           do { // Y-forward

             if ((++nyc)<=H1) { _cimg_draw_fill_test(xc,nyc,0,cont); } else cont = false;

             if (cont) {

               _cimg_draw_fill_set(xc,nyc,0);

               _cimg_draw_fill_test_neighbor(xc-1,nyc,0,xc!=0);

               _cimg_draw_fill_test_neighbor(xc+1,nyc,0,xc<W1);

               if (high_connexity) {

                 _cimg_draw_fill_test_neighbor(xc-1,nyc-1,0,(xc!=0 && nyc!=0));

                 _cimg_draw_fill_test_neighbor(xc+1,nyc-1,0,(xc<W1 && nyc!=0));

                 _cimg_draw_fill_test_neighbor(xc-1,nyc+1,0,(xc!=0 && nyc<H1));

                 _cimg_draw_fill_test_neighbor(xc+1,nyc+1,0,(xc<W1 && nyc<H1));

               }

             }

           } while (cont);

         } while (posr1>posr0);

         if (noregion) cimg_for(region,ptr,t) if (*ptr==noregion) *ptr = (t)0;

       }

       return *this;

     }


     template<typename tc, typename t>

     CImg<T>& draw_fill(const int x, const int y, const int z,

                        const CImg<tc>& color, const float opacity,

                        CImg<t>& region, const float sigma=0, const bool high_connexity=false) {

       return draw_fill(x,y,z,color.data,opacity,region,sigma,high_connexity);

     }


     template<typename tc>

     CImg<T>& draw_fill(const int x, const int y, const int z,

                        const tc *const color, const float opacity=1,

                        const float sigma=0, const bool high_connexity=false) {

       CImg<boolT> tmp;

       return draw_fill(x,y,z,color,opacity,tmp,sigma,high_connexity);

     }


     template<typename tc>

     CImg<T>& draw_fill(const int x, const int y, const int z,

                        const CImg<tc>& color, const float opacity=1,

                        const float sigma=0, const bool high_connexity=false) {

       return draw_fill(x,y,z,color.data,opacity,sigma,high_connexity);

     }


     template<typename tc>

     CImg<T>& draw_fill(const int x, const int y,

                        const tc *const color, const float opacity=1,

                        const float sigma=0, const bool high_connexity=false) {

       CImg<boolT> tmp;

       return draw_fill(x,y,0,color,opacity,tmp,sigma,high_connexity);

     }


     template<typename tc>

     CImg<T>& draw_fill(const int x, const int y,

                        const CImg<tc>& color, const float opacity=1,

                        const float sigma=0, const bool high_connexity=false) {

       return draw_fill(x,y,color.data,opacity,sigma,high_connexity);

     }


     CImg<T>& draw_plasma(const int x0, const int y0, const int x1, const int y1,

                          const float alpha=1, const float beta=1,

                          const float opacity=1) {

       if (!is_empty()) {

         const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

         int nx0 = x0, nx1 = x1, ny0 = y0, ny1 = y1;

         if (nx1<nx0) cimg::swap(nx0,nx1);

         if (ny1<ny0) cimg::swap(ny0,ny1);

         if (nx0<0) nx0 = 0;

         if (nx1>=dimx()) nx1 = width-1;

         if (ny0<0) ny0 = 0;

         if (ny1>=dimy()) ny1 = height-1;

         const int xc = (nx0+nx1)/2, yc = (ny0+ny1)/2, dx = (xc-nx0), dy = (yc-ny0);

         const Tfloat dc = (Tfloat)(std::sqrt((float)(dx*dx+dy*dy))*alpha + beta);

         Tfloat val = 0;

         cimg_forV(*this,k) {

           if (opacity>=1) {

             const Tfloat

               val0 = (Tfloat)((*this)(nx0,ny0,0,k)), val1 = (Tfloat)((*this)(nx1,ny0,0,k)),

               val2 = (Tfloat)((*this)(nx0,ny1,0,k)), val3 = (Tfloat)((*this)(nx1,ny1,0,k));

             (*this)(xc,ny0,0,k) = (T)((val0+val1)/2);

             (*this)(xc,ny1,0,k) = (T)((val2+val3)/2);

             (*this)(nx0,yc,0,k) = (T)((val0+val2)/2);

             (*this)(nx1,yc,0,k) = (T)((val1+val3)/2);

             do {

               val = (Tfloat)(0.25f*((Tfloat)((*this)(nx0,ny0,0,k)) +

                                    (Tfloat)((*this)(nx1,ny0,0,k)) +

                                    (Tfloat)((*this)(nx1,ny1,0,k)) +

                                    (Tfloat)((*this)(nx0,ny1,0,k))) +

                             dc*cimg::grand());

             } while (val<(Tfloat)cimg::type<T>::min() || val>(Tfloat)cimg::type<T>::max());

             (*this)(xc,yc,0,k) = (T)val;

           } else {

             const Tfloat

               val0 = (Tfloat)((*this)(nx0,ny0,0,k)), val1 = (Tfloat)((*this)(nx1,ny0,0,k)),

               val2 = (Tfloat)((*this)(nx0,ny1,0,k)), val3 = (Tfloat)((*this)(nx1,ny1,0,k));

             (*this)(xc,ny0,0,k) = (T)(((val0+val1)*nopacity + copacity*(*this)(xc,ny0,0,k))/2);

             (*this)(xc,ny1,0,k) = (T)(((val2+val3)*nopacity + copacity*(*this)(xc,ny1,0,k))/2);

             (*this)(nx0,yc,0,k) = (T)(((val0+val2)*nopacity + copacity*(*this)(nx0,yc,0,k))/2);

             (*this)(nx1,yc,0,k) = (T)(((val1+val3)*nopacity + copacity*(*this)(nx1,yc,0,k))/2);

             do {

               val = (Tfloat)(0.25f*(((Tfloat)((*this)(nx0,ny0,0,k)) +

                                     (Tfloat)((*this)(nx1,ny0,0,k)) +

                                     (Tfloat)((*this)(nx1,ny1,0,k)) +

                                     (Tfloat)((*this)(nx0,ny1,0,k))) +

                                    dc*cimg::grand())*nopacity + copacity*(*this)(xc,yc,0,k));

             } while (val<(Tfloat)cimg::type<T>::min() || val>(Tfloat)cimg::type<T>::max());

             (*this)(xc,yc,0,k) = (T)val;

           }

         }

         if (xc!=nx0 || yc!=ny0) {

           draw_plasma(nx0,ny0,xc,yc,alpha,beta,opacity);

           draw_plasma(xc,ny0,nx1,yc,alpha,beta,opacity);

           draw_plasma(nx0,yc,xc,ny1,alpha,beta,opacity);

           draw_plasma(xc,yc,nx1,ny1,alpha,beta,opacity);

         }

       }

       return *this;

     }


     CImg<T>& draw_plasma(const float alpha=1, const float beta=1,

                          const float opacity=1) {

       return draw_plasma(0,0,width-1,height-1,alpha,beta,opacity);

     }


     template<typename tc>

     CImg<T>& draw_mandelbrot(const int x0, const int y0, const int x1, const int y1,

                              const CImg<tc>& color_palette, const float opacity=1,

                              const double z0r=-2, const double z0i=-2, const double z1r=2, const double z1i=2,

                              const unsigned int itermax=255,

                              const bool normalized_iteration=false,

                              const bool julia_set=false,

                              const double paramr=0, const double parami=0) {

       if (is_empty()) return *this;

       CImg<tc> palette;

       if (color_palette) palette.assign(color_palette.data,color_palette.size()/color_palette.dim,1,1,color_palette.dim,true);

       if (palette && palette.dim!=dim)

         throw CImgArgumentException("CImg<%s>::draw_mandelbrot() : Specified color palette (%u,%u,%u,%u,%p) is not \n"

                                     "compatible with instance image (%u,%u,%u,%u,%p).",

                                     pixel_type(),color_palette.width,color_palette.height,color_palette.depth,color_palette.dim,

                                     color_palette.data,width,height,depth,dim,data);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0), ln2 = (float)std::log(2.0);

       unsigned int iter = 0;

       cimg_for_inXY(*this,x0,y0,x1,y1,p,q) {

         const double x = z0r + p*(z1r-z0r)/width, y = z0i + q*(z1i-z0i)/height;

         double zr, zi, cr, ci;

         if (julia_set) { zr = x; zi = y; cr = paramr; ci = parami; }

         else { zr = paramr; zi = parami; cr = x; ci = y; }

         for (iter=1; zr*zr + zi*zi<=4 && iter<=itermax; ++iter) {

           const double temp = zr*zr - zi*zi + cr;

           zi = 2*zr*zi + ci;

           zr = temp;

         }

         if (iter>itermax) {

           if (palette) {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)palette(0,k);

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)(palette(0,k)*nopacity + (*this)(p,q,0,k)*copacity);

           } else {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)0;

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)((*this)(p,q,0,k)*copacity);

           }

         } else if (normalized_iteration) {

           const float

             normz = (float)cimg::abs(zr*zr+zi*zi),

             niter = (float)(iter + 1 - std::log(std::log(normz))/ln2);

           if (palette) {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)palette._linear_atX(niter,k);

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)(palette._linear_atX(niter,k)*nopacity + (*this)(p,q,0,k)*copacity);

           } else {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)niter;

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)(niter*nopacity + (*this)(p,q,0,k)*copacity);

           }

         } else {

           if (palette) {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)palette._atX(iter,k);

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)(palette(iter,k)*nopacity + (*this)(p,q,0,k)*copacity);

           } else {

             if (opacity>=1) cimg_forV(*this,k) (*this)(p,q,0,k) = (T)iter;

             else cimg_forV(*this,k) (*this)(p,q,0,k) = (T)(iter*nopacity + (*this)(p,q,0,k)*copacity);

           }

         }

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_mandelbrot(const CImg<tc>& color_palette, const float opacity=1,

                              const double z0r=-2, const double z0i=-2, const double z1r=2, const double z1i=2,

                              const unsigned int itermax=255,

                              const bool normalized_iteration=false,

                              const bool julia_set=false,

                              const double paramr=0, const double parami=0) {

       return draw_mandelbrot(0,0,width-1,height-1,color_palette,opacity,z0r,z0i,z1r,z1i,itermax,normalized_iteration,julia_set,paramr,parami);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float sigma,

                            const tc *const color, const float opacity=1) {

       if (is_empty()) return *this;

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_gaussian() : Specified color is (null)",

                                     pixel_type());

       const float sigma2 = 2*sigma*sigma, nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const unsigned int whz = width*height*depth;

       const tc *col = color;

       cimg_forX(*this,x) {

         const float dx = (x - xc), val = (float)std::exp(-dx*dx/sigma2);

         T *ptrd = ptr(x,0,0,0);

         if (opacity>=1) cimg_forV(*this,k) { *ptrd = (T)(val*(*col++)); ptrd+=whz; }

         else cimg_forV(*this,k) { *ptrd = (T)(nopacity*val*(*col++) + *ptrd*copacity); ptrd+=whz; }

         col-=dim;

       }

       return *this;

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float sigma,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,sigma,color.data,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const CImg<t>& tensor,

                            const tc *const color, const float opacity=1) {

       if (is_empty()) return *this;

       typedef typename cimg::superset<t,float>::type tfloat;

       if (tensor.width!=2 || tensor.height!=2 || tensor.depth!=1 || tensor.dim!=1)

         throw CImgArgumentException("CImg<%s>::draw_gaussian() : Tensor parameter (%u,%u,%u,%u,%p) is not a 2x2 matrix.",

                                     pixel_type(),tensor.width,tensor.height,tensor.depth,tensor.dim,tensor.data);

       if (!color)

         throw CImgArgumentException("CImg<%s>::draw_gaussian() : Specified color is (null)",

                                     pixel_type());

       const CImg<tfloat> invT = tensor.get_invert(), invT2 = (invT*invT)/(-2.0);

       const tfloat a = invT2(0,0), b = 2*invT2(1,0), c = invT2(1,1);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const unsigned int whz = width*height*depth;

       const tc *col = color;

       float dy = -yc;

       cimg_forY(*this,y) {

         float dx = -xc;

         cimg_forX(*this,x) {

           const float val = (float)std::exp(a*dx*dx + b*dx*dy + c*dy*dy);

           T *ptrd = ptr(x,y,0,0);

           if (opacity>=1) cimg_forV(*this,k) { *ptrd = (T)(val*(*col++)); ptrd+=whz; }

           else cimg_forV(*this,k) { *ptrd = (T)(nopacity*val*(*col++) + *ptrd*copacity); ptrd+=whz; }

           col-=dim;

           ++dx;

         }

         ++dy;

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const CImg<t>& tensor,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,yc,tensor,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const int xc, const int yc, const float r1, const float r2, const float ru, const float rv,

                            const tc *const color, const float opacity=1) {

       const double

         a = r1*ru*ru + r2*rv*rv,

         b = (r1-r2)*ru*rv,

         c = r1*rv*rv + r2*ru*ru;

       const CImg<Tfloat> tensor(2,2,1,1, a,b,b,c);

       return draw_gaussian(xc,yc,tensor,color,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const int xc, const int yc, const float r1, const float r2, const float ru, const float rv,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,yc,r1,r2,ru,rv,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float sigma,

                            const tc *const color, const float opacity=1) {

       return draw_gaussian(xc,yc,CImg<floatT>::diagonal(sigma,sigma),color,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float sigma,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,yc,sigma,color.data,opacity);

     }


     template<typename t, typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float zc, const CImg<t>& tensor,

                            const tc *const color, const float opacity=1) {

       if (is_empty()) return *this;

       typedef typename cimg::superset<t,float>::type tfloat;

       if (tensor.width!=3 || tensor.height!=3 || tensor.depth!=1 || tensor.dim!=1)

         throw CImgArgumentException("CImg<%s>::draw_gaussian() : Tensor parameter (%u,%u,%u,%u,%p) is not a 3x3 matrix.",

                                     pixel_type(),tensor.width,tensor.height,tensor.depth,tensor.dim,tensor.data);

       const CImg<tfloat> invT = tensor.get_invert(), invT2 = (invT*invT)/(-2.0);

       const tfloat a = invT(0,0), b = 2*invT(1,0), c = 2*invT(2,0), d = invT(1,1), e = 2*invT(2,1), f = invT(2,2);

       const float nopacity = cimg::abs(opacity), copacity = 1 - cimg::max(opacity,0);

       const unsigned int whz = width*height*depth;

       const tc *col = color;

       cimg_forXYZ(*this,x,y,z) {

         const float

           dx = (x - xc), dy = (y - yc), dz = (z - zc),

           val = (float)std::exp(a*dx*dx + b*dx*dy + c*dx*dz + d*dy*dy + e*dy*dz + f*dz*dz);

         T *ptrd = ptr(x,y,z,0);

         if (opacity>=1) cimg_forV(*this,k) { *ptrd = (T)(val*(*col++)); ptrd+=whz; }

         else cimg_forV(*this,k) { *ptrd = (T)(nopacity*val*(*col++) + *ptrd*copacity); ptrd+=whz; }

         col-=dim;

       }

       return *this;

     }


     template<typename t, typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float zc, const CImg<t>& tensor,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,yc,zc,tensor,color.data,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float zc, const float sigma,

                            const tc *const color, const float opacity=1) {

       return draw_gaussian(xc,yc,zc,CImg<floatT>::diagonal(sigma,sigma,sigma),color,opacity);

     }


     template<typename tc>

     CImg<T>& draw_gaussian(const float xc, const float yc, const float zc, const float sigma,

                            const CImg<tc>& color, const float opacity=1) {

       return draw_gaussian(xc,yc,zc,sigma,color.data,opacity);

     }


     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& draw_object3d(const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors, const CImgList<to>& opacities,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       return _draw_object3d(0,zbuffer,x0,y0,z0,vertices,primitives,colors,opacities,opacities.width,

                             render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine);

     }


 #ifdef cimg_use_board

     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& draw_object3d(LibBoard::Board& board,

                            const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors, const CImgList<to>& opacities,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       return _draw_object3d((void*)&board,zbuffer,x0,y0,z0,vertices,primitives,colors,opacities,opacities.width,

                             render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine);

     }

 #endif

     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& draw_object3d(const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors, const CImg<to>& opacities,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       return _draw_object3d(0,zbuffer,x0,y0,z0,vertices,primitives,colors,opacities,opacities.size(),

                             render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine);

     }


 #ifdef cimg_use_board

     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& draw_object3d(LibBoard::Board& board,

                            const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors, const CImg<to>& opacities,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       return _draw_object3d((void*)&board,zbuffer,x0,y0,z0,vertices,primitives,colors,opacities,opacities.size(),

                             render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine);

     }

 #endif


     template<typename tp, typename tf, typename tc>

     CImg<T>& draw_object3d(const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       static const CImg<floatT> opacities;

       return draw_object3d(x0,y0,z0,vertices,primitives,colors,opacities,

                            render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine,zbuffer);

     }


 #ifdef cimg_use_board

     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& draw_object3d(LibBoard::Board& board,

                            const float x0, const float y0, const float z0,

                            const CImg<tp>& vertices, const CImgList<tf>& primitives,

                            const CImgList<tc>& colors,

                            const unsigned int render_type=4,

                            const bool double_sided=false, const float focale=500,

                            const float lightx=0, const float lighty=0, const float lightz=-5000,

                            const float specular_light=0.2f, const float specular_shine=0.1f,

                            CImg<floatT>& zbuffer=cimg_library::CImg<floatT>::empty()) {

       static const CImg<floatT> opacities;

       return draw_object3d(x0,y0,z0,vertices,primitives,colors,opacities,

                            render_type,double_sided,focale,lightx,lighty,lightz,specular_light,specular_shine,zbuffer);

     }

 #endif


     template<typename tc, typename to>

     void __draw_object3d(const unsigned int n_primitive, const unsigned int nb_opacities, const CImgList<to>& opacities, const CImg<tc>& color,

                          const int nx0, const int ny0, const CImg<T>& sprite, const float opac) {

       if (n_primitive<nb_opacities && opacities[n_primitive].is_sameXY(color))

         draw_image(nx0,ny0,sprite,opacities[n_primitive].get_resize(sprite.width,sprite.height,1,sprite.dim,1));

       else draw_image(nx0,ny0,sprite,opac);

     }


     template<typename tc, typename to>

     void __draw_object3d(const unsigned int, const unsigned int, const CImg<to>&, const CImg<tc>&,

                          const int nx0, const int ny0, const CImg<T>& sprite, const float opac) {

       draw_image(nx0,ny0,sprite,opac);

     }


     template<typename tp, typename tf, typename tc, typename to>

     CImg<T>& _draw_object3d(void *const pboard, CImg<floatT>& zbuffer,

                             const float X, const float Y, const float Z,

                             const CImg<tp>& vertices,

                             const CImgList<tf>& primitives,

                             const CImgList<tc>& colors,

                             const to& opacities, const unsigned int nb_opacities,

                             const unsigned int render_type,

                             const bool double_sided, const float focale,

                             const float lightx, const float lighty, const float lightz,

                             const float specular_light, const float specular_shine) {

       if (is_empty() || !vertices || !primitives) return *this;

       vertices.is_object3d(primitives,false,true);

 #ifndef cimg_use_board

       if (pboard) return *this;

 #endif

       const float

         nspec = 1.0f-(specular_light<0.0f?0.0f:(specular_light>1.0f?1.0f:specular_light)),

         nspec2 = 1.0f+(specular_shine<0.0f?0.0f:specular_shine),

         nsl1 = (nspec2-1)/cimg::sqr(nspec-1),

         nsl2 = (1-2*nsl1*nspec),

         nsl3 = nspec2-nsl1-nsl2;


       // Create light texture for phong-like rendering

       static CImg<floatT> light_texture;

       if (render_type==5) {

         if (colors.width>primitives.width) light_texture.assign(colors[primitives.width])/=255;

         else {

           static float olightx = 0, olighty = 0, olightz = 0, ospecular_shine = 0;

           if (!light_texture || lightx!=olightx || lighty!=olighty || lightz!=olightz || specular_shine!=ospecular_shine) {

             light_texture.assign(512,512);

             const float white[] = { 1 },

               dlx = lightx-X, dly = lighty-Y, dlz = lightz-Z,

                 nl = (float)std::sqrt(dlx*dlx+dly*dly+dlz*dlz),

                 nlx = light_texture.width/2*(1+dlx/nl),

                 nly = light_texture.height/2*(1+dly/nl);

               light_texture.draw_gaussian(nlx,nly,light_texture.width/3.0f,white);

               cimg_forXY(light_texture,x,y) {

                 const float factor = light_texture(x,y);

                 if (factor>nspec) light_texture(x,y) = cimg::min(2,nsl1*factor*factor+nsl2*factor+nsl3);

               }

               olightx = lightx; olighty = lighty; olightz = lightz; ospecular_shine = specular_shine;

           }

         }

       }


       // Compute 3D to 2D projection

       CImg<floatT> projections(vertices.width,2);

       cimg_forX(projections,l) {

         const float

           x = (float)vertices(l,0),

           y = (float)vertices(l,1),

           z = (float)vertices(l,2);

         const float projectedz = z + Z + focale;

         projections(l,1) = Y + focale*y/projectedz;

         projections(l,0) = X + focale*x/projectedz;

       }


       // Compute and sort visible primitives

       CImg<uintT> visibles(primitives.width);

       CImg<floatT> zrange(primitives.width);

       unsigned int nb_visibles = 0;

       const float zmin = -focale+1.5f;

       { cimglist_for(primitives,l) {

         const CImg<tf>& primitive = primitives[l];

         switch (primitive.size()) {


         case 1 : { // Point

           const unsigned int i0 = (unsigned int)primitive(0);

           const float x0 = projections(i0,0), y0 = projections(i0,1), z0 = (float)(Z + vertices(i0,2));

           if (z0>zmin && x0>=0 && x0<width && y0>=0 && y0<height) {

             visibles(nb_visibles) = (unsigned int)l;

             zrange(nb_visibles++) = z0;

           }

         } break;

         case 5 : { // Sphere

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2);

           const float x0 = projections(i0,0), y0 = projections(i0,1), z0 = (float)(Z + vertices(i0,2));

           int radius;

           if (i2) radius = (int)(i2*focale/(z0+focale));

           else {

             const float x1 = projections(i1,0), y1 = projections(i1,1);

             const int deltax = (int)(x1-x0), deltay = (int)(y1-y0);

             radius = (int)std::sqrt((float)(deltax*deltax + deltay*deltay));

           }

           if (z0>zmin && x0+radius>=0 && x0-radius<width && y0+radius>=0 && y0-radius<height) {

             visibles(nb_visibles) = (unsigned int)l;

             zrange(nb_visibles++) = z0;

           }

         } break;

         case 2 : // Segment

         case 6 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1);

           const float

             x0 = projections(i0,0), y0 = projections(i0,1), z0 = (float)(Z + vertices(i0,2)),

             x1 = projections(i1,0), y1 = projections(i1,1), z1 = (float)(Z + vertices(i1,2));

           float xm, xM, ym, yM;

           if (x0<x1) { xm = x0; xM = x1; } else { xm = x1; xM = x0; }

           if (y0<y1) { ym = y0; yM = y1; } else { ym = y1; yM = y0; }

           if (z0>zmin && z1>zmin && xM>=0 && xm<width && yM>=0 && ym<height) {

             visibles(nb_visibles) = (unsigned int)l;

             zrange(nb_visibles++) = 0.5f*(z0+z1);

           }

         } break;

         case 3 :  // Triangle

         case 9 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2);

           const float

             x0 = projections(i0,0), y0 = projections(i0,1), z0 = (float)(Z + vertices(i0,2)),

             x1 = projections(i1,0), y1 = projections(i1,1), z1 = (float)(Z + vertices(i1,2)),

             x2 = projections(i2,0), y2 = projections(i2,1), z2 = (float)(Z + vertices(i2,2));

           float xm, xM, ym, yM;

           if (x0<x1) { xm = x0; xM = x1; } else { xm = x1; xM = x0; }

           if (x2<xm) xm = x2;

           if (x2>xM) xM = x2;

           if (y0<y1) { ym = y0; yM = y1; } else { ym = y1; yM = y0; }

           if (y2<ym) ym = y2;

           if (y2>yM) yM = y2;

           if (z0>zmin && z1>zmin && z2>zmin && xM>=0 && xm<width && yM>=0 && ym<height) {

             const float d = (x1-x0)*(y2-y0)-(x2-x0)*(y1-y0);

             if (double_sided || d<0) {

               visibles(nb_visibles) = (unsigned int)l;

               zrange(nb_visibles++) = (z0+z1+z2)/3;

             }

           }

         } break;

         case 4 : // Rectangle

         case 12 : {

           const unsigned int

             i0 = (unsigned int)primitive(0),

             i1 = (unsigned int)primitive(1),

             i2 = (unsigned int)primitive(2),

             i3 = (unsigned int)primitive(3);

           const float

             x0 = projections(i0,0), y0 = projections(i0,1), z0 = (float)(Z + vertices(i0,2)),

             x1 = projections(i1,0), y1 = projections(i1,1), z1 = (float)(Z + vertices(i1,2)),

             x2 = projections(i2,0), y2 = projections(i2,1), z2 = (float)(Z + vertices(i2,2)),

             x3 = projections(i3,0), y3 = projections(i3,1), z3 = (float)(Z + vertices(i3,2));

           float xm, xM, ym, yM;

           if (x0<x1) { xm = x0; xM = x1; } else { xm = x1; xM = x0; }

           if (x2<xm) xm = x2;

           if (x2>xM) xM = x2;

           if (x3<xm) xm = x3;

           if (x3>xM) xM = x3;

           if (y0<y1) { ym = y0; yM = y1; } else { ym = y1; yM = y0; }

           if (y2<ym) ym = y2;

           if (y2>yM) yM = y2;

           if (y3<ym) ym = y3;

           if (y3>yM) yM = y3;

           if (z0>zmin && z1>zmin && z2>zmin && z3>zmin && xM>=0 && xm<width && yM>=0 && ym<height) {

             const float d = (x1 - x0)*(y2 - y0) - (x2 - x0)*(y1 - y0);

             if (double_sided || d<0) {

               visibles(nb_visibles) = (unsigned int)l;

               zrange(nb_visibles++) = (z0 + z1 + z2 + z3)/4;

             }

           }

         } break;

         default :

           throw CImgArgumentException("CImg<%s>::draw_object3d() : Primitive %u is invalid (size = %u, can be 1,2,3,4,5,6,9 or 12)",

                                       pixel_type(),l,primitive.size());

         }

       }

       }

       if (nb_visibles<=0) return *this;

       CImg<uintT> permutations;

       CImg<floatT>(zrange.data,nb_visibles,1,1,1,true).sort(permutations,false);


       // Compute light properties

       CImg<floatT> lightprops;

       switch (render_type) {

       case 3 : { // Flat Shading

         lightprops.assign(nb_visibles);

         cimg_forX(lightprops,l) {

           const CImg<tf>& primitive = primitives(visibles(permutations(l)));

           const unsigned int psize = primitive.size();

           if (psize==3 || psize==4 || psize==9 || psize==12) {

             const unsigned int

               i0 = (unsigned int)primitive(0),

               i1 = (unsigned int)primitive(1),

               i2 = (unsigned int)primitive(2);

             const float

               x0 = (float)vertices(i0,0), y0 = (float)vertices(i0,1), z0 = (float)vertices(i0,2),

               x1 = (float)vertices(i1,0), y1 = (float)vertices(i1,1), z1 = (float)vertices(i1,2),

               x2 = (float)vertices(i2,0), y2 = (float)vertices(i2,1), z2 = (float)vertices(i2,2),

               dx1 = x1 - x0, dy1 = y1 - y0, dz1 = z1 - z0,

               dx2 = x2 - x0, dy2 = y2 - y0, dz2 = z2 - z0,

               nx = dy1*dz2 - dz1*dy2,

               ny = dz1*dx2 - dx1*dz2,

               nz = dx1*dy2 - dy1*dx2,

               norm = (float)std::sqrt(1e-5f + nx*nx + ny*ny + nz*nz),

               lx = X + (x0 + x1 + x2)/3 - lightx,

               ly = Y + (y0 + y1 + y2)/3 - lighty,

               lz = Z + (z0 + z1 + z2)/3 - lightz,

               nl = (float)std::sqrt(1e-5f + lx*lx + ly*ly + lz*lz),

               factor = cimg::max(cimg::abs(-lx*nx-ly*ny-lz*nz)/(norm*nl),0);

             lightprops[l] = factor<=nspec?factor:(nsl1*factor*factor + nsl2*factor + nsl3);

           } else lightprops[l] = 1;

         }

       } break;


       case 4 : // Gouraud Shading

       case 5 : { // Phong-Shading

         CImg<floatT> vertices_normals(vertices.width,3,1,1,0);

         for (unsigned int l = 0; l<nb_visibles; ++l) {

           const CImg<tf>& primitive = primitives[visibles(l)];

           const unsigned int psize = primitive.size();

           const bool

             triangle_flag = (psize==3) || (psize==9),

             rectangle_flag = (psize==4) || (psize==12);

           if (triangle_flag || rectangle_flag) {

             const unsigned int

               i0 = (unsigned int)primitive(0),

               i1 = (unsigned int)primitive(1),

               i2 = (unsigned int)primitive(2),

               i3 = rectangle_flag?(unsigned int)primitive(3):0;

             const float

               x0 = (float)vertices(i0,0), y0 = (float)vertices(i0,1), z0 = (float)vertices(i0,2),

               x1 = (float)vertices(i1,0), y1 = (float)vertices(i1,1), z1 = (float)vertices(i1,2),

               x2 = (float)vertices(i2,0), y2 = (float)vertices(i2,1), z2 = (float)vertices(i2,2),

               dx1 = x1 - x0, dy1 = y1 - y0, dz1 = z1 - z0,

               dx2 = x2 - x0, dy2 = y2 - y0, dz2 = z2 - z0,

               nnx = dy1*dz2 - dz1*dy2,

               nny = dz1*dx2 - dx1*dz2,

               nnz = dx1*dy2 - dy1*dx2,

               norm = 1e-5f + (float)std::sqrt(nnx*nnx + nny*nny + nnz*nnz),

               nx = nnx/norm,

               ny = nny/norm,

               nz = nnz/norm;

             vertices_normals(i0,0)+=nx; vertices_normals(i0,1)+=ny; vertices_normals(i0,2)+=nz;

             vertices_normals(i1,0)+=nx; vertices_normals(i1,1)+=ny; vertices_normals(i1,2)+=nz;

             vertices_normals(i2,0)+=nx; vertices_normals(i2,1)+=ny; vertices_normals(i2,2)+=nz;

             if (rectangle_flag) { vertices_normals(i3,0)+=nx; vertices_normals(i3,1)+=ny; vertices_normals(i3,2)+=nz; }

           }

         }


         if (double_sided) cimg_forX(vertices_normals,p) if (vertices_normals(p,2)>0) {

           vertices_normals(p,0) = -vertices_normals(p,0);

           vertices_normals(p,1) = -vertices_normals(p,1);

           vertices_normals(p,2) = -vertices_normals(p,2);

         }


         if (render_type==4) {

           lightprops.assign(vertices.width);

           cimg_forX(lightprops,ll) {

             const float

               nx = vertices_normals(ll,0),

               ny = vertices_normals(ll,1),

               nz = vertices_normals(ll,2),

               norm = (float)std::sqrt(1e-5f + nx*nx + ny*ny + nz*nz),

               lx = (float)(X + vertices(ll,0) - lightx),

               ly = (float)(Y + vertices(ll,1) - lighty),

               lz = (float)(Z + vertices(ll,2) - lightz),

               nl = (float)std::sqrt(1e-5f + lx*lx + ly*ly + lz*lz),

               factor = cimg::max((-lx*nx-ly*ny-lz*nz)/(norm*nl),0);

             lightprops[ll] = factor<=nspec?factor:(nsl1*factor*factor + nsl2*factor + nsl3);

           }

         } else {

           const unsigned int

             lw2 = light_texture.width/2 - 1,

             lh2 = light_texture.height/2 - 1;

           lightprops.assign(vertices.width,2);

           cimg_forX(lightprops,ll) {

             const float

               nx = vertices_normals(ll,0),

               ny = vertices_normals(ll,1),

               nz = vertices_normals(ll,2),

               norm = (float)std::sqrt(1e-5f + nx*nx + ny*ny + nz*nz),

               nnx = nx/norm,

               nny = ny/norm;

             lightprops(ll,0) = lw2*(1 + nnx);

             lightprops(ll,1) = lh2*(1 + nny);

           }

         }

       } break;

       }


       // Draw visible primitives

       const CImg<tc> default_color(1,dim,1,1,(tc)200);

       for (unsigned int l = 0; l<nb_visibles; ++l) {

         const unsigned int n_primitive = visibles(permutations(l));

         const CImg<tf>& primitive = primitives[n_primitive];

         const CImg<tc>& color = n_primitive<colors.width?colors[n_primitive]:default_color;

         const float opac = n_primitive<nb_opacities?opacities(n_primitive,0):1.0f;

 #ifdef cimg_use_board

         LibBoard::Board &board = *(LibBoard::Board*)pboard;

 #endif


         switch (primitive.size()) {

         case 1 : { // Colored point or sprite

           const unsigned int n0 = (unsigned int)primitive[0];

           const int x0 = (int)projections(n0,0), y0 = (int)projections(n0,1);

           if (color.size()==dim) { // Colored point.

             draw_point(x0,y0,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.fillCircle((float)x0,dimy()-(float)y0,0);

             }

 #endif

           } else { // Colored sprite.

             const float z = Z + vertices(n0,2);

             const int

               factor = (int)(focale*100/(z+focale)),

               sw = color.width*factor/200,

               sh = color.height*factor/200,

               nx0 = x0 - sw, ny0 = y0 - sh;

             if (x0+sw>=0 && nx0<dimx() && y0+sh>=0 && ny0<dimy()) {

               const CImg<T> sprite = color.get_resize(-factor,-factor,1,-100,render_type<=3?1:3);

               __draw_object3d(n_primitive,nb_opacities,opacities,color,nx0,ny0,sprite,opac);

 #ifdef cimg_use_board

               if (pboard) {

                 board.setPenColorRGBi(128,128,128);

                 board.setFillColor(LibBoard::Color::None);

                 board.drawRectangle((float)nx0,dimy()-(float)ny0,sw,sh);

               }

 #endif

             }

           }

         } break;

         case 2 : { // Colored line

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale;

           if (render_type) {

             if (zbuffer) draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,opac);

             else draw_line(x0,y0,x1,y1,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,x1,dimy()-(float)y1);

             }

 #endif

           } else {

             draw_point(x0,y0,color,opac).draw_point(x1,y1,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

             }

 #endif

           }

         } break;

         case 5 : { // Colored sphere

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             n2 = (unsigned int)primitive[2];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1);

           int radius;

           if (n2) radius = (int)(n2*focale/(Z + vertices(n0,2) + focale));

           else {

             const int

               x1 = (int)projections(n1,0), y1 = (int)projections(n1,1),

               deltax = x1-x0, deltay = y1-y0;

             radius = (int)std::sqrt((float)(deltax*deltax + deltay*deltay));

           }

           switch (render_type) {

           case 0 :

             draw_point(x0,y0,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.fillCircle((float)x0,dimy()-(float)y0,0);

             }

 #endif

             break;

           case 1 :

             draw_circle(x0,y0,radius,color,opac,~0U);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.setFillColor(LibBoard::Color::None);

               board.drawCircle((float)x0,dimy()-(float)y0,(float)radius);

             }

 #endif

             break;

           default :

             draw_circle(x0,y0,radius,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.fillCircle((float)x0,dimy()-(float)y0,(float)radius);

             }

 #endif

             break;

           }

         } break;

         case 6 : { // Textured line

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             tx0 = (unsigned int)primitive[2],

             ty0 = (unsigned int)primitive[3],

             tx1 = (unsigned int)primitive[4],

             ty1 = (unsigned int)primitive[5];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale;

           if (render_type) {

             if (zbuffer) draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,tx0,ty0,tx1,ty1,opac);

             else draw_line(x0,y0,x1,y1,color,tx0,ty0,tx1,ty1,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1);

             }

 #endif

           } else {

             draw_point(x0,y0,color.get_vector_at(tx0,ty0),opac).

               draw_point(x1,y1,color.get_vector_at(tx1,ty1),opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

             }

 #endif

           }

         } break;

         case 3 : { // Colored triangle

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             n2 = (unsigned int)primitive[2];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1),

             x2 = (int)projections(n2,0), y2 = (int)projections(n2,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale,

             z2 = vertices(n2,2) + Z + focale;

           switch (render_type) {

           case 0 :

             draw_point(x0,y0,color,opac).draw_point(x1,y1,color,opac).draw_point(x2,y2,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

               board.drawCircle((float)x2,dimy()-(float)y2,0);

             }

 #endif

             break;

           case 1 :

             if (zbuffer)

               draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,opac).draw_line(zbuffer,x0,y0,z0,x2,y2,z2,color,opac).

                 draw_line(zbuffer,x1,y1,z1,x2,y2,z2,color,opac);

             else

               draw_line(x0,y0,x1,y1,color,opac).draw_line(x0,y0,x2,y2,color,opac).

                 draw_line(x1,y1,x2,y2,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1);

               board.drawLine((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2);

               board.drawLine((float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 2 :

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,opac);

             else draw_triangle(x0,y0,x1,y1,x2,y2,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 3 :

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color.data,opac,lightprops(l));

             else _draw_triangle(x0,y0,x1,y1,x2,y2,color.data,opac,lightprops(l));

 #ifdef cimg_use_board

             if (pboard) {

               const float lp = cimg::min(lightprops(l),1);

               board.setPenColorRGBi((unsigned char)(color[0]*lp),

                                      (unsigned char)(color[1]*lp),

                                      (unsigned char)(color[2]*lp),

                                      (unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 4 :

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,lightprops(n0),lightprops(n1),lightprops(n2),opac);

             else draw_triangle(x0,y0,x1,y1,x2,y2,color,lightprops(n0),lightprops(n1),lightprops(n2),opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi((unsigned char)(color[0]),

                                      (unsigned char)(color[1]),

                                      (unsigned char)(color[2]),

                                      (unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprops(n0),

                                          (float)x1,dimy()-(float)y1,lightprops(n1),

                                          (float)x2,dimy()-(float)y2,lightprops(n2));

             }

 #endif

             break;

           case 5 : {

             const unsigned int

               lx0 = (unsigned int)lightprops(n0,0), ly0 = (unsigned int)lightprops(n0,1),

               lx1 = (unsigned int)lightprops(n1,0), ly1 = (unsigned int)lightprops(n1,1),

               lx2 = (unsigned int)lightprops(n2,0), ly2 = (unsigned int)lightprops(n2,1);

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac);

             else draw_triangle(x0,y0,x1,y1,x2,y2,color,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac);

 #ifdef cimg_use_board

             if (pboard) {

               const float

                 l0 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n0,0))), (int)(light_texture.dimy()/2*(1+lightprops(n0,1)))),

                 l1 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n1,0))), (int)(light_texture.dimy()/2*(1+lightprops(n1,1)))),

                 l2 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n2,0))), (int)(light_texture.dimy()/2*(1+lightprops(n2,1))));

               board.setPenColorRGBi((unsigned char)(color[0]),

                                      (unsigned char)(color[1]),

                                      (unsigned char)(color[2]),

                                      (unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,

                                          (float)x1,dimy()-(float)y1,l1,

                                          (float)x2,dimy()-(float)y2,l2);

             }

 #endif

           } break;

           }

         } break;

         case 4 : { // Colored rectangle

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             n2 = (unsigned int)primitive[2],

             n3 = (unsigned int)primitive[3];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1),

             x2 = (int)projections(n2,0), y2 = (int)projections(n2,1),

             x3 = (int)projections(n3,0), y3 = (int)projections(n3,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale,

             z2 = vertices(n2,2) + Z + focale,

             z3 = vertices(n3,2) + Z + focale;

           switch (render_type) {

           case 0 :

             draw_point(x0,y0,color,opac).draw_point(x1,y1,color,opac).

               draw_point(x2,y2,color,opac).draw_point(x3,y3,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

               board.drawCircle((float)x2,dimy()-(float)y2,0);

               board.drawCircle((float)x3,dimy()-(float)y3,0);

             }

 #endif

             break;

           case 1 :

             if (zbuffer)

               draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,opac).draw_line(zbuffer,x1,y1,z1,x2,y2,z2,color,opac).

                 draw_line(zbuffer,x2,y2,z2,x3,y3,z3,color,opac).draw_line(zbuffer,x3,y3,z3,x0,y0,z0,color,opac);

             else

               draw_line(x0,y0,x1,y1,color,opac).draw_line(x1,y1,x2,y2,color,opac).

                 draw_line(x2,y2,x3,y3,color,opac).draw_line(x3,y3,x0,y0,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1);

               board.drawLine((float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.drawLine((float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

               board.drawLine((float)x3,dimy()-(float)y3,(float)x0,dimy()-(float)y0);

             }

 #endif

             break;

           case 2 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,opac).draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,opac);

             else

               draw_triangle(x0,y0,x1,y1,x2,y2,color,opac).draw_triangle(x0,y0,x2,y2,x3,y3,color,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(color[0],color[1],color[2],(unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

             }

 #endif

             break;

           case 3 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color.data,opac,lightprops(l)).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color.data,opac,lightprops(l));

             else

               _draw_triangle(x0,y0,x1,y1,x2,y2,color.data,opac,lightprops(l)).

                 _draw_triangle(x0,y0,x2,y2,x3,y3,color.data,opac,lightprops(l));

 #ifdef cimg_use_board

             if (pboard) {

               const float lp = cimg::min(lightprops(l),1);

               board.setPenColorRGBi((unsigned char)(color[0]*lp),

                                      (unsigned char)(color[1]*lp),

                                      (unsigned char)(color[2]*lp),(unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

             }

 #endif

             break;

           case 4 : {

             const float

               lightprop0 = lightprops(n0), lightprop1 = lightprops(n1),

               lightprop2 = lightprops(n2), lightprop3 = lightprops(n3);

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,lightprop0,lightprop1,lightprop2,opac).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,lightprop0,lightprop2,lightprop3,opac);

             else

               draw_triangle(x0,y0,x1,y1,x2,y2,color,lightprop0,lightprop1,lightprop2,opac).

                 draw_triangle(x0,y0,x2,y2,x3,y3,color,lightprop0,lightprop2,lightprop3,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi((unsigned char)(color[0]),

                                      (unsigned char)(color[1]),

                                      (unsigned char)(color[2]),

                                      (unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprop0,

                                          (float)x1,dimy()-(float)y1,lightprop1,

                                          (float)x2,dimy()-(float)y2,lightprop2);

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprop0,

                                          (float)x2,dimy()-(float)y2,lightprop2,

                                          (float)x3,dimy()-(float)y3,lightprop3);

             }

 #endif

           } break;

           case 5 : {

             const unsigned int

               lx0 = (unsigned int)lightprops(n0,0), ly0 = (unsigned int)lightprops(n0,1),

               lx1 = (unsigned int)lightprops(n1,0), ly1 = (unsigned int)lightprops(n1,1),

               lx2 = (unsigned int)lightprops(n2,0), ly2 = (unsigned int)lightprops(n2,1),

               lx3 = (unsigned int)lightprops(n3,0), ly3 = (unsigned int)lightprops(n3,1);

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,light_texture,lx0,ly0,lx2,ly2,lx3,ly3,opac);

             else

               draw_triangle(x0,y0,x1,y1,x2,y2,color,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac).

                 draw_triangle(x0,y0,x2,y2,x3,y3,color,light_texture,lx0,ly0,lx2,ly2,lx3,ly3,opac);

 #ifdef cimg_use_board

             if (pboard) {

               const float

                 l0 = light_texture((int)(light_texture.dimx()/2*(1+lx0)), (int)(light_texture.dimy()/2*(1+ly0))),

                 l1 = light_texture((int)(light_texture.dimx()/2*(1+lx1)), (int)(light_texture.dimy()/2*(1+ly1))),

                 l2 = light_texture((int)(light_texture.dimx()/2*(1+lx2)), (int)(light_texture.dimy()/2*(1+ly2))),

                 l3 = light_texture((int)(light_texture.dimx()/2*(1+lx3)), (int)(light_texture.dimy()/2*(1+ly3)));

               board.setPenColorRGBi((unsigned char)(color[0]),

                                      (unsigned char)(color[1]),

                                      (unsigned char)(color[2]),

                                      (unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,

                                          (float)x1,dimy()-(float)y1,l1,

                                          (float)x2,dimy()-(float)y2,l2);

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,

                                          (float)x2,dimy()-(float)y2,l2,

                                          (float)x3,dimy()-(float)y3,l3);

             }

 #endif

           } break;

           }

         } break;

         case 9 : { // Textured triangle

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             n2 = (unsigned int)primitive[2],

             tx0 = (unsigned int)primitive[3],

             ty0 = (unsigned int)primitive[4],

             tx1 = (unsigned int)primitive[5],

             ty1 = (unsigned int)primitive[6],

             tx2 = (unsigned int)primitive[7],

             ty2 = (unsigned int)primitive[8];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1),

             x2 = (int)projections(n2,0), y2 = (int)projections(n2,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale,

             z2 = vertices(n2,2) + Z + focale;

           switch (render_type) {

           case 0 :

             draw_point(x0,y0,color.get_vector_at(tx0,ty0),opac).

               draw_point(x1,y1,color.get_vector_at(tx1,ty1),opac).

               draw_point(x2,y2,color.get_vector_at(tx2,ty2),opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

               board.drawCircle((float)x2,dimy()-(float)y2,0);

             }

 #endif

             break;

           case 1 :

             if (zbuffer)

               draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,tx0,ty0,tx1,ty1,opac).

                 draw_line(zbuffer,x0,y0,z0,x2,y2,z2,color,tx0,ty0,tx2,ty2,opac).

                 draw_line(zbuffer,x1,y1,z1,x2,y2,z2,color,tx1,ty1,tx2,ty2,opac);

             else

               draw_line(x0,y0,z0,x1,y1,z1,color,tx0,ty0,tx1,ty1,opac).

                 draw_line(x0,y0,z0,x2,y2,z2,color,tx0,ty0,tx2,ty2,opac).

                 draw_line(x1,y1,z1,x2,y2,z2,color,tx1,ty1,tx2,ty2,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1);

               board.drawLine((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2);

               board.drawLine((float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 2 :

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac);

             else draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 3 :

             if (zbuffer) draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac,lightprops(l));

             else draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac,lightprops(l));

 #ifdef cimg_use_board

             if (pboard) {

               const float lp = cimg::min(lightprops(l),1);

               board.setPenColorRGBi((unsigned char)(128*lp),

                                      (unsigned char)(128*lp),

                                      (unsigned char)(128*lp),

                                      (unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

             }

 #endif

             break;

           case 4 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,lightprops(n0),lightprops(n1),lightprops(n2),opac);

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,lightprops(n0),lightprops(n1),lightprops(n2),opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprops(n0),

                                          (float)x1,dimy()-(float)y1,lightprops(n1),

                                          (float)x2,dimy()-(float)y2,lightprops(n2));

             }

 #endif

             break;

           case 5 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,light_texture,

                             (unsigned int)lightprops(n0,0), (unsigned int)lightprops(n0,1),

                             (unsigned int)lightprops(n1,0), (unsigned int)lightprops(n1,1),

                             (unsigned int)lightprops(n2,0), (unsigned int)lightprops(n2,1),

                             opac);

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,light_texture,

                             (unsigned int)lightprops(n0,0), (unsigned int)lightprops(n0,1),

                             (unsigned int)lightprops(n1,0), (unsigned int)lightprops(n1,1),

                             (unsigned int)lightprops(n2,0), (unsigned int)lightprops(n2,1),

                             opac);

 #ifdef cimg_use_board

             if (pboard) {

               const float

                 l0 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n0,0))), (int)(light_texture.dimy()/2*(1+lightprops(n0,1)))),

                 l1 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n1,0))), (int)(light_texture.dimy()/2*(1+lightprops(n1,1)))),

                 l2 = light_texture((int)(light_texture.dimx()/2*(1+lightprops(n2,0))), (int)(light_texture.dimy()/2*(1+lightprops(n2,1))));

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,(float)x1,dimy()-(float)y1,l1,(float)x2,dimy()-(float)y2,l2);

             }

 #endif

             break;

           }

         } break;

         case 12 : { // Textured rectangle

           const unsigned int

             n0 = (unsigned int)primitive[0],

             n1 = (unsigned int)primitive[1],

             n2 = (unsigned int)primitive[2],

             n3 = (unsigned int)primitive[3],

             tx0 = (unsigned int)primitive[4],

             ty0 = (unsigned int)primitive[5],

             tx1 = (unsigned int)primitive[6],

             ty1 = (unsigned int)primitive[7],

             tx2 = (unsigned int)primitive[8],

             ty2 = (unsigned int)primitive[9],

             tx3 = (unsigned int)primitive[10],

             ty3 = (unsigned int)primitive[11];

           const int

             x0 = (int)projections(n0,0), y0 = (int)projections(n0,1),

             x1 = (int)projections(n1,0), y1 = (int)projections(n1,1),

             x2 = (int)projections(n2,0), y2 = (int)projections(n2,1),

             x3 = (int)projections(n3,0), y3 = (int)projections(n3,1);

           const float

             z0 = vertices(n0,2) + Z + focale,

             z1 = vertices(n1,2) + Z + focale,

             z2 = vertices(n2,2) + Z + focale,

             z3 = vertices(n3,2) + Z + focale;


           switch (render_type) {

           case 0 :

             draw_point(x0,y0,color.get_vector_at(tx0,ty0),opac).

               draw_point(x1,y1,color.get_vector_at(tx1,ty1),opac).

               draw_point(x2,y2,color.get_vector_at(tx2,ty2),opac).

               draw_point(x3,y3,color.get_vector_at(tx3,ty3),opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawCircle((float)x0,dimy()-(float)y0,0);

               board.drawCircle((float)x1,dimy()-(float)y1,0);

               board.drawCircle((float)x2,dimy()-(float)y2,0);

               board.drawCircle((float)x3,dimy()-(float)y3,0);

             }

 #endif

             break;

           case 1 :

             if (zbuffer)

               draw_line(zbuffer,x0,y0,z0,x1,y1,z1,color,tx0,ty0,tx1,ty1,opac).

                 draw_line(zbuffer,x1,y1,z1,x2,y2,z2,color,tx1,ty1,tx2,ty2,opac).

                 draw_line(zbuffer,x2,y2,z2,x3,y3,z3,color,tx2,ty2,tx3,ty3,opac).

                 draw_line(zbuffer,x3,y3,z3,x0,y0,z0,color,tx3,ty3,tx0,ty0,opac);

             else

               draw_line(x0,y0,z0,x1,y1,z1,color,tx0,ty0,tx1,ty1,opac).

                 draw_line(x1,y1,z1,x2,y2,z2,color,tx1,ty1,tx2,ty2,opac).

                 draw_line(x2,y2,z2,x3,y3,z3,color,tx2,ty2,tx3,ty3,opac).

                 draw_line(x3,y3,z3,x0,y0,z0,color,tx3,ty3,tx0,ty0,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.drawLine((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1);

               board.drawLine((float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.drawLine((float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

               board.drawLine((float)x3,dimy()-(float)y3,(float)x0,dimy()-(float)y0);

             }

 #endif

             break;

           case 2 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,opac);

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac).

                 draw_triangle(x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

             }

 #endif

             break;

           case 3 :

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac,lightprops(l)).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,opac,lightprops(l));

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,opac,lightprops(l)).

                 draw_triangle(x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,opac,lightprops(l));

 #ifdef cimg_use_board

             if (pboard) {

               const float lp = cimg::min(lightprops(l),1);

               board.setPenColorRGBi((unsigned char)(128*lp),

                                      (unsigned char)(128*lp),

                                      (unsigned char)(128*lp),

                                      (unsigned char)(opac*255));

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x1,dimy()-(float)y1,(float)x2,dimy()-(float)y2);

               board.fillTriangle((float)x0,dimy()-(float)y0,(float)x2,dimy()-(float)y2,(float)x3,dimy()-(float)y3);

             }

 #endif

             break;

           case 4 : {

             const float

               lightprop0 = lightprops(n0), lightprop1 = lightprops(n1),

               lightprop2 = lightprops(n2), lightprop3 = lightprops(n3);

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,lightprop0,lightprop1,lightprop2,opac).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,lightprop0,lightprop2,lightprop3,opac);

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,lightprop0,lightprop1,lightprop2,opac).

                 draw_triangle(x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,lightprop0,lightprop2,lightprop3,opac);

 #ifdef cimg_use_board

             if (pboard) {

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprop0,

                                          (float)x1,dimy()-(float)y1,lightprop1,

                                          (float)x2,dimy()-(float)y2,lightprop2);

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,lightprop0,

                                          (float)x2,dimy()-(float)y2,lightprop2,

                                          (float)x3,dimy()-(float)y3,lightprop3);

             }

 #endif

           } break;

           case 5 : {

             const unsigned int

               lx0 = (unsigned int)lightprops(n0,0), ly0 = (unsigned int)lightprops(n0,1),

               lx1 = (unsigned int)lightprops(n1,0), ly1 = (unsigned int)lightprops(n1,1),

               lx2 = (unsigned int)lightprops(n2,0), ly2 = (unsigned int)lightprops(n2,1),

               lx3 = (unsigned int)lightprops(n3,0), ly3 = (unsigned int)lightprops(n3,1);

             if (zbuffer)

               draw_triangle(zbuffer,x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac).

                 draw_triangle(zbuffer,x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,light_texture,lx0,ly0,lx2,ly2,lx3,ly3,opac);

             else

               draw_triangle(x0,y0,z0,x1,y1,z1,x2,y2,z2,color,tx0,ty0,tx1,ty1,tx2,ty2,light_texture,lx0,ly0,lx1,ly1,lx2,ly2,opac).

                 draw_triangle(x0,y0,z0,x2,y2,z2,x3,y3,z3,color,tx0,ty0,tx2,ty2,tx3,ty3,light_texture,lx0,ly0,lx2,ly2,lx3,ly3,opac);

 #ifdef cimg_use_board

             if (pboard) {

               const float

                 l0 = light_texture((int)(light_texture.dimx()/2*(1+lx0)), (int)(light_texture.dimy()/2*(1+ly0))),

                 l1 = light_texture((int)(light_texture.dimx()/2*(1+lx1)), (int)(light_texture.dimy()/2*(1+ly1))),

                 l2 = light_texture((int)(light_texture.dimx()/2*(1+lx2)), (int)(light_texture.dimy()/2*(1+ly2))),

                 l3 = light_texture((int)(light_texture.dimx()/2*(1+lx3)), (int)(light_texture.dimy()/2*(1+ly3)));

               board.setPenColorRGBi(128,128,128,(unsigned char)(opac*255));

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,

                                          (float)x1,dimy()-(float)y1,l1,

                                          (float)x2,dimy()-(float)y2,l2);

               board.fillGouraudTriangle((float)x0,dimy()-(float)y0,l0,

                                          (float)x2,dimy()-(float)y2,l2,

                                          (float)x3,dimy()-(float)y3,l3);

             }

 #endif

           } break;

           }

         } break;

         }

       }

       return *this;

     }


     //---------------------------

     //


     //---------------------------


     CImg<T>& select(CImgDisplay &disp,

                     const int select_type=2, unsigned int *const XYZ=0,

                     const unsigned char *const color=0) {

       return get_select(disp,select_type,XYZ,color).transfer_to(*this);

     }


     CImg<T>& select(const char *const title,

                     const int select_type=2, unsigned int *const XYZ=0,

                     const unsigned char *const color=0) {

       return get_select(title,select_type,XYZ,color).transfer_to(*this);

     }


     CImg<intT> get_select(CImgDisplay &disp,

                           const int select_type=2, unsigned int *const XYZ=0,

                           const unsigned char *const color=0) const {

       return _get_select(disp,0,select_type,XYZ,color,0,0,0);

     }


     CImg<intT> get_select(const char *const title,

                           const int select_type=2, unsigned int *const XYZ=0,

                           const unsigned char *const color=0) const {

       CImgDisplay disp;

       return _get_select(disp,title,select_type,XYZ,color,0,0,0);

     }


     CImg<intT> _get_select(CImgDisplay &disp, const char *const title,

                            const int coords_type, unsigned int *const XYZ,

                            const unsigned char *const color,

                            const int origX, const int origY, const int origZ) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::select() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       if (!disp) {

         char ntitle[64] = { 0 }; if (!title) { std::sprintf(ntitle,"CImg<%s>",pixel_type()); }

         disp.assign(cimg_fitscreen(width,height,depth),title?title:ntitle,1);

       }


       const unsigned int

         old_normalization = disp.normalization,

         hatch = 0x55555555;


       bool old_is_resized = disp.is_resized;

       disp.normalization = 0;

       disp.show().key = 0;


       unsigned char foreground_color[] = { 255,255,105 }, background_color[] = { 0,0,0 };

       if (color) std::memcpy(foreground_color,color,sizeof(unsigned char)*cimg::min(3,dimv()));


       int area = 0, clicked_area = 0, phase = 0,

         X0 = (int)((XYZ?XYZ[0]:width/2)%width), Y0 = (int)((XYZ?XYZ[1]:height/2)%height), Z0 = (int)((XYZ?XYZ[2]:depth/2)%depth),

         X1 =-1, Y1 = -1, Z1 = -1,

         X = -1, Y = -1, Z = -1,

         oX = X, oY = Y, oZ = Z;

       unsigned int old_button = 0, key = 0;


       bool shape_selected = false, text_down = false;

       CImg<ucharT> visu, visu0;

       char text[1024] = { 0 };


       while (!key && !disp.is_closed && !shape_selected) {


         // Handle mouse motion and selection

         oX = X; oY = Y; oZ = Z;

         int mx = disp.mouse_x, my = disp.mouse_y;

         const int mX = mx*(width+(depth>1?depth:0))/disp.width, mY = my*(height+(depth>1?depth:0))/disp.height;


         area = 0;

         if (mX<dimx() && mY<dimy())  { area = 1; X = mX; Y = mY; Z = phase?Z1:Z0; }

         if (mX<dimx() && mY>=dimy()) { area = 2; X = mX; Z = mY-height; Y = phase?Y1:Y0; }

         if (mX>=dimx() && mY<dimy()) { area = 3; Y = mY; Z = mX-width; X = phase?X1:X0; }


         switch (key = disp.key) {

         case 0 : case cimg::keyCTRLLEFT : disp.key = key = 0; break;

         case cimg::keyPAGEUP : if (disp.is_keyCTRLLEFT) { ++disp.wheel; key = 0; } break;

         case cimg::keyPAGEDOWN : if (disp.is_keyCTRLLEFT) { --disp.wheel; key = 0; } break;

         case cimg::keyD : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,false),

                                      CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,true),false).is_resized = true;

           disp.key = key = 0;

         } break;

         case cimg::keyC : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(2*disp.width/3,2*disp.height/3,1),false).is_resized = true;

           disp.key = key = 0; visu0.assign();

         } break;

         case cimg::keyR : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(width,height,depth),false).is_resized = true;

           disp.key = key = 0; visu0.assign();

         } break;

         case cimg::keyF : if (disp.is_keyCTRLLEFT) {

           disp.resize(disp.screen_dimx(),disp.screen_dimy(),false).toggle_fullscreen().is_resized = true;

           disp.key = key = 0; visu0.assign();

         } break;

         case cimg::keyS : if (disp.is_keyCTRLLEFT) {

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.bmp",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           if (visu0) {

             visu.draw_text(2,2,"Saving snapshot...",foreground_color,background_color,0.8f,11).display(disp);

             visu0.save(filename);

             visu.draw_text(2,2,"Snapshot '%s' saved.",foreground_color,background_color,0.8f,11,filename).display(disp);

           }

           disp.key = key = 0;

         } break;

         case cimg::keyO : if (disp.is_keyCTRLLEFT) {

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.cimg",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           visu.draw_text(2,2,"Saving instance...",foreground_color,background_color,0.8f,11).display(disp);

           save(filename);

           visu.draw_text(2,2,"Instance '%s' saved.",foreground_color,background_color,0.8f,11,filename).display(disp);

           disp.key = key = 0;

         } break;

         }


         if (!area) mx = my = X = Y = Z = -1;

         else {

           if (disp.button&1 && phase<2) { X1 = X; Y1 = Y; Z1 = Z; }

           if (!(disp.button&1) && phase>=2) {

             switch (clicked_area) {

             case 1 : Z1 = Z; break;

             case 2 : Y1 = Y; break;

             case 3 : X1 = X; break;

             }

           }

           if (disp.button&2) { if (phase) { X1 = X; Y1 = Y; Z1 = Z; } else { X0 = X; Y0 = Y; Z0 = Z; } }

           if (disp.button&4) { oX = X = X0; oY = Y = Y0; oZ = Z = Z0; phase = 0; visu.assign(); }

           if (disp.wheel) {

             if (depth>1 && !disp.is_keyCTRLLEFT && !disp.is_keySHIFTLEFT && !disp.is_keyALT) {

               switch (area) {

               case 1 : if (phase) Z = (Z1+=disp.wheel); else Z = (Z0+=disp.wheel); break;

               case 2 : if (phase) Y = (Y1+=disp.wheel); else Y = (Y0+=disp.wheel); break;

               case 3 : if (phase) X = (X1+=disp.wheel); else X = (X0+=disp.wheel); break;

               }

               disp.wheel = 0;

             } else key = ~0U;

           }

           if ((disp.button&1)!=old_button) {

             switch (phase++) {

             case 0 : X0 = X1 = X; Y0 = Y1 = Y; Z0 = Z1 = Z; clicked_area = area; break;

             case 1 : X1 = X; Y1 = Y; Z1 = Z; break;

             }

             old_button = disp.button&1;

           }

           if (depth>1 && (X!=oX || Y!=oY || Z!=oZ)) visu0.assign();

         }


         if (phase) {

           if (!coords_type) shape_selected = phase?true:false;

           else {

             if (depth>1) shape_selected = (phase==3)?true:false;

             else shape_selected = (phase==2)?true:false;

           }

         }


         if (X0<0) X0 = 0; if (X0>=dimx()) X0 = dimx()-1; if (Y0<0) Y0 = 0; if (Y0>=dimy()) Y0 = dimy()-1;

         if (Z0<0) Z0 = 0; if (Z0>=dimz()) Z0 = dimz()-1;

         if (X1<1) X1 = 0; if (X1>=dimx()) X1 = dimx()-1; if (Y1<0) Y1 = 0; if (Y1>=dimy()) Y1 = dimy()-1;

         if (Z1<0) Z1 = 0; if (Z1>=dimz()) Z1 = dimz()-1;


         // Draw visualization image on the display

         if (oX!=X || oY!=Y || oZ!=Z || !visu0) {

           if (!visu0) {

             CImg<Tuchar> tmp, tmp0;

             if (depth!=1) {

               tmp0 = (!phase)?get_projections2d(X0,Y0,Z0):get_projections2d(X1,Y1,Z1);

               tmp = tmp0.get_channels(0,cimg::min(2U,dim-1));

             } else tmp = get_channels(0,cimg::min(2U,dim-1));

             switch (old_normalization) {

             case 0 : visu0 = tmp; break;

             case 3 :

               if (cimg::type<T>::is_float()) visu0 = tmp.normalize(0,(T)255);

               else {

                 const float m = (float)cimg::type<T>::min(), M = (float)cimg::type<T>::max();

                 visu0.assign(tmp.width,tmp.height,1,tmp.dim);

                 unsigned char *ptrd = visu0.end();

                 cimg_for(tmp,ptrs,Tuchar) *(--ptrd) = (unsigned char)((*ptrs-m)*255.0f/(M-m));

               } break;

             default : visu0 = tmp.normalize(0,255);

             }

             visu0.resize(disp);

           }

           visu = visu0;

           if (!color) {

             if (visu.mean()<200) {

               foreground_color[0] = foreground_color[1] = foreground_color[2] = 255;

               background_color[0] = background_color[1] = background_color[2] = 0;

             } else {

               foreground_color[0] = foreground_color[1] = foreground_color[2] = 0;

               background_color[0] = background_color[1] = background_color[2] = 255;

             }

           }


           const int d = (depth>1)?depth:0;

           if (phase) switch (coords_type) {

           case 1 : {

             const int

               x0 = (int)((X0+0.5f)*disp.width/(width+d)),

               y0 = (int)((Y0+0.5f)*disp.height/(height+d)),

               x1 = (int)((X1+0.5f)*disp.width/(width+d)),

               y1 = (int)((Y1+0.5f)*disp.height/(height+d));

             visu.draw_arrow(x0,y0,x1,y1,foreground_color,0.6f,30,5,hatch);

             if (d) {

               const int

                 zx0 = (int)((width+Z0+0.5f)*disp.width/(width+d)),

                 zx1 = (int)((width+Z1+0.5f)*disp.width/(width+d)),

                 zy0 = (int)((height+Z0+0.5f)*disp.height/(height+d)),

                 zy1 = (int)((height+Z1+0.5f)*disp.height/(height+d));

               visu.draw_arrow(zx0,y0,zx1,y1,foreground_color,0.6f,30,5,hatch).

                 draw_arrow(x0,zy0,x1,zy1,foreground_color,0.6f,30,5,hatch);

             }

           } break;

           case 2 : {

             const int

               x0 = (X0<X1?X0:X1)*disp.width/(width+d), y0 = (Y0<Y1?Y0:Y1)*disp.height/(height+d),

               x1 = ((X0<X1?X1:X0)+1)*disp.width/(width+d)-1, y1 = ((Y0<Y1?Y1:Y0)+1)*disp.height/(height+d)-1;

             visu.draw_rectangle(x0,y0,x1,y1,foreground_color,0.2f).draw_rectangle(x0,y0,x1,y1,foreground_color,0.6f,hatch);

             if (d) {

               const int

                 zx0 = (int)((width+(Z0<Z1?Z0:Z1))*disp.width/(width+d)),

                 zy0 = (int)((height+(Z0<Z1?Z0:Z1))*disp.height/(height+d)),

                 zx1 = (int)((width+(Z0<Z1?Z1:Z0)+1)*disp.width/(width+d))-1,

                 zy1 = (int)((height+(Z0<Z1?Z1:Z0)+1)*disp.height/(height+d))-1;

               visu.draw_rectangle(zx0,y0,zx1,y1,foreground_color,0.2f).draw_rectangle(zx0,y0,zx1,y1,foreground_color,0.6f,hatch);

               visu.draw_rectangle(x0,zy0,x1,zy1,foreground_color,0.2f).draw_rectangle(x0,zy0,x1,zy1,foreground_color,0.6f,hatch);

             }

           } break;

           case 3 : {

             const int

               x0 = X0*disp.width/(width+d),

               y0 = Y0*disp.height/(height+d),

               x1 = X1*disp.width/(width+d)-1,

               y1 = Y1*disp.height/(height+d)-1;

             visu.draw_ellipse(x0,y0,(float)(x1-x0),(float)(y1-y0),0,foreground_color,0.2f).

               draw_ellipse(x0,y0,(float)(x1-x0),(float)(y1-y0),0,foreground_color,0.6f,hatch);

             if (d) {

               const int

                 zx0 = (int)((width+Z0)*disp.width/(width+d)),

                 zy0 = (int)((height+Z0)*disp.height/(height+d)),

                 zx1 = (int)((width+Z1+1)*disp.width/(width+d))-1,

                 zy1 = (int)((height+Z1+1)*disp.height/(height+d))-1;

               visu.draw_ellipse(zx0,y0,(float)(zx1-zx0),(float)(y1-y0),0,foreground_color,0.2f).

                 draw_ellipse(zx0,y0,(float)(zx1-zx0),(float)(y1-y0),0,foreground_color,0.6f,hatch).

                 draw_ellipse(x0,zy0,(float)(x1-x0),(float)(zy1-zy0),0,foreground_color,0.2f).

                 draw_ellipse(x0,zy0,(float)(x1-x0),(float)(zy1-zy0),0,foreground_color,0.6f,hatch);

             }

           } break;

           } else {

             const int

               x0 = X*disp.width/(width+d),

               y0 = Y*disp.height/(height+d),

               x1 = (X+1)*disp.width/(width+d)-1,

               y1 = (Y+1)*disp.height/(height+d)-1;

             if (x1-x0>=4 && y1-y0>=4) visu.draw_rectangle(x0,y0,x1,y1,foreground_color,0.4f,~0U);

           }


           if (my<12) text_down = true;

           if (my>=visu.dimy()-11) text_down = false;

           if (!coords_type || !phase) {

             if (X>=0 && Y>=0 && Z>=0 && X<dimx() && Y<dimy() && Z<dimz()) {

               if (depth>1) std::sprintf(text,"Point (%d,%d,%d) = [ ",origX+X,origY+Y,origZ+Z);

               else std::sprintf(text,"Point (%d,%d) = [ ",origX+X,origY+Y);

               char *ctext = text + std::strlen(text), *const ltext = text + 512;

               for (unsigned int k = 0; k<dim && ctext<ltext; ++k) {

                 std::sprintf(ctext,cimg::type<T>::format(),cimg::type<T>::format((*this)(X,Y,Z,k)));

                 ctext = text + std::strlen(text);

                 *(ctext++) = ' '; *ctext = 0;

               }

               std::sprintf(text + std::strlen(text),"]");

             }

           } else switch (coords_type) {

           case 1 : {

             const double dX = (double)(X0 - X1), dY = (double)(Y0 - Y1), dZ = (double)(Z0 - Z1), norm = std::sqrt(dX*dX+dY*dY+dZ*dZ);

             if (depth>1) std::sprintf(text,"Vect (%d,%d,%d)-(%d,%d,%d), Norm = %g",

                                       origX+X0,origY+Y0,origZ+Z0,origX+X1,origY+Y1,origZ+Z1,norm);

             else std::sprintf(text,"Vect (%d,%d)-(%d,%d), Norm = %g",

                               origX+X0,origY+Y0,origX+X1,origY+Y1,norm);

           } break;

           case 2 :

             if (depth>1) std::sprintf(text,"Box (%d,%d,%d)-(%d,%d,%d), Size = (%d,%d,%d)",

                                       origX+(X0<X1?X0:X1),origY+(Y0<Y1?Y0:Y1),origZ+(Z0<Z1?Z0:Z1),

                                       origX+(X0<X1?X1:X0),origY+(Y0<Y1?Y1:Y0),origZ+(Z0<Z1?Z1:Z0),

                                       1+cimg::abs(X0-X1),1+cimg::abs(Y0-Y1),1+cimg::abs(Z0-Z1));

             else  std::sprintf(text,"Box (%d,%d)-(%d,%d), Size = (%d,%d)",

                                origX+(X0<X1?X0:X1),origY+(Y0<Y1?Y0:Y1),origX+(X0<X1?X1:X0),origY+(Y0<Y1?Y1:Y0),

                                1+cimg::abs(X0-X1),1+cimg::abs(Y0-Y1));

             break;

           default :

             if (depth>1) std::sprintf(text,"Ellipse (%d,%d,%d)-(%d,%d,%d), Radii = (%d,%d,%d)",

                                       origX+X0,origY+Y0,origZ+Z0,origX+X1,origY+Y1,origZ+Z1,

                                       1+cimg::abs(X0-X1),1+cimg::abs(Y0-Y1),1+cimg::abs(Z0-Z1));

             else  std::sprintf(text,"Ellipse (%d,%d)-(%d,%d), Radii = (%d,%d)",

                                origX+X0,origY+Y0,origX+X1,origY+Y1,1+cimg::abs(X0-X1),1+cimg::abs(Y0-Y1));


           }

           if (phase || (mx>=0 && my>=0)) visu.draw_text(0,text_down?visu.dimy()-11:0,text,foreground_color,background_color,0.7f,11);

           disp.display(visu).wait(25);

         } else if (!shape_selected) disp.wait();

         if (disp.is_resized) { disp.resize(false).is_resized = false; old_is_resized = true; visu0.assign(); }

       }


       // Return result

       CImg<intT> res(1,6,1,1,-1);

       if (XYZ) { XYZ[0] = (unsigned int)X0; XYZ[1] = (unsigned int)Y0; XYZ[2] = (unsigned int)Z0; }

       if (shape_selected) {

         if (coords_type==2) {

           if (X0>X1) cimg::swap(X0,X1);

           if (Y0>Y1) cimg::swap(Y0,Y1);

           if (Z0>Z1) cimg::swap(Z0,Z1);

         }

         if (X1<0 || Y1<0 || Z1<0) X0 = Y0 = Z0 = X1 = Y1 = Z1 = -1;

         switch (coords_type) {

         case 1 :

         case 2 :  res[3] = X1; res[4] = Y1; res[5] = Z1;

         default : res[0] = X0; res[1] = Y0; res[2] = Z0;

         }

       }

       disp.button = 0;

       disp.normalization = old_normalization;

       disp.is_resized = old_is_resized;

       if (key!=~0U) disp.key = key;

       return res;

     }


     CImg<intT> get_select_graph(CImgDisplay &disp,

                                 const unsigned int plot_type=1, const unsigned int vertex_type=1,

                                 const char *const labelx=0, const double xmin=0, const double xmax=0,

                                 const char *const labely=0, const double ymin=0, const double ymax=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::display_graph() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       const unsigned int siz = width*height*depth, onormalization = disp.normalization;

       if (!disp) { char ntitle[64] = { 0 }; std::sprintf(ntitle,"CImg<%s>",pixel_type()); disp.assign(640,480,ntitle,0); }

       disp.show().key = disp.normalization = disp.button = disp.wheel = 0;  // Must keep 'key' field unchanged.

       double nymin = ymin, nymax = ymax, nxmin = xmin, nxmax = xmax;

       if (nymin==nymax) nymin = (Tfloat)minmax(nymax);

       if (nymin==nymax) { --nymin; ++nymax; }

       if (nxmin==nxmax && nxmin==0) { nxmin = 0; nxmax = siz - 1.0; }


       const unsigned char black[] = { 0,0,0 }, white[] = { 255,255,255 }, gray[] = { 220,220,220 };

       const unsigned char gray2[] = { 110,110,110 }, ngray[] = { 35,35,35 };

       static unsigned int odimv = 0;

       static CImg<ucharT> palette;

       if (odimv!=dim) {

         odimv = dim;

         palette = CImg<ucharT>(3,dim,1,1,120).noise(70,1);

         if (dim==1) { palette[0] = palette[1] = 120; palette[2] = 200; }

         else {

           palette(0,0) = 220; palette(1,0) = 10; palette(2,0) = 10;

           if (dim>1) { palette(0,1) = 10; palette(1,1) = 220; palette(2,1) = 10; }

           if (dim>2) { palette(0,2) = 10; palette(1,2) = 10; palette(2,2) = 220; }

         }

       }


       CImg<ucharT> visu0, visu, graph, text, axes;

       const unsigned int whz = width*height*depth;

       int x0 = -1, x1 = -1, y0 = -1, y1 = -1, omouse_x = -2, omouse_y = -2;

       char message[1024] = { 0 };

       unsigned int okey = 0, obutton = 0;

       CImg_3x3(I,unsigned char);


       for (bool selected = false; !selected && !disp.is_closed && !okey && !disp.wheel; ) {

         const int mouse_x = disp.mouse_x, mouse_y = disp.mouse_y;

         const unsigned int key = disp.key, button = disp.button;


         // Generate graph representation.

         if (!visu0) {

           visu0.assign(disp.dimx(),disp.dimy(),1,3,220);

           const int gdimx = disp.dimx() - 32, gdimy = disp.dimy() - 32;

           if (gdimx>0 && gdimy>0) {

             graph.assign(gdimx,gdimy,1,3,255);

             graph.draw_grid(-10,-10,0,0,false,true,black,0.2f,0x33333333,0x33333333);

             cimg_forV(*this,k) graph.draw_graph(get_shared_channel(k),&palette(0,k),(plot_type!=3 || dim==1)?1:0.6f,

                                                 plot_type,vertex_type,nymax,nymin,false);


             axes.assign(gdimx,gdimy,1,1,0);

             const float

               dx = (float)cimg::abs(nxmax-nxmin), dy = (float)cimg::abs(nymax-nymin),

               px = (float)std::pow(10.0,(int)std::log10(dx)-2.0),

               py = (float)std::pow(10.0,(int)std::log10(dy)-2.0);

             const CImg<Tdouble>

               seqx = CImg<Tdouble>::sequence(1 + gdimx/60,nxmin,nxmax).round(px),

               seqy = CImg<Tdouble>::sequence(1 + gdimy/60,nymax,nymin).round(py);

             axes.draw_axis(seqx,seqy,white);

             if (nymin>0) axes.draw_axis(seqx,gdimy-1,gray);

             if (nymax<0) axes.draw_axis(seqx,0,gray);

             if (nxmin>0) axes.draw_axis(0,seqy,gray);

             if (nxmax<0) axes.draw_axis(gdimx-1,seqy,gray);


             cimg_for3x3(axes,x,y,0,0,I)

               if (Icc) {

                 if (Icc==255) cimg_forV(graph,k) graph(x,y,k) = 0;

                 else cimg_forV(graph,k) graph(x,y,k) = (unsigned char)(2*graph(x,y,k)/3);

               }

               else if (Ipc || Inc || Icp || Icn || Ipp || Inn || Ipn || Inp) cimg_forV(graph,k) graph(x,y,k) = (graph(x,y,k)+255)/2;


             visu0.draw_image(16,16,graph);

             visu0.draw_line(15,15,16+gdimx,15,gray2).draw_line(16+gdimx,15,16+gdimx,16+gdimy,gray2).

               draw_line(16+gdimx,16+gdimy,15,16+gdimy,white).draw_line(15,16+gdimy,15,15,white);

           } else graph.assign();

           text.assign().draw_text(0,0,labelx?labelx:"X-axis",white,ngray,1);

           visu0.draw_image((visu0.dimx()-text.dimx())/2,visu0.dimy()-14,~text);

           text.assign().draw_text(0,0,labely?labely:"Y-axis",white,ngray,1).rotate(-90);

           visu0.draw_image(2,(visu0.dimy()-text.dimy())/2,~text);

           visu.assign();

         }


         // Generate and display current view.

         if (!visu) {

           visu.assign(visu0);

           if (graph && x0>=0 && x1>=0) {

             const int

               nx0 = x0<=x1?x0:x1,

               nx1 = x0<=x1?x1:x0,

               ny0 = y0<=y1?y0:y1,

               ny1 = y0<=y1?y1:y0,

               sx0 = 16 + nx0*(visu.dimx()-32)/whz,

               sx1 = 15 + (nx1+1)*(visu.dimx()-32)/whz,

               sy0 = 16 + ny0,

               sy1 = 16 + ny1;


             if (y0>=0 && y1>=0)

               visu.draw_rectangle(sx0,sy0,sx1,sy1,gray,0.5f).draw_rectangle(sx0,sy0,sx1,sy1,black,0.5f,0xCCCCCCCCU);

             else visu.draw_rectangle(sx0,0,sx1,visu.dimy()-17,gray,0.5f).

                    draw_line(sx0,16,sx0,visu.dimy()-17,black,0.5f,0xCCCCCCCCU).

                    draw_line(sx1,16,sx1,visu.dimy()-17,black,0.5f,0xCCCCCCCCU);

           }

           if (mouse_x>=16 && mouse_y>=16 && mouse_x<visu.dimx()-16 && mouse_y<visu.dimy()-16) {

             if (graph) visu.draw_line(mouse_x,16,mouse_x,visu.dimy()-17,black,0.5f,0x55555555U);

             const unsigned x = (mouse_x-16)*whz/(disp.dimx()-32);

             const double cx = nxmin + x*(nxmax-nxmin)/whz;

             if (dim>=7)

               std::sprintf(message,"Value[%g] = ( %g %g %g ... %g %g %g )",cx,

                            (double)(*this)(x,0,0,0),(double)(*this)(x,0,0,1),(double)(*this)(x,0,0,2),

                            (double)(*this)(x,0,0,dim-4),(double)(*this)(x,0,0,dim-3),(double)(*this)(x,0,0,dim-1));

             else {

               std::sprintf(message,"Value[%g] = ( ",cx);

               cimg_forV(*this,k) std::sprintf(message+std::strlen(message),"%g ",(double)(*this)(x,0,0,k));

               std::sprintf(message+std::strlen(message),")");

             }

             if (x0>=0 && x1>=0) {

               const int

                  nx0 = x0<=x1?x0:x1,

                  nx1 = x0<=x1?x1:x0,

                  ny0 = y0<=y1?y0:y1,

                  ny1 = y0<=y1?y1:y0;

               const double

                  cx0 = nxmin + nx0*(nxmax-nxmin)/(visu.dimx()-32),

                  cx1 = nxmin + nx1*(nxmax-nxmin)/(visu.dimx()-32),

                  cy0 = nymax - ny0*(nymax-nymin)/(visu.dimy()-32),

                  cy1 = nymax - ny1*(nymax-nymin)/(visu.dimy()-32);

               if (y0>=0 && y1>=0)

                 std::sprintf(message+std::strlen(message)," - Range ( %g, %g ) - ( %g, %g )",cx0,cy0,cx1,cy1);

               else

                 std::sprintf(message+std::strlen(message)," - Range [ %g - %g ]",cx0,cx1);

             }

             text.assign().draw_text(0,0,message,white,ngray,1);

             visu.draw_image((visu.dimx()-text.dimx())/2,2,~text);

           }

           visu.display(disp);

         }


         // Test keys.

         switch (okey = key) {

         case cimg::keyCTRLLEFT : okey = 0; break;

         case cimg::keyD : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,false),

                                      CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,true),false).is_resized = true;

           disp.key = okey = 0;

         } break;

         case cimg::keyC : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(2*disp.width/3,2*disp.height/3,1),false).is_resized = true;

           disp.key = okey = 0;

         } break;

         case cimg::keyR : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(640,480,1),false).is_resized = true;

           disp.key = okey = 0;

         } break;

         case cimg::keyF : if (disp.is_keyCTRLLEFT) {

           disp.resize(disp.screen_dimx(),disp.screen_dimy(),false).toggle_fullscreen().is_resized = true;

           disp.key = okey = 0;

         } break;

         case cimg::keyS : if (disp.is_keyCTRLLEFT) {

           static unsigned int snap_number = 0;

           if (visu || visu0) {

             CImg<ucharT> &screen = visu?visu:visu0;

             char filename[32] = { 0 };

             std::FILE *file;

             do {

               std::sprintf(filename,"CImg_%.4u.bmp",snap_number++);

               if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

             } while (file);

             (+screen).draw_text(2,2,"Saving BMP snapshot...",black,gray,1,11).display(disp);

             screen.save(filename);

             screen.draw_text(2,2,"Snapshot '%s' saved.",black,gray,1,11,filename).display(disp);

           }

           disp.key = okey = 0;

         } break;

         }


         // Handle mouse motion and mouse buttons

         if (obutton!=button || omouse_x!=mouse_x || omouse_y!=mouse_y) {

           visu.assign();

           if (disp.mouse_x>=0 && disp.mouse_y>=0) {

             const int

               mx = (mouse_x-16)*(int)whz/(disp.dimx()-32),

               cx = mx<0?0:(mx>=(int)whz?whz-1:mx),

               my = mouse_y-16,

               cy = my<=0?0:(my>=(disp.dimy()-32)?(disp.dimy()-32):my);

             if (button&1) { if (!obutton) { x0 = cx; y0 = -1; } else { x1 = cx; y1 = -1; }}

             else if (button&2) { if (!obutton) { x0 = cx; y0 = cy; } else { x1 = cx; y1 = cy; }}

             else if (obutton) { x1 = cx; y1 = y1>=0?cy:-1; selected = true; }

           } else if (!button && obutton) selected = true;

           obutton = button; omouse_x = mouse_x; omouse_y = mouse_y;

         }

         if (disp.is_resized) { disp.resize(false); visu0.assign(); }

         if (visu && visu0) disp.wait();

       }

       disp.normalization = onormalization;

       if (x1<x0) cimg::swap(x0,x1);

       if (y1<y0) cimg::swap(y0,y1);

       disp.key = okey;

       return CImg<intT>(4,1,1,1,x0,y0,x1,y1);

     }


     CImg<T>& load(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load() : Cannot load (null) filename.",

                                     pixel_type());

       const char *ext = cimg::split_filename(filename);

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       assign();

       try {

 #ifdef cimg_load_plugin

         cimg_load_plugin(filename);

 #endif

 #ifdef cimg_load_plugin1

         cimg_load_plugin1(filename);

 #endif

 #ifdef cimg_load_plugin2

         cimg_load_plugin2(filename);

 #endif

 #ifdef cimg_load_plugin3

         cimg_load_plugin3(filename);

 #endif

 #ifdef cimg_load_plugin4

         cimg_load_plugin4(filename);

 #endif

 #ifdef cimg_load_plugin5

         cimg_load_plugin5(filename);

 #endif

 #ifdef cimg_load_plugin6

         cimg_load_plugin6(filename);

 #endif

 #ifdef cimg_load_plugin7

         cimg_load_plugin7(filename);

 #endif

 #ifdef cimg_load_plugin8

         cimg_load_plugin8(filename);

 #endif

         // ASCII formats

         if (!cimg::strcasecmp(ext,"asc")) load_ascii(filename);

         if (!cimg::strcasecmp(ext,"dlm") ||

             !cimg::strcasecmp(ext,"txt")) load_dlm(filename);


         // 2D binary formats

         if (!cimg::strcasecmp(ext,"bmp")) load_bmp(filename);

         if (!cimg::strcasecmp(ext,"jpg") ||

             !cimg::strcasecmp(ext,"jpeg") ||

             !cimg::strcasecmp(ext,"jpe") ||

             !cimg::strcasecmp(ext,"jfif") ||

             !cimg::strcasecmp(ext,"jif")) load_jpeg(filename);

         if (!cimg::strcasecmp(ext,"png")) load_png(filename);

         if (!cimg::strcasecmp(ext,"ppm") ||

             !cimg::strcasecmp(ext,"pgm") ||

             !cimg::strcasecmp(ext,"pnm")) load_pnm(filename);

         if (!cimg::strcasecmp(ext,"tif") ||

             !cimg::strcasecmp(ext,"tiff")) load_tiff(filename);

         if (!cimg::strcasecmp(ext,"cr2") ||

             !cimg::strcasecmp(ext,"crw") ||

             !cimg::strcasecmp(ext,"dcr") ||

             !cimg::strcasecmp(ext,"mrw") ||

             !cimg::strcasecmp(ext,"nef") ||

             !cimg::strcasecmp(ext,"orf") ||

             !cimg::strcasecmp(ext,"pix") ||

             !cimg::strcasecmp(ext,"ptx") ||

             !cimg::strcasecmp(ext,"raf") ||

             !cimg::strcasecmp(ext,"srf")) load_dcraw_external(filename);


         // 3D binary formats

         if (!cimg::strcasecmp(ext,"dcm") ||

             !cimg::strcasecmp(ext,"dicom")) load_medcon_external(filename);

         if (!cimg::strcasecmp(ext,"hdr") ||

             !cimg::strcasecmp(ext,"nii")) load_analyze(filename);

         if (!cimg::strcasecmp(ext,"par") ||

             !cimg::strcasecmp(ext,"rec")) load_parrec(filename);

         if (!cimg::strcasecmp(ext,"inr")) load_inr(filename);

         if (!cimg::strcasecmp(ext,"pan")) load_pandore(filename);

         if (!cimg::strcasecmp(ext,"cimg") ||

             !cimg::strcasecmp(ext,"cimgz") ||

             !*ext)  return load_cimg(filename);


         // Archive files

         if (!cimg::strcasecmp(ext,"gz")) load_gzip_external(filename);


         // Image sequences

         if (!cimg::strcasecmp(ext,"avi") ||

             !cimg::strcasecmp(ext,"mov") ||

             !cimg::strcasecmp(ext,"asf") ||

             !cimg::strcasecmp(ext,"divx") ||

             !cimg::strcasecmp(ext,"flv") ||

             !cimg::strcasecmp(ext,"mpg") ||

             !cimg::strcasecmp(ext,"m1v") ||

             !cimg::strcasecmp(ext,"m2v") ||

             !cimg::strcasecmp(ext,"m4v") ||

             !cimg::strcasecmp(ext,"mjp") ||

             !cimg::strcasecmp(ext,"mkv") ||

             !cimg::strcasecmp(ext,"mpe") ||

             !cimg::strcasecmp(ext,"movie") ||

             !cimg::strcasecmp(ext,"ogm") ||

             !cimg::strcasecmp(ext,"qt") ||

             !cimg::strcasecmp(ext,"rm") ||

             !cimg::strcasecmp(ext,"vob") ||

             !cimg::strcasecmp(ext,"wmv") ||

             !cimg::strcasecmp(ext,"xvid") ||

             !cimg::strcasecmp(ext,"mpeg")) load_ffmpeg(filename);

         if (is_empty()) throw CImgIOException("CImg<%s>::load()",pixel_type());

       } catch (CImgException& e) {

         if (!cimg::strncasecmp(e.message,"cimg::fopen()",13)) {

           cimg::exception_mode() = omode;

           throw CImgIOException("CImg<%s>::load() : File '%s' cannot be opened.",pixel_type(),filename);

         } else try {

           const char *const ftype = cimg::file_type(0,filename);

           assign();

           if (!cimg::strcasecmp(ftype,"pnm")) load_pnm(filename);

           if (!cimg::strcasecmp(ftype,"bmp")) load_bmp(filename);

           if (!cimg::strcasecmp(ftype,"jpeg")) load_jpeg(filename);

           if (!cimg::strcasecmp(ftype,"pan")) load_pandore(filename);

           if (!cimg::strcasecmp(ftype,"png")) load_png(filename);

           if (!cimg::strcasecmp(ftype,"tiff")) load_tiff(filename);

           if (is_empty()) throw CImgIOException("CImg<%s>::load()",pixel_type());

         } catch (CImgException&) {

           try {

             load_other(filename);

           } catch (CImgException&) {

             assign();

           }

         }

       }

       cimg::exception_mode() = omode;

       if (is_empty())

         throw CImgIOException("CImg<%s>::load() : File '%s', format not recognized.",pixel_type(),filename);

       return *this;

     }


     static CImg<T> get_load(const char *const filename) {

       return CImg<T>().load(filename);

     }


     CImg<T>& load_ascii(const char *const filename) {

       return _load_ascii(0,filename);

     }


     static CImg<T> get_load_ascii(const char *const filename) {

       return CImg<T>().load_ascii(filename);

     }


     CImg<T>& load_ascii(std::FILE *const file) {

       return _load_ascii(file,0);

     }


     static CImg<T> get_load_ascii(std::FILE *const file) {

       return CImg<T>().load_ascii(file);

     }


     CImg<T>& _load_ascii(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_ascii() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       char line[256] = { 0 };

       int err = std::fscanf(nfile,"%255[^\n]",line);

       unsigned int off, dx = 0, dy = 1, dz = 1, dv = 1;

       std::sscanf(line,"%u%*c%u%*c%u%*c%u",&dx,&dy,&dz,&dv);

       err = std::fscanf(nfile,"%*[^0-9.eE+-]");

       if (!dx || !dy || !dz || !dv) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_ascii() : File '%s', invalid .ASC header, specified image dimensions are (%u,%u,%u,%u).",

                               pixel_type(),filename?filename:"(FILE*)",dx,dy,dz,dv);

       }

       assign(dx,dy,dz,dv);

       const unsigned int siz = size();

       double val;

       T *ptr = data;

       for (err = 1, off = 0; off<siz && err==1; ++off) {

         err = std::fscanf(nfile,"%lf%*[^0-9.eE+-]",&val);

         *(ptr++) = (T)val;

       }

       if (err!=1)

         cimg::warn("CImg<%s>::load_ascii() : File '%s', only %u/%u values read.",

                    pixel_type(),filename?filename:"(FILE*)",off-1,siz);

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_dlm(const char *const filename) {

       return _load_dlm(0,filename);

     }


     static CImg<T> get_load_dlm(const char *const filename) {

       return CImg<T>().load_dlm(filename);

     }


     CImg<T>& load_dlm(std::FILE *const file) {

       return _load_dlm(file,0);

     }


     static CImg<T> get_load_dlm(std::FILE *const file) {

       return CImg<T>().load_dlm(file);

     }


     CImg<T>& _load_dlm(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_dlm() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"r");

       char delimiter[256] = { 0 }, tmp[256] = { 0 };

       unsigned int cdx = 0, dx = 0, dy = 0;

       int err = 0;

       double val;

       assign(256,256);

       while ((err = std::fscanf(nfile,"%lf%255[^0-9.+-]",&val,delimiter))>0) {

         if (err>0) (*this)(cdx++,dy) = (T)val;

         if (cdx>=width) resize(3*width/2,1,1,1,0);

         char c = 0;

         if (!std::sscanf(delimiter,"%255[^\n]%c",tmp,&c) || c=='\n') {

           dx = cimg::max(cdx,dx);

           if (++dy>=height) resize(width,3*height/2,1,1,0);

           cdx = 0;

         }

       }

       if (cdx && err==1) { dx = cdx; ++dy; }

       if (!dx || !dy) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_dlm() : File '%s', invalid DLM file.",pixel_type(),filename?filename:"(FILE*)");

       }

       resize(dx,dy,1,1,0);

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_bmp(const char *const filename) {

       return _load_bmp(0,filename);

     }


     static CImg<T> get_load_bmp(const char *const filename) {

       return CImg<T>().load_bmp(filename);

     }


     CImg<T>& load_bmp(std::FILE *const file) {

       return _load_bmp(file,0);

     }


     static CImg<T> get_load_bmp(std::FILE *const file) {

       return CImg<T>().load_bmp(file);

     }


     CImg<T>& _load_bmp(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_bmp() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       unsigned char header[64] = { 0 };

       cimg::fread(header,54,nfile);

       if (header[0]!='B' || header[1]!='M') {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_bmp() : Invalid valid BMP file (filename '%s').",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       assign();


       // Read header and pixel buffer

       int

         file_size = header[0x02] + (header[0x03]<<8) + (header[0x04]<<16) + (header[0x05]<<24),

         offset = header[0x0A] + (header[0x0B]<<8) + (header[0x0C]<<16) + (header[0x0D]<<24),

         dx = header[0x12] + (header[0x13]<<8) + (header[0x14]<<16) + (header[0x15]<<24),

         dy = header[0x16] + (header[0x17]<<8) + (header[0x18]<<16) + (header[0x19]<<24),

         compression = header[0x1E] + (header[0x1F]<<8) + (header[0x20]<<16) + (header[0x21]<<24),

         nb_colors = header[0x2E] + (header[0x2F]<<8) + (header[0x30]<<16) + (header[0x31]<<24),

         bpp = header[0x1C] + (header[0x1D]<<8),

         *palette = 0;

       const int

         dx_bytes = (bpp==1)?(dx/8+(dx%8?1:0)):((bpp==4)?(dx/2+(dx%2?1:0)):(dx*bpp/8)),

         align = (4-dx_bytes%4)%4,

         buf_size = cimg::min(cimg::abs(dy)*(dx_bytes+align),file_size-offset);


       if (bpp<16) { if (!nb_colors) nb_colors=1<<bpp; } else nb_colors = 0;

       if (nb_colors) { palette = new int[nb_colors]; cimg::fread(palette,nb_colors,nfile); }

       const int xoffset = offset-54-4*nb_colors;

       if (xoffset>0) std::fseek(nfile,xoffset,SEEK_CUR);

       unsigned char *buffer = new unsigned char[buf_size], *ptrs = buffer;

       cimg::fread(buffer,buf_size,nfile);

       if (!file) cimg::fclose(nfile);


       // Decompress buffer (if necessary)

       if (compression) {

         delete[] buffer;

         if (file) {

           throw CImgIOException("CImg<%s>::load_bmp() : Not able to read a compressed BMP file using a *FILE input",

                                 pixel_type());

         } else return load_other(filename);

       }


       // Read pixel data

       assign(dx,cimg::abs(dy),1,3);

       switch (bpp) {

       case 1 : { // Monochrome

         for (int y = dimy()-1; y>=0; --y) {

           unsigned char mask = 0x80, val = 0;

           cimg_forX(*this,x) {

             if (mask==0x80) val = *(ptrs++);

             const unsigned char *col = (unsigned char*)(palette+(val&mask?1:0));

             (*this)(x,y,2) = (T)*(col++);

             (*this)(x,y,1) = (T)*(col++);

             (*this)(x,y,0) = (T)*(col++);

             mask = cimg::ror(mask);

           } ptrs+=align; }

       } break;

       case 4 : { // 16 colors

         for (int y = dimy()-1; y>=0; --y) {

           unsigned char mask = 0xF0, val = 0;

           cimg_forX(*this,x) {

             if (mask==0xF0) val = *(ptrs++);

             const unsigned char color = (unsigned char)((mask<16)?(val&mask):((val&mask)>>4));

             unsigned char *col = (unsigned char*)(palette+color);

             (*this)(x,y,2) = (T)*(col++);

             (*this)(x,y,1) = (T)*(col++);

             (*this)(x,y,0) = (T)*(col++);

             mask = cimg::ror(mask,4);

           } ptrs+=align; }

       } break;

       case 8 : { //  256 colors

         for (int y = dimy()-1; y>=0; --y) { cimg_forX(*this,x) {

           const unsigned char *col = (unsigned char*)(palette+*(ptrs++));

           (*this)(x,y,2) = (T)*(col++);

           (*this)(x,y,1) = (T)*(col++);

           (*this)(x,y,0) = (T)*(col++);

         } ptrs+=align; }

       } break;

       case 16 : { // 16 bits colors

         for (int y = dimy()-1; y>=0; --y) { cimg_forX(*this,x) {

           const unsigned char c1 = *(ptrs++), c2 = *(ptrs++);

           const unsigned short col = (unsigned short)(c1|(c2<<8));

           (*this)(x,y,2) = (T)(col&0x1F);

           (*this)(x,y,1) = (T)((col>>5)&0x1F);

           (*this)(x,y,0) = (T)((col>>10)&0x1F);

         } ptrs+=align; }

       } break;

       case 24 : { // 24 bits colors

         for (int y = dimy()-1; y>=0; --y) { cimg_forX(*this,x) {

           (*this)(x,y,2) = (T)*(ptrs++);

           (*this)(x,y,1) = (T)*(ptrs++);

           (*this)(x,y,0) = (T)*(ptrs++);

         } ptrs+=align; }

       } break;

       case 32 : { // 32 bits colors

         for (int y = dimy()-1; y>=0; --y) { cimg_forX(*this,x) {

           (*this)(x,y,2) = (T)*(ptrs++);

           (*this)(x,y,1) = (T)*(ptrs++);

           (*this)(x,y,0) = (T)*(ptrs++);

           ++ptrs;

         } ptrs+=align; }

       } break;

       }

       if (palette) delete[] palette;

       delete[] buffer;

       if (dy<0) mirror('y');

       return *this;

     }


     CImg<T>& load_jpeg(const char *const filename) {

       return _load_jpeg(0,filename);

     }


     static CImg<T> get_load_jpeg(const char *const filename) {

       return CImg<T>().load_jpeg(filename);

     }


     CImg<T>& load_jpeg(std::FILE *const file) {

       return _load_jpeg(file,0);

     }


     static CImg<T> get_load_jpeg(std::FILE *const file) {

       return CImg<T>().load_jpeg(file);

     }


     CImg<T>& _load_jpeg(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_jpeg() : Cannot load (null) filename.",

                                     pixel_type());

 #ifndef cimg_use_jpeg

       if (file)

         throw CImgIOException("CImg<%s>::load_jpeg() : File '(FILE*)' cannot be read without using libjpeg.",

                               pixel_type());

       else return load_other(filename);

 #else

       struct jpeg_decompress_struct cinfo;

       struct jpeg_error_mgr jerr;

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");


       cinfo.err = jpeg_std_error(&jerr);

       jpeg_create_decompress(&cinfo);

       jpeg_stdio_src(&cinfo,nfile);

       jpeg_read_header(&cinfo,TRUE);

       jpeg_start_decompress(&cinfo);


       if (cinfo.output_components!=1 && cinfo.output_components!=3 && cinfo.output_components!=4) {

         cimg::warn("CImg<%s>::load_jpeg() : Don't know how to read image '%s' with libpeg, trying ImageMagick's convert",

                    pixel_type(),filename?filename:"(FILE*)");

         if (!file) return load_other(filename);

         else {

           if (!file) cimg::fclose(nfile);

           throw CImgIOException("CImg<%s>::load_jpeg() : Cannot read JPEG image '%s' using a *FILE input.",

                                 pixel_type(),filename?filename:"(FILE*)");

         }

       }


       const unsigned int row_stride = cinfo.output_width * cinfo.output_components;

       unsigned char *buf = new unsigned char[cinfo.output_width*cinfo.output_height*cinfo.output_components], *buf2 = buf;

       JSAMPROW row_pointer[1];

       while (cinfo.output_scanline < cinfo.output_height) {

         row_pointer[0] = &buf[cinfo.output_scanline*row_stride];

         jpeg_read_scanlines(&cinfo,row_pointer,1);

       }

       jpeg_finish_decompress(&cinfo);

       jpeg_destroy_decompress(&cinfo);

       if (!file) cimg::fclose(nfile);


       assign(cinfo.output_width,cinfo.output_height,1,cinfo.output_components);

       switch (dim) {

       case 1 : {

         T *ptr_g = data;

         cimg_forXY(*this,x,y) *(ptr_g++) = (T)*(buf2++);

       } break;

       case 3 : {

         T *ptr_r = ptr(0,0,0,0), *ptr_g = ptr(0,0,0,1), *ptr_b = ptr(0,0,0,2);

         cimg_forXY(*this,x,y) {

           *(ptr_r++) = (T)*(buf2++);

           *(ptr_g++) = (T)*(buf2++);

           *(ptr_b++) = (T)*(buf2++);

         }

       } break;

       case 4 : {

         T *ptr_r = ptr(0,0,0,0), *ptr_g = ptr(0,0,0,1),

           *ptr_b = ptr(0,0,0,2), *ptr_a = ptr(0,0,0,3);

         cimg_forXY(*this,x,y) {

           *(ptr_r++) = (T)*(buf2++);

           *(ptr_g++) = (T)*(buf2++);

           *(ptr_b++) = (T)*(buf2++);

           *(ptr_a++) = (T)*(buf2++);

         }

       } break;

       }

       delete[] buf;

       return *this;

 #endif

     }


     // Added April/may 2006 by Christoph Hormann <chris_hormann@gmx.de>

     //   This is experimental code, not much tested, use with care.

     CImg<T>& load_magick(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_magick() : Cannot load (null) filename.",

                                     pixel_type());

 #ifdef cimg_use_magick

       Magick::Image image(filename);

       const unsigned int W = image.size().width(), H = image.size().height();

       switch (image.type()) {

       case Magick::PaletteMatteType :

       case Magick::TrueColorMatteType :

       case Magick::ColorSeparationType : {

         assign(W,H,1,4);

         T *rdata = ptr(0,0,0,0), *gdata = ptr(0,0,0,1), *bdata = ptr(0,0,0,2), *adata = ptr(0,0,0,3);

         Magick::PixelPacket *pixels = image.getPixels(0,0,W,H);

         for (unsigned int off = W*H; off; --off) {

           *(rdata++) = (T)(pixels->red);

           *(gdata++) = (T)(pixels->green);

           *(bdata++) = (T)(pixels->blue);

           *(adata++) = (T)(pixels->opacity);

           ++pixels;

         }

       } break;

       case Magick::PaletteType :

       case Magick::TrueColorType : {

         assign(W,H,1,3);

         T *rdata = ptr(0,0,0,0), *gdata = ptr(0,0,0,1), *bdata = ptr(0,0,0,2);

         Magick::PixelPacket *pixels = image.getPixels(0,0,W,H);

         for (unsigned int off = W*H; off; --off) {

           *(rdata++) = (T)(pixels->red);

           *(gdata++) = (T)(pixels->green);

           *(bdata++) = (T)(pixels->blue);

           ++pixels;

         }

       } break;

       case Magick::GrayscaleMatteType : {

         assign(W,H,1,2);

         T *data = ptr(0,0,0,0), *adata = ptr(0,0,0,1);

         Magick::PixelPacket *pixels = image.getPixels(0,0,W,H);

         for (unsigned int off = W*H; off; --off) {

           *(data++) = (T)(pixels->red);

           *(adata++) = (T)(pixels->opacity);

           ++pixels;

         }

       } break;

       default : {

         assign(W,H,1,1);

         T *data = ptr(0,0,0,0);

         Magick::PixelPacket *pixels = image.getPixels(0,0,W,H);

         for (unsigned int off = W*H; off; --off) {

           *(data++) = (T)(pixels->red);

           ++pixels;

         }

       }

       }

 #else

       throw CImgIOException("CImg<%s>::load_magick() : File '%s', Magick++ library has not been linked.",

                             pixel_type(),filename);

 #endif

       return *this;

     }


     static CImg<T> get_load_magick(const char *const filename) {

       return CImg<T>().load_magick(filename);

     }


     CImg<T>& load_png(const char *const filename) {

       return _load_png(0,filename);

     }


     static CImg<T> get_load_png(const char *const filename) {

       return CImg<T>().load_png(filename);

     }


     CImg<T>& load_png(std::FILE *const file) {

       return _load_png(file,0);

     }


     static CImg<T> get_load_png(std::FILE *const file) {

       return CImg<T>().load_png(file);

     }


     // (Note : Most of this function has been written by Eric Fausett)

     CImg<T>& _load_png(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_png() : Cannot load (null) filename.",

                                     pixel_type());

 #ifndef cimg_use_png

       if (file)

         throw CImgIOException("CImg<%s>::load_png() : File '(FILE*)' cannot be read without using libpng.",

                               pixel_type());

       else return load_other(filename);

 #else

       // Open file and check for PNG validity

       const char *volatile nfilename = filename; // two 'volatile' here to remove a g++ warning due to 'setjmp'.

       std::FILE *volatile nfile = file?file:cimg::fopen(nfilename,"rb");


       unsigned char pngCheck[8] = { 0 };

       cimg::fread(pngCheck,8,(std::FILE*)nfile);

       if (png_sig_cmp(pngCheck,0,8)) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_png() : File '%s' is not a valid PNG file.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }


       // Setup PNG structures for read

       png_voidp user_error_ptr = 0;

       png_error_ptr user_error_fn = 0, user_warning_fn = 0;

       png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,user_error_ptr,user_error_fn,user_warning_fn);

       if (!png_ptr) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', trouble initializing 'png_ptr' data structure.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_infop info_ptr = png_create_info_struct(png_ptr);

       if (!info_ptr) {

         if (!file) cimg::fclose(nfile);

         png_destroy_read_struct(&png_ptr,(png_infopp)0,(png_infopp)0);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', trouble initializing 'info_ptr' data structure.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_infop end_info = png_create_info_struct(png_ptr);

       if (!end_info) {

         if (!file) cimg::fclose(nfile);

         png_destroy_read_struct(&png_ptr,&info_ptr,(png_infopp)0);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', trouble initializing 'end_info' data structure.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }


       // Error handling callback for png file reading

       if (setjmp(png_jmpbuf(png_ptr))) {

         if (!file) cimg::fclose((std::FILE*)nfile);

         png_destroy_read_struct(&png_ptr, &end_info, (png_infopp)0);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', unknown fatal error.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_init_io(png_ptr, nfile);

       png_set_sig_bytes(png_ptr, 8);


       // Get PNG Header Info up to data block

       png_read_info(png_ptr,info_ptr);

       png_uint_32 W, H;

       int bit_depth, color_type, interlace_type;

       png_get_IHDR(png_ptr,info_ptr,&W,&H,&bit_depth,&color_type,&interlace_type,int_p_NULL,int_p_NULL);

       int new_bit_depth = bit_depth;

       int new_color_type = color_type;


       // Transforms to unify image data

       if (new_color_type == PNG_COLOR_TYPE_PALETTE){

         png_set_palette_to_rgb(png_ptr);

         new_color_type -= PNG_COLOR_MASK_PALETTE;

         new_bit_depth = 8;

       }

       if (new_color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8){

         png_set_gray_1_2_4_to_8(png_ptr);

         new_bit_depth = 8;

       }

       if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))

         png_set_tRNS_to_alpha(png_ptr);

       if (new_color_type == PNG_COLOR_TYPE_GRAY || new_color_type == PNG_COLOR_TYPE_GRAY_ALPHA){

         png_set_gray_to_rgb(png_ptr);

         new_color_type |= PNG_COLOR_MASK_COLOR;

       }

       if (new_color_type == PNG_COLOR_TYPE_RGB)

         png_set_filler(png_ptr, 0xffffU, PNG_FILLER_AFTER);

       png_read_update_info(png_ptr,info_ptr);

       if (!(new_bit_depth==8 || new_bit_depth==16)) {

         if (!file) cimg::fclose(nfile);

         png_destroy_read_struct(&png_ptr, &end_info, (png_infopp)0);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', wrong bit coding (bit_depth=%u)",

                               pixel_type(),nfilename?nfilename:"(FILE*)",new_bit_depth);

       }

       const int byte_depth = new_bit_depth>>3;


       // Allocate Memory for Image Read

       png_bytep *imgData = new png_bytep[H];

       for (unsigned int row = 0; row<H; ++row) imgData[row] = new png_byte[byte_depth*4*W];

       png_read_image(png_ptr,imgData);

       png_read_end(png_ptr,end_info);


       // Read pixel data

       if (!(new_color_type==PNG_COLOR_TYPE_RGB || new_color_type==PNG_COLOR_TYPE_RGB_ALPHA)) {

         if (!file) cimg::fclose(nfile);

         png_destroy_read_struct(&png_ptr,&end_info,(png_infopp)0);

         throw CImgIOException("CImg<%s>::load_png() : File '%s', wrong color coding (new_color_type=%u)",

                               pixel_type(),nfilename?nfilename:"(FILE*)",new_color_type);

       }

       const bool no_alpha_channel = (new_color_type==PNG_COLOR_TYPE_RGB);

       assign(W,H,1,no_alpha_channel?3:4);

       T *ptr1 = ptr(0,0,0,0), *ptr2 = ptr(0,0,0,1), *ptr3 = ptr(0,0,0,2), *ptr4 = ptr(0,0,0,3);

       switch (new_bit_depth) {

       case 8 : {

         cimg_forY(*this,y){

           const unsigned char *ptrs = (unsigned char*)imgData[y];

           cimg_forX(*this,x){

             *(ptr1++) = (T)*(ptrs++);

             *(ptr2++) = (T)*(ptrs++);

             *(ptr3++) = (T)*(ptrs++);

             if (no_alpha_channel) ++ptrs; else *(ptr4++) = (T)*(ptrs++);

           }

         }

       } break;

       case 16 : {

         cimg_forY(*this,y){

           const unsigned short *ptrs = (unsigned short*)(imgData[y]);

           if (!cimg::endianness()) cimg::invert_endianness(ptrs,4*width);

           cimg_forX(*this,x){

             *(ptr1++) = (T)*(ptrs++);

             *(ptr2++) = (T)*(ptrs++);

             *(ptr3++) = (T)*(ptrs++);

             if (no_alpha_channel) ++ptrs; else *(ptr4++) = (T)*(ptrs++);

           }

         }

       } break;

       }

       png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);


       // Deallocate Image Read Memory

       cimg_forY(*this,n) delete[] imgData[n];

       delete[] imgData;

       if (!file) cimg::fclose(nfile);

       return *this;

 #endif

     }


     CImg<T>& load_pnm(const char *const filename) {

       return _load_pnm(0,filename);

     }


     static CImg<T> get_load_pnm(const char *const filename) {

       return CImg<T>().load_pnm(filename);

     }


     CImg<T>& load_pnm(std::FILE *const file) {

       return _load_pnm(file,0);

     }


     static CImg<T> get_load_pnm(std::FILE *const file) {

       return CImg<T>().load_pnm(file);

     }


     CImg<T>& _load_pnm(std::FILE *const file, const char *const filename) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_pnm() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       unsigned int ppm_type, W, H, colormax = 255;

       char item[1024] = { 0 };

       int err, rval, gval, bval;

       const int cimg_iobuffer = 12*1024*1024;

       while ((err=std::fscanf(nfile,"%1023[^\n]",item))!=EOF && (item[0]=='#' || !err)) std::fgetc(nfile);

       if (std::sscanf(item," P%u",&ppm_type)!=1) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_pnm() : File '%s', PNM header 'P?' not found.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       while ((err=std::fscanf(nfile," %1023[^\n]",item))!=EOF && (item[0]=='#' || !err)) std::fgetc(nfile);

       if ((err=std::sscanf(item," %u %u %u",&W,&H,&colormax))<2) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_pnm() : File '%s', WIDTH and HEIGHT fields are not defined in PNM header.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       if (err==2) {

         while ((err=std::fscanf(nfile," %1023[^\n]",item))!=EOF && (item[0]=='#' || !err)) std::fgetc(nfile);

         if (std::sscanf(item,"%u",&colormax)!=1)

           cimg::warn("CImg<%s>::load_pnm() : File '%s', COLORMAX field is not defined in PNM header.",

                      pixel_type(),filename?filename:"(FILE*)");

       }

       std::fgetc(nfile);

       assign();


       switch (ppm_type) {

       case 2 : { // Grey Ascii

         assign(W,H,1,1);

         T* rdata = data;

         cimg_foroff(*this,off) { if (std::fscanf(nfile,"%d",&rval)>0) *(rdata++) = (T)rval; else break; }

       } break;

       case 3 : { // Color Ascii

         assign(W,H,1,3);

         T *rdata = ptr(0,0,0,0), *gdata = ptr(0,0,0,1), *bdata = ptr(0,0,0,2);

         cimg_forXY(*this,x,y) {

           if (std::fscanf(nfile,"%d %d %d",&rval,&gval,&bval)==3) { *(rdata++) = (T)rval; *(gdata++) = (T)gval; *(bdata++) = (T)bval; }

           else break;

         }

       } break;

       case 5 : { // Grey Binary

         if (colormax<256) { // 8 bits

           CImg<ucharT> raw;

           assign(W,H,1,1);

           T *ptrd = ptr(0,0,0,0);

           for (int toread = (int)size(); toread>0; ) {

             raw.assign(cimg::min(toread,cimg_iobuffer));

             cimg::fread(raw.data,raw.width,nfile);

             toread-=raw.width;

             const unsigned char *ptrs = raw.data;

             for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++);

           }

         } else { // 16 bits

           CImg<ushortT> raw;

           assign(W,H,1,1);

           T *ptrd = ptr(0,0,0,0);

           for (int toread = (int)size(); toread>0; ) {

             raw.assign(cimg::min(toread,cimg_iobuffer/2));

             cimg::fread(raw.data,raw.width,nfile);

             if (!cimg::endianness()) cimg::invert_endianness(raw.data,raw.width);

             toread-=raw.width;

             const unsigned short *ptrs = raw.data;

             for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++);

           }

         }

       } break;

       case 6 : { // Color Binary

         if (colormax<256) { // 8 bits

           CImg<ucharT> raw;

           assign(W,H,1,3);

           T

             *ptr_r = ptr(0,0,0,0),

             *ptr_g = ptr(0,0,0,1),

             *ptr_b = ptr(0,0,0,2);

           for (int toread = (int)size(); toread>0; ) {

             raw.assign(cimg::min(toread,cimg_iobuffer));

             cimg::fread(raw.data,raw.width,nfile);

             toread-=raw.width;

             const unsigned char *ptrs = raw.data;

             for (unsigned int off = raw.width/3; off; --off) {

               *(ptr_r++) = (T)*(ptrs++);

               *(ptr_g++) = (T)*(ptrs++);

               *(ptr_b++) = (T)*(ptrs++);

             }

           }

         } else { // 16 bits

           CImg<ushortT> raw;

           assign(W,H,1,3);

           T

             *ptr_r = ptr(0,0,0,0),

             *ptr_g = ptr(0,0,0,1),

             *ptr_b = ptr(0,0,0,2);

           for (int toread = (int)size(); toread>0; ) {

             raw.assign(cimg::min(toread,cimg_iobuffer/2));

             cimg::fread(raw.data,raw.width,nfile);

             if (!cimg::endianness()) cimg::invert_endianness(raw.data,raw.width);

             toread-=raw.width;

             const unsigned short *ptrs = raw.data;

             for (unsigned int off = raw.width/3; off; --off) {

               *(ptr_r++) = (T)*(ptrs++);

               *(ptr_g++) = (T)*(ptrs++);

               *(ptr_b++) = (T)*(ptrs++);

             }

           }

         }

       } break;

       default :

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_pnm() : File '%s', PPM type 'P%d' not supported.",

                               pixel_type(),filename?filename:"(FILE*)",ppm_type);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_rgb(const char *const filename, const unsigned int dimw, const unsigned int dimh=1) {

       return _load_rgb(0,filename,dimw,dimh);

     }


     static CImg<T> get_load_rgb(const char *const filename, const unsigned int dimw, const unsigned int dimh=1) {

       return CImg<T>().load_rgb(filename,dimw,dimh);

     }


     CImg<T>& load_rgb(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1) {

       return _load_rgb(file,0,dimw,dimh);

     }


     static CImg<T> get_load_rgb(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1) {

       return CImg<T>().load_rgb(file,dimw,dimh);

     }


     CImg<T>& _load_rgb(std::FILE *const file, const char *const filename, const unsigned int dimw, const unsigned int dimh) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_rgb() : Cannot load (null) filename.",

                                     pixel_type());

       if (!dimw || !dimh) return assign();

       const int cimg_iobuffer = 12*1024*1024;

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       CImg<ucharT> raw;

       assign(dimw,dimh,1,3);

       T

         *ptr_r = ptr(0,0,0,0),

         *ptr_g = ptr(0,0,0,1),

         *ptr_b = ptr(0,0,0,2);

       for (int toread = (int)size(); toread>0; ) {

         raw.assign(cimg::min(toread,cimg_iobuffer));

         cimg::fread(raw.data,raw.width,nfile);

         toread-=raw.width;

         const unsigned char *ptrs = raw.data;

         for (unsigned int off = raw.width/3; off; --off) {

           *(ptr_r++) = (T)*(ptrs++);

           *(ptr_g++) = (T)*(ptrs++);

           *(ptr_b++) = (T)*(ptrs++);

         }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_rgba(const char *const filename, const unsigned int dimw, const unsigned int dimh=1) {

       return _load_rgba(0,filename,dimw,dimh);

     }


     static CImg<T> get_load_rgba(const char *const filename, const unsigned int dimw, const unsigned int dimh=1) {

       return CImg<T>().load_rgba(filename,dimw,dimh);

     }


     CImg<T>& load_rgba(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1) {

       return _load_rgba(file,0,dimw,dimh);

     }


     static CImg<T> get_load_rgba(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1) {

       return CImg<T>().load_rgba(file,dimw,dimh);

     }


     CImg<T>& _load_rgba(std::FILE *const file, const char *const filename, const unsigned int dimw, const unsigned int dimh) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_rgba() : Cannot load (null) filename.",

                                     pixel_type());

       if (!dimw || !dimh) return assign();

       const int cimg_iobuffer = 12*1024*1024;

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       CImg<ucharT> raw;

       assign(dimw,dimh,1,4);

       T

         *ptr_r = ptr(0,0,0,0),

         *ptr_g = ptr(0,0,0,1),

         *ptr_b = ptr(0,0,0,2),

         *ptr_a = ptr(0,0,0,3);

       for (int toread = (int)size(); toread>0; ) {

         raw.assign(cimg::min(toread,cimg_iobuffer));

         cimg::fread(raw.data,raw.width,nfile);

         toread-=raw.width;

         const unsigned char *ptrs = raw.data;

         for (unsigned int off = raw.width/4; off; --off) {

           *(ptr_r++) = (T)*(ptrs++);

           *(ptr_g++) = (T)*(ptrs++);

           *(ptr_b++) = (T)*(ptrs++);

           *(ptr_a++) = (T)*(ptrs++);

         }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_tiff(const char *const filename,

                        const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                        const unsigned int step_frame=1) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_tiff() : Cannot load (null) filename.",

                                     pixel_type());

       const unsigned int

         nfirst_frame = first_frame<last_frame?first_frame:last_frame,

         nstep_frame = step_frame?step_frame:1;

       unsigned int nlast_frame = first_frame<last_frame?last_frame:first_frame;


 #ifndef cimg_use_tiff

       if (nfirst_frame || nlast_frame!=~0U || nstep_frame>1)

         throw CImgArgumentException("CImg<%s>::load_tiff() : File '%s', reading sub-images from a tiff file requires the use of libtiff.\n"

                                     "('cimg_use_tiff' must be defined).",

                                     pixel_type(),filename);

       return load_other(filename);

 #else

       TIFF *tif = TIFFOpen(filename,"r");

       if (tif) {

         unsigned int nb_images = 0;

         do ++nb_images; while (TIFFReadDirectory(tif));

         if (nfirst_frame>=nb_images || (nlast_frame!=~0U && nlast_frame>=nb_images))

           cimg::warn("CImg<%s>::load_tiff() : File '%s' contains %u image(s), specified frame range is [%u,%u] (step %u).",

                      pixel_type(),filename,nb_images,nfirst_frame,nlast_frame,nstep_frame);

         if (nfirst_frame>=nb_images) return assign();

         if (nlast_frame>=nb_images) nlast_frame = nb_images-1;

         TIFFSetDirectory(tif,0);

         CImg<T> frame;

         for (unsigned int l = nfirst_frame; l<=nlast_frame; l+=nstep_frame) {

           frame._load_tiff(tif,l);

           if (l==nfirst_frame) assign(frame.width,frame.height,1+(nlast_frame-nfirst_frame)/nstep_frame,frame.dim);

           if (frame.width>width || frame.height>height || frame.dim>dim)

             resize(cimg::max(frame.width,width),cimg::max(frame.height,height),-100,cimg::max(frame.dim,dim),0);

           draw_image(0,0,(l-nfirst_frame)/nstep_frame,frame);

         }

         TIFFClose(tif);

       } else throw CImgException("CImg<%s>::load_tiff() : File '%s' cannot be opened.",

                                  pixel_type(),filename);

       return *this;

 #endif

     }


     static CImg<T> get_load_tiff(const char *const filename,

                                  const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                  const unsigned int step_frame=1) {

       return CImg<T>().load_tiff(filename,first_frame,last_frame,step_frame);

     }


     // (Original contribution by Jerome Boulanger).

 #ifdef cimg_use_tiff

     CImg<T>& _load_tiff(TIFF *tif, const unsigned int directory) {

       if (!TIFFSetDirectory(tif,directory)) return assign();

       uint16 samplesperpixel, bitspersample;

       uint32 nx,ny;

       const char *const filename = TIFFFileName(tif);

       TIFFGetField(tif,TIFFTAG_IMAGEWIDTH,&nx);

       TIFFGetField(tif,TIFFTAG_IMAGELENGTH,&ny);

       TIFFGetField(tif,TIFFTAG_SAMPLESPERPIXEL,&samplesperpixel);

       if (samplesperpixel!=1 && samplesperpixel!=3 && samplesperpixel!=4) {

         cimg::warn("CImg<%s>::load_tiff() : File '%s', unknow value for tag : TIFFTAG_SAMPLESPERPIXEL, will force it to 1.",

                    pixel_type(),filename);

         samplesperpixel = 1;

       }

       TIFFGetFieldDefaulted(tif,TIFFTAG_BITSPERSAMPLE,&bitspersample);

       assign(nx,ny,1,samplesperpixel);

       if (bitspersample!=8 || !(samplesperpixel==3 || samplesperpixel==4)) {

         uint16 photo, config;

         TIFFGetField(tif,TIFFTAG_PLANARCONFIG,&config);

         TIFFGetField(tif,TIFFTAG_PHOTOMETRIC,&photo);

         if (TIFFIsTiled(tif)) {

           uint32 tw, th;

           TIFFGetField(tif,TIFFTAG_TILEWIDTH,&tw);

           TIFFGetField(tif,TIFFTAG_TILELENGTH,&th);

           if (config==PLANARCONFIG_CONTIG) switch (bitspersample) {

             case 8 : {

               unsigned char *buf = (unsigned char*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int row = 0; row<ny; row+=th)

                   for (unsigned int col = 0; col<nx; col+=tw) {

                     if (TIFFReadTile(tif,buf,col,row,0,0)<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                           pixel_type(),filename);

                     } else {

                       unsigned char *ptr = buf;

                       for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                         for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                           for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                             (*this)(cc,rr,vv) = (T)(float)(ptr[(rr-row)*th*samplesperpixel + (cc-col)*samplesperpixel + vv]);

                     }

                   }

                 _TIFFfree(buf);

               }

             } break;

             case 16 : {

               unsigned short *buf = (unsigned short*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int row = 0; row<ny; row+=th)

                   for (unsigned int col = 0; col<nx; col+=tw) {

                     if (TIFFReadTile(tif,buf,col,row,0,0)<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                           pixel_type(),filename);

                     } else {

                       unsigned short *ptr = buf;

                       for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                         for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                           for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                             (*this)(cc,rr,vv) = (T)(float)(ptr[(rr-row)*th*samplesperpixel + (cc-col)*samplesperpixel + vv]);

                     }

                   }

                 _TIFFfree(buf);

               }

             } break;

             case 32 : {

               float *buf = (float*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int row = 0; row<ny; row+=th)

                   for (unsigned int col = 0; col<nx; col+=tw) {

                     if (TIFFReadTile(tif,buf,col,row,0,0)<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                           pixel_type(),filename);

                     } else {

                       float *ptr = buf;

                       for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                         for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                           for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                             (*this)(cc,rr,vv) = (T)(float)(ptr[(rr-row)*th*samplesperpixel + (cc-col)*samplesperpixel + vv]);

                     }

                   }

                 _TIFFfree(buf);

               }

             } break;

             } else switch (bitspersample) {

             case 8 : {

               unsigned char *buf = (unsigned char*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (unsigned int row = 0; row<ny; row+=th)

                     for (unsigned int col = 0; col<nx; col+=tw) {

                       if (TIFFReadTile(tif,buf,col,row,0,vv)<0) {

                         _TIFFfree(buf); TIFFClose(tif);

                         throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                             pixel_type(),filename);

                       } else {

                         unsigned char *ptr = buf;

                         for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                           for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                             (*this)(cc,rr,vv) = (T)(float)*(ptr++);

                       }

                     }

                 _TIFFfree(buf);

               }

             } break;

             case 16 : {

               unsigned short *buf = (unsigned short*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (unsigned int row = 0; row<ny; row+=th)

                     for (unsigned int col = 0; col<nx; col+=tw) {

                       if (TIFFReadTile(tif,buf,col,row,0,vv)<0) {

                         _TIFFfree(buf); TIFFClose(tif);

                         throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                             pixel_type(),filename);

                       } else {

                         unsigned short *ptr = buf;

                         for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                           for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                             (*this)(cc,rr,vv) = (T)(float)*(ptr++);

                       }

                     }

                 _TIFFfree(buf);

               }

             } break;

             case 32 : {

               float *buf = (float*)_TIFFmalloc(TIFFTileSize(tif));

               if (buf) {

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (unsigned int row = 0; row<ny; row+=th)

                     for (unsigned int col = 0; col<nx; col+=tw) {

                       if (TIFFReadTile(tif,buf,col,row,0,vv)<0) {

                         _TIFFfree(buf); TIFFClose(tif);

                         throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a tile.",

                                             pixel_type(),filename);

                       } else {

                         float *ptr = buf;

                         for (unsigned int rr = row; rr<cimg::min((unsigned int)(row+th),(unsigned int)ny); ++rr)

                           for (unsigned int cc = col; cc<cimg::min((unsigned int)(col+tw),(unsigned int)nx); ++cc)

                             (*this)(cc,rr,vv) = (T)(float)*(ptr++);

                       }

                     }

                 _TIFFfree(buf);

               }

             } break;

             }

         } else {

           if (config==PLANARCONFIG_CONTIG) switch (bitspersample) {

             case 8 : {

               unsigned char *buf = (unsigned char*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (row = 0; row<ny; row+= rowsperstrip) {

                   uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                   tstrip_t strip = TIFFComputeStrip(tif, row, 0);

                   if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                     _TIFFfree(buf); TIFFClose(tif);

                     throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a strip.",

                                         pixel_type(),filename);

                   }

                   unsigned char *ptr = buf;

                   for (unsigned int rr = 0; rr<nrow; ++rr)

                     for (unsigned int cc = 0; cc<nx; ++cc)

                       for (unsigned int vv = 0; vv<samplesperpixel; ++vv) (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                 }

                 _TIFFfree(buf);

               }

             } break;

             case 16 : {

               unsigned short *buf = (unsigned short*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (row = 0; row<ny; row+= rowsperstrip) {

                   uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                   tstrip_t strip = TIFFComputeStrip(tif, row, 0);

                   if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                     _TIFFfree(buf); TIFFClose(tif);

                     throw CImgException("CImg<%s>::load_tiff() : File '%s', error while reading a strip.",

                                         pixel_type(),filename);

                   }

                   unsigned short *ptr = buf;

                   for (unsigned int rr = 0; rr<nrow; ++rr)

                     for (unsigned int cc = 0; cc<nx; ++cc)

                       for (unsigned int vv = 0; vv<samplesperpixel; ++vv) (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                 }

                 _TIFFfree(buf);

               }

             } break;

             case 32 : {

               float *buf = (float*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (row = 0; row<ny; row+= rowsperstrip) {

                   uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                   tstrip_t strip = TIFFComputeStrip(tif, row, 0);

                   if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                     _TIFFfree(buf); TIFFClose(tif);

                     throw CImgException("CImg<%s>::load_tiff() : File '%s', error while reading a strip.",

                                         pixel_type(),filename);

                   }

                   float *ptr = buf;

                   for (unsigned int rr = 0; rr<nrow; ++rr)

                     for (unsigned int cc = 0; cc<nx; ++cc)

                       for (unsigned int vv = 0; vv<samplesperpixel; ++vv) (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                 }

                 _TIFFfree(buf);

               }

             } break;

             } else switch (bitspersample){

             case 8 : {

               unsigned char *buf = (unsigned char*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (row = 0; row<ny; row+= rowsperstrip) {

                     uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                     tstrip_t strip = TIFFComputeStrip(tif, row, vv);

                     if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', an error occure while reading a strip.",

                                           pixel_type(),filename);

                     }

                     unsigned char *ptr = buf;

                     for (unsigned int rr = 0;rr<nrow; ++rr)

                       for (unsigned int cc = 0; cc<nx; ++cc)

                         (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                   }

                 _TIFFfree(buf);

               }

             } break;

             case 16 : {

               unsigned short *buf = (unsigned short*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (row = 0; row<ny; row+= rowsperstrip) {

                     uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                     tstrip_t strip = TIFFComputeStrip(tif, row, vv);

                     if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', error while reading a strip.",

                                           pixel_type(),filename);

                     }

                     unsigned short *ptr = buf;

                     for (unsigned int rr = 0; rr<nrow; ++rr)

                       for (unsigned int cc = 0; cc<nx; ++cc)

                         (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                   }

                 _TIFFfree(buf);

               }

             } break;

             case 32 : {

               float *buf = (float*)_TIFFmalloc(TIFFStripSize(tif));

               if (buf) {

                 uint32 row, rowsperstrip = (uint32)-1;

                 TIFFGetField(tif,TIFFTAG_ROWSPERSTRIP,&rowsperstrip);

                 for (unsigned int vv = 0; vv<samplesperpixel; ++vv)

                   for (row = 0; row<ny; row+= rowsperstrip) {

                     uint32 nrow = (row+rowsperstrip>ny?ny-row:rowsperstrip);

                     tstrip_t strip = TIFFComputeStrip(tif, row, vv);

                     if ((TIFFReadEncodedStrip(tif,strip,buf,-1))<0) {

                       _TIFFfree(buf); TIFFClose(tif);

                       throw CImgException("CImg<%s>::load_tiff() : File '%s', error while reading a strip.",

                                           pixel_type(),filename);

                     }

                     float *ptr = buf;

                     for (unsigned int rr = 0; rr<nrow; ++rr)  for (unsigned int cc = 0; cc<nx; ++cc)

                         (*this)(cc,row+rr,vv) = (T)(float)*(ptr++);

                   }

                 _TIFFfree(buf);

               }

             } break;

             }

         }

       } else {

         uint32* raster = (uint32*)_TIFFmalloc(nx * ny * sizeof (uint32));

         if (!raster) {

           _TIFFfree(raster); TIFFClose(tif);

           throw CImgException("CImg<%s>::load_tiff() : File '%s', not enough memory for buffer allocation.",

                               pixel_type(),filename);

         }

         TIFFReadRGBAImage(tif,nx,ny,raster,0);

         switch (samplesperpixel) {

         case 1 : {

           cimg_forXY(*this,x,y) (*this)(x,y) = (T)(float)((raster[nx*(ny-1-y)+x]+ 128) / 257);

         } break;

         case 3 : {

           cimg_forXY(*this,x,y) {

             (*this)(x,y,0) = (T)(float)TIFFGetR(raster[nx*(ny-1-y)+x]);

             (*this)(x,y,1) = (T)(float)TIFFGetG(raster[nx*(ny-1-y)+x]);

             (*this)(x,y,2) = (T)(float)TIFFGetB(raster[nx*(ny-1-y)+x]);

           }

         } break;

         case 4 : {

           cimg_forXY(*this,x,y) {

             (*this)(x,y,0) = (T)(float)TIFFGetR(raster[nx*(ny-1-y)+x]);

             (*this)(x,y,1) = (T)(float)TIFFGetG(raster[nx*(ny-1-y)+x]);

             (*this)(x,y,2) = (T)(float)TIFFGetB(raster[nx*(ny-1-y)+x]);

             (*this)(x,y,3) = (T)(float)TIFFGetA(raster[nx*(ny-1-y)+x]);

           }

         } break;

         }

         _TIFFfree(raster);

       }

       return *this;

     }

 #endif


     CImg<T>& load_analyze(const char *const filename, float *const voxsize=0) {

       return _load_analyze(0,filename,voxsize);

     }


     static CImg<T> get_load_analyze(const char *const filename, float *const voxsize=0) {

       return CImg<T>().load_analyze(filename,voxsize);

     }


     CImg<T>& load_analyze(std::FILE *const file, float *const voxsize=0) {

       return _load_analyze(file,0,voxsize);

     }


     static CImg<T> get_load_analyze(std::FILE *const file, float *const voxsize=0) {

       return CImg<T>().load_analyze(file,voxsize);

     }


     CImg<T>& _load_analyze(std::FILE *const file, const char *const filename, float *const voxsize=0) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_analyze() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *nfile_header = 0, *nfile = 0;

       if (!file) {

         char body[1024] = { 0 };

         const char *ext = cimg::split_filename(filename,body);

         if (!cimg::strcasecmp(ext,"hdr")) { // File is an Analyze header file.

           nfile_header = cimg::fopen(filename,"rb");

           std::sprintf(body+std::strlen(body),".img");

           nfile = cimg::fopen(body,"rb");

         } else if (!cimg::strcasecmp(ext,"img")) { // File is an Analyze data file.

           nfile = cimg::fopen(filename,"rb");

           std::sprintf(body+std::strlen(body),".hdr");

           nfile_header = cimg::fopen(body,"rb");

         } else nfile_header = nfile = cimg::fopen(filename,"rb"); // File is a Niftii file.

       } else nfile_header = nfile = file; // File is a Niftii file.

       if (!nfile || !nfile_header)

         throw CImgIOException("CImg<%s>::load_analyze() : File '%s', not recognized as an Analyze7.5 or NIFTI file.",

                               pixel_type(),filename?filename:"(FILE*)");


       // Read header.

       bool endian = false;

       unsigned int header_size;

       cimg::fread(&header_size,1,nfile_header);

       if (!header_size)

         throw CImgIOException("CImg<%s>::load_analyze() : File '%s', zero-sized header found.",

                               pixel_type(),filename?filename:"(FILE*)");

       if (header_size>=4096) { endian = true; cimg::invert_endianness(header_size); }

       unsigned char *header = new unsigned char[header_size];

       cimg::fread(header+4,header_size-4,nfile_header);

       if (!file && nfile_header!=nfile) cimg::fclose(nfile_header);

       if (endian) {

         cimg::invert_endianness((short*)(header+40),5);

         cimg::invert_endianness((short*)(header+70),1);

         cimg::invert_endianness((short*)(header+72),1);

         cimg::invert_endianness((float*)(header+76),4);

         cimg::invert_endianness((float*)(header+112),1);

       }

       unsigned short *dim = (unsigned short*)(header+40), dimx = 1, dimy = 1, dimz = 1, dimv = 1;

       if (!dim[0])

         cimg::warn("CImg<%s>::load_analyze() : File '%s', tells that image has zero dimensions.",

                    pixel_type(),filename?filename:"(FILE*)");

       if (dim[0]>4)

         cimg::warn("CImg<%s>::load_analyze() : File '%s', number of image dimension is %u, reading only the 4 first dimensions",

                    pixel_type(),filename?filename:"(FILE*)",dim[0]);

       if (dim[0]>=1) dimx = dim[1];

       if (dim[0]>=2) dimy = dim[2];

       if (dim[0]>=3) dimz = dim[3];

       if (dim[0]>=4) dimv = dim[4];

       float scalefactor = *(float*)(header+112); if (scalefactor==0) scalefactor=1;

       const unsigned short datatype = *(short*)(header+70);

       if (voxsize) {

         const float *vsize = (float*)(header+76);

         voxsize[0] = vsize[1]; voxsize[1] = vsize[2]; voxsize[2] = vsize[3];

       }

       delete[] header;


       // Read pixel data.

       assign(dimx,dimy,dimz,dimv);

       switch (datatype) {

       case 2 : {

         unsigned char *buffer = new unsigned char[dimx*dimy*dimz*dimv];

         cimg::fread(buffer,dimx*dimy*dimz*dimv,nfile);

         cimg_foroff(*this,off) data[off] = (T)(buffer[off]*scalefactor);

         delete[] buffer;

       } break;

       case 4 : {

         short *buffer = new short[dimx*dimy*dimz*dimv];

         cimg::fread(buffer,dimx*dimy*dimz*dimv,nfile);

         if (endian) cimg::invert_endianness(buffer,dimx*dimy*dimz*dimv);

         cimg_foroff(*this,off) data[off] = (T)(buffer[off]*scalefactor);

         delete[] buffer;

       } break;

       case 8 : {

         int *buffer = new int[dimx*dimy*dimz*dimv];

         cimg::fread(buffer,dimx*dimy*dimz*dimv,nfile);

         if (endian) cimg::invert_endianness(buffer,dimx*dimy*dimz*dimv);

         cimg_foroff(*this,off) data[off] = (T)(buffer[off]*scalefactor);

         delete[] buffer;

       } break;

       case 16 : {

         float *buffer = new float[dimx*dimy*dimz*dimv];

         cimg::fread(buffer,dimx*dimy*dimz*dimv,nfile);

         if (endian) cimg::invert_endianness(buffer,dimx*dimy*dimz*dimv);

         cimg_foroff(*this,off) data[off] = (T)(buffer[off]*scalefactor);

         delete[] buffer;

       } break;

       case 64 : {

         double *buffer = new double[dimx*dimy*dimz*dimv];

         cimg::fread(buffer,dimx*dimy*dimz*dimv,nfile);

         if (endian) cimg::invert_endianness(buffer,dimx*dimy*dimz*dimv);

         cimg_foroff(*this,off) data[off] = (T)(buffer[off]*scalefactor);

         delete[] buffer;

       } break;

       default :

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_analyze() : File '%s', cannot read images with 'datatype = %d'",

                               pixel_type(),filename?filename:"(FILE*)",datatype);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_cimg(const char *const filename, const char axis='z', const char align='p') {

       CImgList<T> list;

       list.load_cimg(filename);

       if (list.width==1) return list[0].transfer_to(*this);

       return assign(list.get_append(axis,align));

     }


     static CImg<T> get_load_cimg(const char *const filename, const char axis='z', const char align='p') {

       return CImg<T>().load_cimg(filename,axis,align);

     }


     CImg<T>& load_cimg(std::FILE *const file, const char axis='z', const char align='p') {

       CImgList<T> list;

       list.load_cimg(file);

       if (list.width==1) return list[0].transfer_to(*this);

       return assign(list.get_append(axis,align));

     }


     static CImg<T> get_load_cimg(std::FILE *const file, const char axis='z', const char align='p') {

       return CImg<T>().load_cimg(file,axis,align);

     }


     CImg<T>& load_cimg(const char *const filename,

                        const unsigned int n0, const unsigned int n1,

                        const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                        const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1,

                        const char axis='z', const char align='p') {

       CImgList<T> list;

       list.load_cimg(filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

       if (list.width==1) return list[0].transfer_to(*this);

       return assign(list.get_append(axis,align));

     }


     static CImg<T> get_load_cimg(const char *const filename,

                                  const unsigned int n0, const unsigned int n1,

                                  const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                                  const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1,

                                  const char axis='z', const char align='p') {

       return CImg<T>().load_cimg(filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1,axis,align);

     }


     CImg<T>& load_cimg(std::FILE *const file,

                        const unsigned int n0, const unsigned int n1,

                        const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                        const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1,

                        const char axis='z', const char align='p') {

       CImgList<T> list;

       list.load_cimg(file,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

       if (list.width==1) return list[0].transfer_to(*this);

       return assign(list.get_append(axis,align));

     }


     static CImg<T> get_load_cimg(std::FILE *const file,

                                  const unsigned int n0, const unsigned int n1,

                                  const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                                  const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1,

                                  const char axis='z', const char align='p') {

       return CImg<T>().load_cimg(file,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1,axis,align);

     }


     CImg<T>& load_inr(const char *const filename, float *const voxsize=0) {

       return _load_inr(0,filename,voxsize);

     }


     static CImg<T> get_load_inr(const char *const filename, float *const voxsize=0) {

       return CImg<T>().load_inr(filename,voxsize);

     }


     CImg<T>& load_inr(std::FILE *const file, float *const voxsize=0) {

       return _load_inr(file,0,voxsize);

     }


     static CImg<T> get_load_inr(std::FILE *const file, float *voxsize=0) {

       return CImg<T>().load_inr(file,voxsize);

     }


     // Load an image from an INRIMAGE-4 file (internal).

     static void _load_inr_header(std::FILE *file, int out[8], float *const voxsize) {

       char item[1024] = { 0 }, tmp1[64] = { 0 }, tmp2[64] = { 0 };

       out[0] = std::fscanf(file,"%63s",item);

       out[0] = out[1] = out[2] = out[3] = out[5] = 1; out[4] = out[6] = out[7] = -1;

       if(cimg::strncasecmp(item,"#INRIMAGE-4#{",13)!=0)

         throw CImgIOException("CImg<%s>::load_inr() : File does not appear to be a valid INR file.\n"

                               "(INRIMAGE-4 identifier not found)",

                               pixel_type());

       while (std::fscanf(file," %63[^\n]%*c",item)!=EOF && std::strncmp(item,"##}",3)) {

         std::sscanf(item," XDIM%*[^0-9]%d",out);

         std::sscanf(item," YDIM%*[^0-9]%d",out+1);

         std::sscanf(item," ZDIM%*[^0-9]%d",out+2);

         std::sscanf(item," VDIM%*[^0-9]%d",out+3);

         std::sscanf(item," PIXSIZE%*[^0-9]%d",out+6);

         if (voxsize) {

           std::sscanf(item," VX%*[^0-9.+-]%f",voxsize);

           std::sscanf(item," VY%*[^0-9.+-]%f",voxsize+1);

           std::sscanf(item," VZ%*[^0-9.+-]%f",voxsize+2);

         }

         if (std::sscanf(item," CPU%*[ =]%s",tmp1)) out[7]=cimg::strncasecmp(tmp1,"sun",3)?0:1;

         switch (std::sscanf(item," TYPE%*[ =]%s %s",tmp1,tmp2)) {

         case 0 : break;

         case 2 : out[5] = cimg::strncasecmp(tmp1,"unsigned",8)?1:0; std::strcpy(tmp1,tmp2);

         case 1 :

           if (!cimg::strncasecmp(tmp1,"int",3)   || !cimg::strncasecmp(tmp1,"fixed",5))  out[4] = 0;

           if (!cimg::strncasecmp(tmp1,"float",5) || !cimg::strncasecmp(tmp1,"double",6)) out[4] = 1;

           if (!cimg::strncasecmp(tmp1,"packed",6))                                       out[4] = 2;

           if (out[4]>=0) break;

         default :

           throw CImgIOException("cimg::inr_header_read() : Invalid TYPE '%s'",tmp2);

         }

       }

       if(out[0]<0 || out[1]<0 || out[2]<0 || out[3]<0)

         throw CImgIOException("CImg<%s>::load_inr() : Bad dimensions in .inr file = ( %d , %d , %d , %d )",

                               pixel_type(),out[0],out[1],out[2],out[3]);

       if(out[4]<0 || out[5]<0)

         throw CImgIOException("CImg<%s>::load_inr() : TYPE is not fully defined",

                               pixel_type());

       if(out[6]<0)

         throw CImgIOException("CImg<%s>::load_inr() : PIXSIZE is not fully defined",

                               pixel_type());

       if(out[7]<0)

         throw CImgIOException("CImg<%s>::load_inr() : Big/Little Endian coding type is not defined",

                               pixel_type());

     }


     CImg<T>& _load_inr(std::FILE *const file, const char *const filename, float *const voxsize) {

 #define _cimg_load_inr_case(Tf,sign,pixsize,Ts) \

      if (!loaded && fopt[6]==pixsize && fopt[4]==Tf && fopt[5]==sign) { \

         Ts *xval, *val = new Ts[fopt[0]*fopt[3]]; \

         cimg_forYZ(*this,y,z) { \

             cimg::fread(val,fopt[0]*fopt[3],nfile); \

             if (fopt[7]!=endian) cimg::invert_endianness(val,fopt[0]*fopt[3]); \

             xval = val; cimg_forX(*this,x) cimg_forV(*this,k) (*this)(x,y,z,k) = (T)*(xval++); \

           } \

         delete[] val; \

         loaded = true; \

       }


       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_inr() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       int fopt[8], endian=cimg::endianness()?1:0;

       bool loaded = false;

       if (voxsize) voxsize[0]=voxsize[1]=voxsize[2]=1;

       _load_inr_header(nfile,fopt,voxsize);

       assign(fopt[0],fopt[1],fopt[2],fopt[3]);

       _cimg_load_inr_case(0,0,8, unsigned char);

       _cimg_load_inr_case(0,1,8, char);

       _cimg_load_inr_case(0,0,16,unsigned short);

       _cimg_load_inr_case(0,1,16,short);

       _cimg_load_inr_case(0,0,32,unsigned int);

       _cimg_load_inr_case(0,1,32,int);

       _cimg_load_inr_case(1,0,32,float);

       _cimg_load_inr_case(1,1,32,float);

       _cimg_load_inr_case(1,0,64,double);

       _cimg_load_inr_case(1,1,64,double);

       if (!loaded) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_inr() : File '%s', cannot read images of the type specified in the file",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_pandore(const char *const filename) {

       return _load_pandore(0,filename);

     }


     static CImg<T> get_load_pandore(const char *const filename) {

       return CImg<T>().load_pandore(filename);

     }


     CImg<T>& load_pandore(std::FILE *const file) {

       return _load_pandore(file,0);

     }


     static CImg<T> get_load_pandore(std::FILE *const file) {

       return CImg<T>().load_pandore(file);

     }


     CImg<T>& _load_pandore(std::FILE *const file, const char *const filename) {

 #define __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,ndim,stype) \

         cimg::fread(dims,nbdim,nfile); \

         if (endian) cimg::invert_endianness(dims,nbdim); \

         assign(nwidth,nheight,ndepth,ndim); \

         const unsigned int siz = size(); \

         stype *buffer = new stype[siz]; \

         cimg::fread(buffer,siz,nfile); \

         if (endian) cimg::invert_endianness(buffer,siz); \

         T *ptrd = data; \

         cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++); \

         buffer-=siz; \

         delete[] buffer


 #define _cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype1,stype2,stype3,ltype) { \

         if (sizeof(stype1)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype1); } \

         else if (sizeof(stype2)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype2); } \

         else if (sizeof(stype3)==ltype) { __cimg_load_pandore_case(nbdim,nwidth,nheight,ndepth,dim,stype3); } \

         else throw CImgIOException("CImg<%s>::load_pandore() : File '%s' cannot be read, datatype not supported on this architecture.", \

                                    pixel_type(),filename?filename:"(FILE*)"); }


       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_pandore() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;

       char header[32] = { 0 };

       cimg::fread(header,12,nfile);

       if (cimg::strncasecmp("PANDORE",header,7)) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_pandore() : File '%s' is not a valid PANDORE file, "

                               "(PANDORE identifier not found).",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       unsigned int imageid, dims[8] = { 0 };

       cimg::fread(&imageid,1,nfile);

       const bool endian = (imageid>255);

       if (endian) cimg::invert_endianness(imageid);

       cimg::fread(header,20,nfile);


       switch (imageid) {

       case 2: _cimg_load_pandore_case(2,dims[1],1,1,1,uchar,uchar,uchar,1); break;

       case 3: _cimg_load_pandore_case(2,dims[1],1,1,1,long,int,short,4); break;

       case 4: _cimg_load_pandore_case(2,dims[1],1,1,1,double,float,float,4); break;

       case 5: _cimg_load_pandore_case(3,dims[2],dims[1],1,1,uchar,uchar,uchar,1); break;

       case 6: _cimg_load_pandore_case(3,dims[2],dims[1],1,1,long,int,short,4); break;

       case 7: _cimg_load_pandore_case(3,dims[2],dims[1],1,1,double,float,float,4); break;

       case 8: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],1,uchar,uchar,uchar,1); break;

       case 9: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],1,long,int,short,4); break;

       case 10: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],1,double,float,float,4); break;

       case 11 : { // Region 1D

         cimg::fread(dims,3,nfile);

         if (endian) cimg::invert_endianness(dims,3);

         assign(dims[1],1,1,1);

         const unsigned siz = size();

         if (dims[2]<256) {

           unsigned char *buffer = new unsigned char[siz];

           cimg::fread(buffer,siz,nfile);

           T *ptrd = data;

           cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

           buffer-=siz;

           delete[] buffer;

         } else {

           if (dims[2]<65536) {

             unsigned short *buffer = new unsigned short[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           } else {

             unsigned int *buffer = new unsigned int[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           }

         }

       }

         break;

       case 12 : { // Region 2D

         cimg::fread(dims,4,nfile);

         if (endian) cimg::invert_endianness(dims,4);

         assign(dims[2],dims[1],1,1);

         const unsigned int siz = size();

         if (dims[3]<256) {

           unsigned char *buffer = new unsigned char[siz];

           cimg::fread(buffer,siz,nfile);

           T *ptrd = data;

           cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

           buffer-=siz;

           delete[] buffer;

         } else {

           if (dims[3]<65536) {

             unsigned short *buffer = new unsigned short[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           } else {

             unsigned long *buffer = new unsigned long[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           }

         }

       }

         break;

       case 13 : { // Region 3D

         cimg::fread(dims,5,nfile);

         if (endian) cimg::invert_endianness(dims,5);

         assign(dims[3],dims[2],dims[1],1);

         const unsigned int siz = size();

         if (dims[4]<256) {

           unsigned char *buffer = new unsigned char[siz];

           cimg::fread(buffer,siz,nfile);

           T *ptrd = data;

           cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

           buffer-=siz;

           delete[] buffer;

         } else {

           if (dims[4]<65536) {

             unsigned short *buffer = new unsigned short[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           } else {

             unsigned int *buffer = new unsigned int[siz];

             cimg::fread(buffer,siz,nfile);

             if (endian) cimg::invert_endianness(buffer,siz);

             T *ptrd = data;

             cimg_foroff(*this,off) *(ptrd++) = (T)*(buffer++);

             buffer-=siz;

             delete[] buffer;

           }

         }

       }

         break;

       case 16: _cimg_load_pandore_case(4,dims[2],dims[1],1,3,uchar,uchar,uchar,1); break;

       case 17: _cimg_load_pandore_case(4,dims[2],dims[1],1,3,long,int,short,4); break;

       case 18: _cimg_load_pandore_case(4,dims[2],dims[1],1,3,double,float,float,4); break;

       case 19: _cimg_load_pandore_case(5,dims[3],dims[2],dims[1],3,uchar,uchar,uchar,1); break;

       case 20: _cimg_load_pandore_case(5,dims[3],dims[2],dims[1],3,long,int,short,4); break;

       case 21: _cimg_load_pandore_case(5,dims[3],dims[2],dims[1],3,double,float,float,4); break;

       case 22: _cimg_load_pandore_case(2,dims[1],1,1,dims[0],uchar,uchar,uchar,1); break;

       case 23: _cimg_load_pandore_case(2,dims[1],1,1,dims[0],long,int,short,4);

       case 24: _cimg_load_pandore_case(2,dims[1],1,1,dims[0],ulong,uint,ushort,4); break;

       case 25: _cimg_load_pandore_case(2,dims[1],1,1,dims[0],double,float,float,4); break;

       case 26: _cimg_load_pandore_case(3,dims[2],dims[1],1,dims[0],uchar,uchar,uchar,1); break;

       case 27: _cimg_load_pandore_case(3,dims[2],dims[1],1,dims[0],long,int,short,4); break;

       case 28: _cimg_load_pandore_case(3,dims[2],dims[1],1,dims[0],ulong,uint,ushort,4); break;

       case 29: _cimg_load_pandore_case(3,dims[2],dims[1],1,dims[0],double,float,float,4); break;

       case 30: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],dims[0],uchar,uchar,uchar,1); break;

       case 31: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],dims[0],long,int,short,4); break;

       case 32: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],dims[0],ulong,uint,ushort,4); break;

       case 33: _cimg_load_pandore_case(4,dims[3],dims[2],dims[1],dims[0],double,float,float,4); break;

       case 34 : { // Points 1D

         int ptbuf[4] = { 0 };

         cimg::fread(ptbuf,1,nfile);

         if (endian) cimg::invert_endianness(ptbuf,1);

         assign(1); (*this)(0) = (T)ptbuf[0];

       } break;

       case 35 : { // Points 2D

         int ptbuf[4] = { 0 };

         cimg::fread(ptbuf,2,nfile);

         if (endian) cimg::invert_endianness(ptbuf,2);

         assign(2); (*this)(0) = (T)ptbuf[1]; (*this)(1) = (T)ptbuf[0];

       } break;

       case 36 : { // Points 3D

         int ptbuf[4] = { 0 };

         cimg::fread(ptbuf,3,nfile);

         if (endian) cimg::invert_endianness(ptbuf,3);

         assign(3); (*this)(0) = (T)ptbuf[2]; (*this)(1) = (T)ptbuf[1]; (*this)(2) = (T)ptbuf[0];

       } break;

       default :

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_pandore() : File '%s', cannot read images with ID_type = %u",

                               pixel_type(),filename?filename:"(FILE*)",imageid);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImg<T>& load_parrec(const char *const filename, const char axis='v', const char align='p') {

       CImgList<T> list;

       list.load_parrec(filename);

       if (list.width==1) return list[0].transfer_to(*this);

       return assign(list.get_append(axis,align));

     }


     static CImg<T> get_load_parrec(const char *const filename, const char axis='v', const char align='p') {

       return CImg<T>().load_parrec(filename,axis,align);

     }


     CImg<T>& load_raw(const char *const filename,

                       const unsigned int sizex, const unsigned int sizey=1,

                       const unsigned int sizez=1, const unsigned int sizev=1,

                       const bool multiplexed=false, const bool invert_endianness=false) {

       return _load_raw(0,filename,sizex,sizey,sizez,sizev,multiplexed,invert_endianness);

     }


     static CImg<T> get_load_raw(const char *const filename,

                                 const unsigned int sizex, const unsigned int sizey=1,

                                 const unsigned int sizez=1, const unsigned int sizev=1,

                                 const bool multiplexed=false, const bool invert_endianness=false) {

       return CImg<T>().load_raw(filename,sizex,sizey,sizez,sizev,multiplexed,invert_endianness);

     }


     CImg<T>& load_raw(std::FILE *const file,

                       const unsigned int sizex, const unsigned int sizey=1,

                       const unsigned int sizez=1, const unsigned int sizev=1,

                       const bool multiplexed=false, const bool invert_endianness=false) {

       return _load_raw(file,0,sizex,sizey,sizez,sizev,multiplexed,invert_endianness);

     }


     static CImg<T> get_load_raw(std::FILE *const file,

                                 const unsigned int sizex, const unsigned int sizey=1,

                                 const unsigned int sizez=1, const unsigned int sizev=1,

                                 const bool multiplexed=false, const bool invert_endianness=false) {

       return CImg<T>().load_raw(file,sizex,sizey,sizez,sizev,multiplexed,invert_endianness);

     }


     CImg<T>& _load_raw(std::FILE *const file, const char *const filename,

                        const unsigned int sizex, const unsigned int sizey,

                        const unsigned int sizez, const unsigned int sizev,

                        const bool multiplexed, const bool invert_endianness) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_raw() : Cannot load (null) filename.",

                                     pixel_type());

       assign(sizex,sizey,sizez,sizev,0);

       const unsigned int siz = size();

       if (siz) {

         std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

         if (!multiplexed) {

           cimg::fread(data,siz,nfile);

           if (invert_endianness) cimg::invert_endianness(data,siz);

         }

         else {

           CImg<T> buf(1,1,1,sizev);

           cimg_forXYZ(*this,x,y,z) {

             cimg::fread(buf.data,sizev,nfile);

             if (invert_endianness) cimg::invert_endianness(buf.data,sizev);

             set_vector_at(buf,x,y,z); }

         }

         if (!file) cimg::fclose(nfile);

       }

       return *this;

     }


     CImg<T>& load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                          const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false,

                          const char axis='z', const char align='p') {

       return get_load_ffmpeg(filename,first_frame,last_frame,step_frame,pixel_format,resume,axis,align).transfer_to(*this);

     }


     static CImg<T> get_load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                    const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false,

                                    const char axis='z', const char align='p') {

       return CImgList<T>().load_ffmpeg(filename,first_frame,last_frame,step_frame,pixel_format,resume).get_append(axis,align);

     }


     CImg<T>& load_yuv(const char *const filename,

                       const unsigned int sizex, const unsigned int sizey=1,

                       const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                       const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p') {

       return get_load_yuv(filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb,axis,align).transfer_to(*this);

     }


     static CImg<T> get_load_yuv(const char *const filename,

                                 const unsigned int sizex, const unsigned int sizey=1,

                                 const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                 const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p') {

       return CImgList<T>().load_yuv(filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb).get_append(axis,align);

     }


     CImg<T>& load_yuv(std::FILE *const file,

                       const unsigned int sizex, const unsigned int sizey=1,

                       const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                       const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p') {

       return get_load_yuv(file,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb,axis,align).transfer_to(*this);

     }


     static CImg<T> get_load_yuv(std::FILE *const file,

                                 const unsigned int sizex, const unsigned int sizey=1,

                                 const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                 const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p') {

       return CImgList<T>().load_yuv(file,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb).get_append(axis,align);

     }


     template<typename tf, typename tc>

     CImg<T>& load_off(const char *const filename, CImgList<tf>& primitives, CImgList<tc>& colors) {

       return _load_off(0,filename,primitives,colors);

     }


     template<typename tf, typename tc>

     static CImg<T> get_load_off(const char *const filename, CImgList<tf>& primitives, CImgList<tc>& colors) {

       return CImg<T>().load_off(filename,primitives,colors);

     }


     template<typename tf, typename tc>

     CImg<T>& load_off(std::FILE *const file, CImgList<tf>& primitives, CImgList<tc>& colors) {

       return _load_off(file,0,primitives,colors);

     }


     template<typename tf, typename tc>

     static CImg<T> get_load_off(std::FILE *const file, CImgList<tf>& primitives, CImgList<tc>& colors) {

       return CImg<T>().load_off(file,primitives,colors);

     }


     template<typename tf, typename tc>

     CImg<T>& _load_off(std::FILE *const file, const char *const filename,

                        CImgList<tf>& primitives, CImgList<tc>& colors) {

       if (!filename && !file)

         throw CImgArgumentException("CImg<%s>::load_off() : Cannot load (null) filename.",

                                     pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"r");

       unsigned int nb_points = 0, nb_primitives = 0, nb_read = 0;

       char line[256] = { 0 };

       int err;


       // Skip comments, and read magic string OFF

       do { err = std::fscanf(nfile,"%255[^\n] ",line); } while (!err || (err==1 && line[0]=='#'));

       if (cimg::strncasecmp(line,"OFF",3) && cimg::strncasecmp(line,"COFF",4)) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_off() : File '%s', keyword 'OFF' not found.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       do { err = std::fscanf(nfile,"%255[^\n] ",line); } while (!err || (err==1 && line[0]=='#'));

       if ((err = std::sscanf(line,"%u%u%*[^\n] ",&nb_points,&nb_primitives))!=2) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::load_off() : File '%s', invalid vertices/primitives numbers.",

                               pixel_type(),filename?filename:"(FILE*)");

       }


       // Read points data

       assign(nb_points,3);

       float X = 0, Y = 0, Z = 0;

       cimg_forX(*this,l) {

         do { err = std::fscanf(nfile,"%255[^\n] ",line); } while (!err || (err==1 && line[0]=='#'));

         if ((err = std::sscanf(line,"%f%f%f%*[^\n] ",&X,&Y,&Z))!=3) {

           if (!file) cimg::fclose(nfile);

           throw CImgIOException("CImg<%s>::load_off() : File '%s', cannot read point %u/%u.\n",

                                 pixel_type(),filename?filename:"(FILE*)",l+1,nb_points);

         }

         (*this)(l,0) = (T)X; (*this)(l,1) = (T)Y; (*this)(l,2) = (T)Z;

       }


       // Read primitive data

       primitives.assign();

       colors.assign();

       bool stopflag = false;

       while (!stopflag) {

         float c0 = 0.7f, c1 = 0.7f, c2 = 0.7f;

         unsigned int prim = 0, i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;

         line[0] = 0;

         if ((err = std::fscanf(nfile,"%u",&prim))!=1) stopflag=true;

         else {

           ++nb_read;

           switch (prim) {

           case 1 : {

             if ((err = std::fscanf(nfile,"%u%255[^\n] ",&i0,line))<2) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0).transfer_to(primitives);

               CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255)).transfer_to(colors);

             }

           } break;

           case 2 : {

             if ((err = std::fscanf(nfile,"%u%u%255[^\n] ",&i0,&i1,line))<2) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i1).transfer_to(primitives);

               CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255)).transfer_to(colors);

             }

           } break;

           case 3 : {

             if ((err = std::fscanf(nfile,"%u%u%u%255[^\n] ",&i0,&i1,&i2,line))<3) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i2,i1).transfer_to(primitives);

               CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255)).transfer_to(colors);

             }

           } break;

           case 4 : {

             if ((err = std::fscanf(nfile,"%u%u%u%u%255[^\n] ",&i0,&i1,&i2,&i3,line))<4) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i3,i2,i1).transfer_to(primitives);

               CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255),(tc)(c2*255)).transfer_to(colors);

             }

           } break;

           case 5 : {

             if ((err = std::fscanf(nfile,"%u%u%u%u%u%255[^\n] ",&i0,&i1,&i2,&i3,&i4,line))<5) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i3,i2,i1).transfer_to(primitives);

               CImg<tf>::vector(i0,i4,i3).transfer_to(primitives);

               colors.insert(2,CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255),(tc)(c2*255)));

               ++nb_primitives;

             }

           } break;

           case 6 : {

             if ((err = std::fscanf(nfile,"%u%u%u%u%u%u%255[^\n] ",&i0,&i1,&i2,&i3,&i4,&i5,line))<6) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i3,i2,i1).transfer_to(primitives);

               CImg<tf>::vector(i0,i5,i4,i3).transfer_to(primitives);

               colors.insert(2,CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255),(tc)(c2*255)));

               ++nb_primitives;

             }

           } break;

           case 7 : {

             if ((err = std::fscanf(nfile,"%u%u%u%u%u%u%u%255[^\n] ",&i0,&i1,&i2,&i3,&i4,&i5,&i6,line))<7) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i4,i3,i1).transfer_to(primitives);

               CImg<tf>::vector(i0,i6,i5,i4).transfer_to(primitives);

               CImg<tf>::vector(i3,i2,i1).transfer_to(primitives);

               colors.insert(2,CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255),(tc)(c2*255)));

               ++(++nb_primitives);

             }

           } break;

           case 8 : {

             if ((err = std::fscanf(nfile,"%u%u%u%u%u%u%u%u%255[^\n] ",&i0,&i1,&i2,&i3,&i4,&i5,&i6,&i7,line))<7) {

               cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u.",

                          pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives);

               err = std::fscanf(nfile,"%*[^\n] ");

             } else {

               err = std::sscanf(line,"%f%f%f",&c0,&c1,&c2);

               CImg<tf>::vector(i0,i3,i2,i1).transfer_to(primitives);

               CImg<tf>::vector(i0,i5,i4,i3).transfer_to(primitives);

               CImg<tf>::vector(i0,i7,i6,i5).transfer_to(primitives);

               colors.insert(2,CImg<tc>::vector((tc)(c0*255),(tc)(c1*255),(tc)(c2*255),(tc)(c2*255)));

               ++(++nb_primitives);

             }

           } break;

           default :

             cimg::warn("CImg<%s>::load_off() : File '%s', invalid primitive %u/%u (%u vertices).",

                        pixel_type(),filename?filename:"(FILE*)",nb_read,nb_primitives,prim);

             err = std::fscanf(nfile,"%*[^\n] ");

           }

         }

       }

       if (!file) cimg::fclose(nfile);

       if (primitives.width!=nb_primitives)

         cimg::warn("CImg<%s>::load_off() : File '%s', read only %u primitives instead of %u as claimed in the header.",

                    pixel_type(),filename?filename:"(FILE*)",primitives.width,nb_primitives);

       return *this;

     }


     CImg<T>& load_ffmpeg_external(const char *const filename, const char axis='z', const char align='p') {

       return get_load_ffmpeg_external(filename,axis,align).transfer_to(*this);

     }


     static CImg<T> get_load_ffmpeg_external(const char *const filename, const char axis='z', const char align='p') {

       return CImgList<T>().load_ffmpeg_external(filename).get_append(axis,align);

     }


     CImg<T>& load_graphicsmagick_external(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_graphicsmagick_external() : Cannot load (null) filename.",

                                     pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 };

       std::FILE *file = 0;

 #if cimg_OS==1

       std::sprintf(command,"%s convert \"%s\" ppm:-",cimg::graphicsmagick_path(),filename);

       file = popen(command,"r");

       if (file) { load_pnm(file); pclose(file); return *this; }

 #endif

       do {

         std::sprintf(filetmp,"%s%c%s.ppm",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s convert \"%s\" %s",cimg::graphicsmagick_path(),filename,filetmp);

       cimg::system(command,cimg::graphicsmagick_path());

       if (!(file = std::fopen(filetmp,"rb"))) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::load_graphicsmagick_external() : Failed to open image '%s'.\n\n"

                               "Path of 'GraphicsMagick's gm' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"",

                               pixel_type(),filename,cimg::graphicsmagick_path(),filetmp);

       } else cimg::fclose(file);

       load_pnm(filetmp);

       std::remove(filetmp);

       return *this;

     }


     static CImg<T> get_load_graphicsmagick_external(const char *const filename) {

       return CImg<T>().load_graphicsmagick_external(filename);

     }


     CImg<T>& load_gzip_external(const char *const filename) {

       if (!filename)

         throw CImgIOException("CImg<%s>::load_gzip_external() : Cannot load (null) filename.",

                               pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       const char

         *ext = cimg::split_filename(filename,body),

         *ext2 = cimg::split_filename(body,0);

       std::FILE *file = 0;

       do {

         if (!cimg::strcasecmp(ext,"gz")) {

           if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);

           else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         } else {

           if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);

           else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         }

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s -c \"%s\" > %s",cimg::gunzip_path(),filename,filetmp);

       cimg::system(command);

       if (!(file = std::fopen(filetmp,"rb"))) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::load_gzip_external() : File '%s' cannot be opened.",

                               pixel_type(),filename);

       } else cimg::fclose(file);

       load(filetmp);

       std::remove(filetmp);

       return *this;

     }


     static CImg<T> get_load_gzip_external(const char *const filename) {

       return CImg<T>().load_gzip_external(filename);

     }


     CImg<T>& load_imagemagick_external(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_imagemagick_external() : Cannot load (null) filename.",

                                     pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 };

       std::FILE *file = 0;

 #if cimg_OS==1

       std::sprintf(command,"%s \"%s\" ppm:-",cimg::imagemagick_path(),filename);

       file = popen(command,"r");

       if (file) { load_pnm(file); pclose(file); return *this; }

 #endif

       do {

         std::sprintf(filetmp,"%s%c%s.ppm",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s \"%s\" %s",cimg::imagemagick_path(),filename,filetmp);

       cimg::system(command,cimg::imagemagick_path());

       if (!(file = std::fopen(filetmp,"rb"))) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::load_imagemagick_external() : Failed to open image '%s'.\n\n"

                               "Path of 'ImageMagick's convert' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"",

                               pixel_type(),filename,cimg::imagemagick_path(),filetmp);

       } else cimg::fclose(file);

       load_pnm(filetmp);

       std::remove(filetmp);

       return *this;

     }


     static CImg<T> get_load_imagemagick_external(const char *const filename) {

       return CImg<T>().load_imagemagick_external(filename);

     }


     CImg<T>& load_medcon_external(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_medcon_external() : Cannot load (null) filename.",

                                     pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       cimg::fclose(cimg::fopen(filename,"r"));

       std::FILE *file = 0;

       do {

         std::sprintf(filetmp,"%s.hdr",cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s -w -c anlz -o %s -f %s",cimg::medcon_path(),filetmp,filename);

       cimg::system(command);

       cimg::split_filename(filetmp,body);

       std::sprintf(command,"m000-%s.hdr",body);

       file = std::fopen(command,"rb");

       if (!file) {

         throw CImgIOException("CImg<%s>::load_medcon_external() : Failed to open image '%s'.\n\n"

                               "Path of 'medcon' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"",

                               pixel_type(),filename,cimg::medcon_path(),filetmp);

       } else cimg::fclose(file);

       load_analyze(command);

       std::remove(command);

       std::sprintf(command,"m000-%s.img",body);

       std::remove(command);

       return *this;

     }


     static CImg<T> get_load_medcon_external(const char *const filename) {

       return CImg<T>().load_medcon_external(filename);

     }


     CImg<T>& load_dcraw_external(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_dcraw_external() : Cannot load (null) filename.",

                                     pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 };

       std::FILE *file = 0;

 #if cimg_OS==1

       std::sprintf(command,"%s -4 -c \"%s\"",cimg::dcraw_path(),filename);

       file = popen(command,"r");

       if (file) { load_pnm(file); pclose(file); return *this; }

 #endif

       do {

         std::sprintf(filetmp,"%s%c%s.ppm",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s -4 -c \"%s\" > %s",cimg::dcraw_path(),filename,filetmp);

       cimg::system(command,cimg::dcraw_path());

       if (!(file = std::fopen(filetmp,"rb"))) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::load_dcraw_external() : Failed to open image '%s'.\n\n"

                               "Path of 'dcraw' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"",

                               pixel_type(),filename,cimg::dcraw_path(),filetmp);

       } else cimg::fclose(file);

       load_pnm(filetmp);

       std::remove(filetmp);

       return *this;

     }


     static CImg<T> get_load_dcraw_external(const char *const filename) {

       return CImg<T>().load_dcraw_external(filename);

     }


     CImg<T>& load_other(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImg<%s>::load_other() : Cannot load (null) filename.",

                                     pixel_type());

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       try { load_magick(filename); }

       catch (CImgException&) {

         try { load_imagemagick_external(filename); }

         catch (CImgException&) {

           try { load_graphicsmagick_external(filename); }

           catch (CImgException&) {

             assign();

           }

         }

       }

       cimg::exception_mode() = omode;

       if (is_empty())

         throw CImgIOException("CImg<%s>::load_other() : File '%s' cannot be opened.",

                               pixel_type(),filename);

       return *this;

     }


     static CImg<T> get_load_other(const char *const filename) {

       return CImg<T>().load_other(filename);

     }


     //---------------------------

     //


     //---------------------------


     const CImg<T>& print(const char *title=0, const bool display_stats=true) const {

       int xm = 0, ym = 0, zm = 0, vm = 0, xM = 0, yM = 0, zM = 0, vM = 0;

       static CImg<doubleT> st;

       if (!is_empty() && display_stats) {

         st = get_stats();

         xm = (int)st[4]; ym = (int)st[5], zm = (int)st[6], vm = (int)st[7];

         xM = (int)st[8]; yM = (int)st[9], zM = (int)st[10], vM = (int)st[11];

       }

       const unsigned int siz = size(), msiz = siz*sizeof(T), siz1 = siz-1;

       const unsigned int mdisp = msiz<8*1024?0:(msiz<8*1024*1024?1:2), width1 = width-1;

       char ntitle[64] = { 0 };

       if (!title) std::sprintf(ntitle,"CImg<%s>",pixel_type());

       std::fprintf(cimg_stdout,"%s: this = %p, size = (%u,%u,%u,%u) [%u %s], data = (%s*)%p..%p (%s) = [ ",

                    title?title:ntitle,(void*)this,width,height,depth,dim,

                    mdisp==0?msiz:(mdisp==1?(msiz>>10):(msiz>>20)),

                    mdisp==0?"b":(mdisp==1?"Kb":"Mb"),

                    pixel_type(),(void*)begin(),(void*)((char*)end()-1),

                    is_shared?"shared":"not shared");

       if (!is_empty()) cimg_foroff(*this,off) {

         std::fprintf(cimg_stdout,cimg::type<T>::format(),cimg::type<T>::format(data[off]));

         if (off!=siz1) std::fprintf(cimg_stdout,"%s",off%width==width1?" ; ":" ");

         if (off==7 && siz>16) { off = siz1-8; if (off!=7) std::fprintf(cimg_stdout,"... "); }

       }

       if (!is_empty() && display_stats)

         std::fprintf(cimg_stdout," ], min = %g, max = %g, mean = %g, std = %g, coords(min) = (%u,%u,%u,%u), coords(max) = (%u,%u,%u,%u).\n",

                      st[0],st[1],st[2],std::sqrt(st[3]),xm,ym,zm,vm,xM,yM,zM,vM);

       else std::fprintf(cimg_stdout,"%s].\n",is_empty()?"":" ");

       return *this;

     }


     const CImg<T>& display(CImgDisplay& disp) const {

       disp.display(*this);

       return *this;

     }


     const CImg<T>& display(CImgDisplay &disp, const bool display_info) const {

       return _display(disp,0,display_info);

     }


     const CImg<T>& display(const char *const title=0, const bool display_info=true) const {

       CImgDisplay disp;

       return _display(disp,title,display_info);

     }


     const CImg<T>& _display(CImgDisplay &disp, const char *const title, const bool display_info) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::display() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       unsigned int oldw = 0, oldh = 0, XYZ[3], key = 0, mkey = 0;

       int x0 = 0, y0 = 0, z0 = 0, x1 = dimx()-1, y1 = dimy()-1, z1 = dimz()-1;

       float frametiming = 5;


       char ntitle[256] = { 0 };

       if (!disp) {

         if (!title) std::sprintf(ntitle,"CImg<%s> (%ux%ux%ux%u)",pixel_type(),width,height,depth,dim);

         disp.assign(cimg_fitscreen(width,height,depth),title?title:ntitle,1);

       }

       std::strncpy(ntitle,disp.title,255);

       if (display_info) print(ntitle);


       CImg<T> zoom;

       for (bool reset_view = true, resize_disp = false; !key && !disp.is_closed; ) {

         if (reset_view) {

           XYZ[0] = (x0 + x1)/2; XYZ[1] = (y0 + y1)/2; XYZ[2] = (z0 + z1)/2;

           x0 = 0; y0 = 0; z0 = 0; x1 = width-1; y1 = height-1; z1 = depth-1;

           oldw = disp.width; oldh = disp.height;

           reset_view = false;

         }

         if (!x0 && !y0 && !z0 && x1==dimx()-1 && y1==dimy()-1 && z1==dimz()-1) zoom.assign();

         else zoom = get_crop(x0,y0,z0,x1,y1,z1);


         const unsigned int

           dx = 1 + x1 - x0, dy = 1 + y1 - y0, dz = 1 + z1 - z0,

           tw = dx + (dz>1?dz:0), th = dy + (dz>1?dz:0);

         if (resize_disp) {

           const unsigned int

             ttw = tw*disp.width/oldw, tth = th*disp.height/oldh,

             dM = cimg::max(ttw,tth), diM = cimg::max(disp.width,disp.height),

             imgw = cimg::max(16U,ttw*diM/dM), imgh = cimg::max(16U,tth*diM/dM);

           disp.normalscreen().resize(cimg_fitscreen(imgw,imgh,1),false);

           resize_disp = false;

         }

         oldw = tw; oldh = th;


         bool

           go_up = false, go_down = false, go_left = false, go_right = false,

           go_inc = false, go_dec = false, go_in = false, go_out = false,

           go_in_center = false;

         const CImg<T>& visu = zoom?zoom:*this;

         const CImg<intT> selection = visu._get_select(disp,0,2,XYZ,0,x0,y0,z0);

         if (disp.wheel) {

           if (disp.is_keyCTRLLEFT) { if (!mkey || mkey==1) go_out = !(go_in = disp.wheel>0); go_in_center = false; mkey = 1; }

           else if (disp.is_keySHIFTLEFT) { if (!mkey || mkey==2) go_right = !(go_left = disp.wheel>0); mkey = 2; }

           else if (disp.is_keyALT || depth==1) { if (!mkey || mkey==3) go_down = !(go_up = disp.wheel>0); mkey = 3; }

           else mkey = 0;

           disp.wheel = 0;

         } else mkey = 0;

         const int

           sx0 = selection(0), sy0 = selection(1), sz0 = selection(2),

           sx1 = selection(3), sy1 = selection(4), sz1 = selection(5);

         if (sx0>=0 && sy0>=0 && sz0>=0 && sx1>=0 && sy1>=0 && sz1>=0) {

           x1 = x0 + sx1; y1 = y0 + sy1; z1 = z0 + sz1; x0+=sx0; y0+=sy0; z0+=sz0;

           if (sx0==sx1 && sy0==sy1 && sz0==sz1) reset_view = true;

           resize_disp = true;

         } else switch (key = disp.key) {

         case 0 : case cimg::keyCTRLLEFT : case cimg::keyPAD5 : case cimg::keySHIFTLEFT : case cimg::keyALT : disp.key = key = 0; break;

         case cimg::keyP : if (visu.depth>1 && disp.is_keyCTRLLEFT) { // Special mode : play stack of frames

           const unsigned int

             w1 = visu.width*disp.width/(visu.width+(visu.depth>1?visu.depth:0)),

             h1 = visu.height*disp.height/(visu.height+(visu.depth>1?visu.depth:0));

           disp.resize(cimg_fitscreen(w1,h1,1),false).key = disp.wheel = key = 0;

           for (unsigned int timer = 0; !key && !disp.is_closed && !disp.button; ) {

             if (disp.is_resized) disp.resize(false);

             if (!timer) {

               visu.get_slice(XYZ[2]).display(disp.set_title("%s | z=%d",ntitle,XYZ[2]));

               if (++XYZ[2]>=visu.depth) XYZ[2] = 0;

             }

             if (++timer>(unsigned int)frametiming) timer = 0;

             if (disp.wheel) { frametiming-=disp.wheel/3.0f; disp.wheel = 0; }

             switch (key = disp.key) {

             case 0 : case cimg::keyCTRLLEFT : disp.key = key = 0; break;

             case cimg::keyPAGEUP : frametiming-=0.3f; key = 0; break;

             case cimg::keyPAGEDOWN : frametiming+=0.3f; key = 0; break;

             case cimg::keyD : if (disp.is_keyCTRLLEFT) {

               disp.normalscreen().resize(CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,false),

                                          CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,true),false);

               disp.key = key = 0;

             } break;

             case cimg::keyC : if (disp.is_keyCTRLLEFT) {

               disp.normalscreen().resize(cimg_fitscreen(2*disp.width/3,2*disp.height/3,1),false);

               disp.key = key = 0;

             } break;

             case cimg::keyR : if (disp.is_keyCTRLLEFT) {

               disp.normalscreen().resize(cimg_fitscreen(width,height,depth),false);

               disp.key = key = 0;

             } break;

             case cimg::keyF : if (disp.is_keyCTRLLEFT)

               disp.resize(disp.screen_dimx(),disp.screen_dimy(),false).toggle_fullscreen().key = key = 0;

               break;

             }

             frametiming = frametiming<1?1:(frametiming>39?39:frametiming);

             disp.wait(20);

           }

           const unsigned int

             w2 = (visu.width + (visu.depth>1?visu.depth:0))*disp.width/visu.width,

             h2 = (visu.height + (visu.depth>1?visu.depth:0))*disp.height/visu.height;

           disp.resize(cimg_fitscreen(w2,h2,1),false).set_title(ntitle);

           key = disp.key = disp.button = disp.wheel = 0;

         } break;

         case cimg::keyHOME : case cimg::keyBACKSPACE : reset_view = resize_disp = true; key = 0; break;

         case cimg::keyPADADD : go_in = true; go_in_center = true; key = 0; break;

         case cimg::keyPADSUB : go_out = true; key = 0; break;

         case cimg::keyARROWLEFT : case cimg::keyPAD4: go_left = true; key = 0; break;

         case cimg::keyARROWRIGHT : case cimg::keyPAD6: go_right = true; key = 0; break;

         case cimg::keyARROWUP : case cimg::keyPAD8: go_up = true; key = 0; break;

         case cimg::keyARROWDOWN : case cimg::keyPAD2: go_down = true; key = 0; break;

         case cimg::keyPAD7 : go_up = go_left = true; key = 0; break;

         case cimg::keyPAD9 : go_up = go_right = true; key = 0; break;

         case cimg::keyPAD1 : go_down = go_left = true; key = 0; break;

         case cimg::keyPAD3 : go_down = go_right = true; key = 0; break;

         case cimg::keyPAGEUP : go_inc = true; key = 0; break;

         case cimg::keyPAGEDOWN : go_dec = true; key = 0; break;

         }

         if (go_in) {

           const int

             mx = go_in_center?disp.dimx()/2:disp.mouse_x,

             my = go_in_center?disp.dimy()/2:disp.mouse_y,

             mX = mx*(width+(depth>1?depth:0))/disp.width,

             mY = my*(height+(depth>1?depth:0))/disp.height;

           int X = XYZ[0], Y = XYZ[1], Z = XYZ[2];

           if (mX<dimx() && mY<dimy())  { X = x0 + mX*(1+x1-x0)/width; Y = y0 + mY*(1+y1-y0)/height; Z = XYZ[2]; }

           if (mX<dimx() && mY>=dimy()) { X = x0 + mX*(1+x1-x0)/width; Z = z0 + (mY-height)*(1+z1-z0)/depth; Y = XYZ[1]; }

           if (mX>=dimx() && mY<dimy()) { Y = y0 + mY*(1+y1-y0)/height; Z = z0 + (mX-width)*(1+z1-z0)/depth; X = XYZ[0]; }

           if (x1-x0>4) { x0 = X - 7*(X-x0)/8; x1 = X + 7*(x1-X)/8; }

           if (y1-y0>4) { y0 = Y - 7*(Y-y0)/8; y1 = Y + 7*(y1-Y)/8; }

           if (z1-z0>4) { z0 = Z - 7*(Z-z0)/8; z1 = Z + 7*(z1-Z)/8; }

         }

         if (go_out) {

           const int

             deltax = (x1-x0)/8, deltay = (y1-y0)/8, deltaz = (z1-z0)/8,

             ndeltax = deltax?deltax:(width>1?1:0),

             ndeltay = deltay?deltay:(height>1?1:0),

             ndeltaz = deltaz?deltaz:(depth>1?1:0);

           x0-=ndeltax; y0-=ndeltay; z0-=ndeltaz;

           x1+=ndeltax; y1+=ndeltay; z1+=ndeltaz;

           if (x0<0) { x1-=x0; x0 = 0; if (x1>=dimx()) x1 = dimx()-1; }

           if (y0<0) { y1-=y0; y0 = 0; if (y1>=dimy()) y1 = dimy()-1; }

           if (z0<0) { z1-=z0; z0 = 0; if (z1>=dimz()) z1 = dimz()-1; }

           if (x1>=dimx()) { x0-=(x1-dimx()+1); x1 = dimx()-1; if (x0<0) x0 = 0; }

           if (y1>=dimy()) { y0-=(y1-dimy()+1); y1 = dimy()-1; if (y0<0) y0 = 0; }

           if (z1>=dimz()) { z0-=(z1-dimz()+1); z1 = dimz()-1; if (z0<0) z0 = 0; }

         }

         if (go_left) {

           const int delta = (x1-x0)/5, ndelta = delta?delta:(width>1?1:0);

           if (x0-ndelta>=0) { x0-=ndelta; x1-=ndelta; }

           else { x1-=x0; x0 = 0; }

         }

         if (go_right) {

           const int delta = (x1-x0)/5, ndelta = delta?delta:(width>1?1:0);

           if (x1+ndelta<dimx()) { x0+=ndelta; x1+=ndelta; }

           else { x0+=(dimx()-1-x1); x1 = dimx()-1; }

         }

         if (go_up) {

           const int delta = (y1-y0)/5, ndelta = delta?delta:(height>1?1:0);

           if (y0-ndelta>=0) { y0-=ndelta; y1-=ndelta; }

           else { y1-=y0; y0 = 0; }

         }

         if (go_down) {

           const int delta = (y1-y0)/5, ndelta = delta?delta:(height>1?1:0);

           if (y1+ndelta<dimy()) { y0+=ndelta; y1+=ndelta; }

           else { y0+=(dimy()-1-y1); y1 = dimy()-1; }

         }

         if (go_inc) {

           const int delta = (z1-z0)/5, ndelta = delta?delta:(depth>1?1:0);

           if (z0-ndelta>=0) { z0-=ndelta; z1-=ndelta; }

           else { z1-=z0; z0 = 0; }

         }

         if (go_dec) {

           const int delta = (z1-z0)/5, ndelta = delta?delta:(depth>1?1:0);

           if (z1+ndelta<dimz()) { z0+=ndelta; z1+=ndelta; }

           else { z0+=(depth-1-z1); z1 = depth-1; }

         }

       }

       disp.key = key;

       return *this;

     }


     template<typename tp, typename tf, typename tc, typename to>

     const CImg<T>& display_object3d(CImgDisplay& disp,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const CImgList<tc>& colors,

                                     const to& opacities,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return _display_object3d(disp,0,vertices,primitives,colors,opacities,centering,render_static,

                                render_motion,double_sided,focale,specular_light,specular_shine,

                                display_axes,pose_matrix);

     }


     template<typename tp, typename tf, typename tc, typename to>

     const CImg<T>& display_object3d(const char *const title,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const CImgList<tc>& colors,

                                     const to& opacities,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       CImgDisplay disp;

       return _display_object3d(disp,title,vertices,primitives,colors,opacities,centering,render_static,

                                render_motion,double_sided,focale,specular_light,specular_shine,

                                display_axes,pose_matrix);

     }


     template<typename tp, typename tf, typename tc>

     const CImg<T>& display_object3d(CImgDisplay &disp,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const CImgList<tc>& colors,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(disp,vertices,primitives,colors,CImgList<floatT>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp, typename tf, typename tc>

     const CImg<T>& display_object3d(const char *const title,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const CImgList<tc>& colors,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(title,vertices,primitives,colors,CImgList<floatT>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp, typename tf>

     const CImg<T>& display_object3d(CImgDisplay &disp,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(disp,vertices,primitives,CImgList<T>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp, typename tf>

     const CImg<T>& display_object3d(const char *const title,

                                     const CImg<tp>& vertices,

                                     const CImgList<tf>& primitives,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(title,vertices,primitives,CImgList<T>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp>

     const CImg<T>& display_object3d(CImgDisplay &disp,

                                     const CImg<tp>& vertices,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(disp,vertices,CImgList<uintT>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp>

     const CImg<T>& display_object3d(const char *const title,

                                     const CImg<tp>& vertices,

                                     const bool centering=true,

                                     const int render_static=4, const int render_motion=1,

                                     const bool double_sided=true, const float focale=500,

                                     const float specular_light=0.2f, const float specular_shine=0.1f,

                                     const bool display_axes=true, float *const pose_matrix=0) const {

       return display_object3d(title,vertices,CImgList<uintT>(),centering,

                               render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                               display_axes,pose_matrix);

     }


     template<typename tp, typename tf, typename tc, typename to>

     const CImg<T>& _display_object3d(CImgDisplay& disp, const char *const title,

                                      const CImg<tp>& vertices,

                                      const CImgList<tf>& primitives,

                                      const CImgList<tc>& colors,

                                      const to& opacities,

                                      const bool centering,

                                      const int render_static, const int render_motion,

                                      const bool double_sided, const float focale,

                                      const float specular_light, const float specular_shine,

                                      const bool display_axes, float *const pose_matrix) const {


       // Check input arguments

       if (is_empty()) {

         if (disp) return CImg<T>(disp.width,disp.height,1,colors[0].size(),0).

                     _display_object3d(disp,title,vertices,primitives,colors,opacities,centering,

                                      render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                                      display_axes,pose_matrix);

         else return CImg<T>(cimg_fitscreen(640,480,1),1,colors?colors[0].size():3,0).

                _display_object3d(disp,title,vertices,primitives,colors,opacities,centering,

                                  render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                                  display_axes,pose_matrix);

       }

       vertices.is_object3d(primitives,true,true);

       if (vertices.width && !primitives) {

         CImgList<tf> nprimitives(vertices.width,1,1,1,1);

         cimglist_for(nprimitives,l) nprimitives(l,0) = l;

         return _display_object3d(disp,title,vertices,nprimitives,colors,opacities,centering,

                                  render_static,render_motion,double_sided,focale,specular_light,specular_shine,

                                  display_axes,pose_matrix);

       }

       if (!disp) {

         char ntitle[256] = { 0 };

         if (!title) { std::sprintf(ntitle,"CImg<%s> (%u vertices, %u primitives)",pixel_type(),vertices.width,primitives.width); }

         disp.assign(cimg_fitscreen(width,height,depth),title?title:ntitle,1);

       }


       CImgList<tc> _colors;

       if (!colors) _colors.insert(primitives.width,CImg<tc>::vector(200,200,200));

       const CImgList<tc> &ncolors = colors?colors:_colors;


       // Init 3D objects and compute object statistics

       CImg<floatT>

         pose, rot_mat, zbuffer(disp.width,disp.height,1,1,0),

         centered_vertices = centering?CImg<floatT>(vertices.width,3):CImg<floatT>(),

         rotated_vertices(vertices.width,3),

         bbox_vertices, rotated_bbox_vertices,

         axes_vertices, rotated_axes_vertices,

         bbox_opacities, axes_opacities;

       CImgList<uintT> bbox_primitives, axes_primitives;

       CImgList<T> bbox_colors, bbox_colors2, axes_colors;

       float dx = 0, dy = 0, dz = 0, ratio = 1;


       T minval = (T)0, maxval = (T)255;

       if (disp.normalization && colors) {

         minval = colors.minmax(maxval);

         if (minval==maxval) { minval = (T)0; maxval = (T)255; }

       }

       unsigned int ns_width = 0, ns_height = 0;

       const float meanval = (float)mean();

       bool color_model = true;

       if (cimg::abs(meanval-minval)>cimg::abs(meanval-maxval)) color_model = false;

       const CImg<T>

         background_color(1,1,1,dim,color_model?minval:maxval),

         foreground_color(1,1,1,dim,color_model?maxval:minval);


       float xm = cimg::type<float>::max(), xM = 0, ym = xm, yM = 0, zm = xm, zM = 0;

       cimg_forX(vertices,i) {

         const float x = (float)vertices(i,0), y = (float)vertices(i,1), z = (float)vertices(i,2);

         if (x<xm) xm = x;

         if (x>xM) xM = x;

         if (y<ym) ym = y;

         if (y>yM) yM = y;

         if (z<zm) zm = z;

         if (z>zM) zM = z;

       }

       const float delta = cimg::max(xM-xm,yM-ym,zM-zm);


       if (display_axes) {

         rotated_axes_vertices = axes_vertices.assign(7,3,1,1,

                                                      0,20,0,0,22,-6,-6,

                                                      0,0,20,0,-6,22,-6,

                                                      0,0,0,20,0,0,22);

         axes_opacities.assign(3,1,1,1,1);

         axes_colors.assign(3,dim,1,1,1,foreground_color[0]);

         axes_primitives.assign(3,1,2,1,1, 0,1, 0,2, 0,3);

       }


       // Begin user interaction loop

       CImg<T> visu0(*this), visu;

       bool init = true, clicked = false, redraw = true;

       unsigned int key = 0;

       int x0 = 0, y0 = 0, x1 = 0, y1 = 0;

       disp.show().flush();


       while (!disp.is_closed && !key) {


         // Init object position and scale if necessary

         if (init) {

           ratio = delta>0?(2.0f*cimg::min(disp.width,disp.height)/(3.0f*delta)):0;

           dx = 0.5f*(xM + xm); dy = 0.5f*(yM + ym); dz = 0.5f*(zM + zm);

           if (centering) {

             cimg_forX(centered_vertices,l) {

               centered_vertices(l,0) = (float)((vertices(l,0) - dx)*ratio);

               centered_vertices(l,1) = (float)((vertices(l,1) - dy)*ratio);

               centered_vertices(l,2) = (float)((vertices(l,2) - dz)*ratio);

             }

           }


           if (render_static<0 || render_motion<0) {

             rotated_bbox_vertices = bbox_vertices.assign(8,3,1,1,

                                                          xm,xM,xM,xm,xm,xM,xM,xm,

                                                          ym,ym,yM,yM,ym,ym,yM,yM,

                                                          zm,zm,zm,zm,zM,zM,zM,zM);

             bbox_primitives.assign(6,1,4,1,1, 0,3,2,1, 4,5,6,7, 1,2,6,5, 0,4,7,3, 0,1,5,4, 2,3,7,6);

             bbox_colors.assign(6,dim,1,1,1,background_color[0]);

             bbox_colors2.assign(6,dim,1,1,1,foreground_color[0]);

             bbox_opacities.assign(bbox_colors.width,1,1,1,0.3f);

           }


           if (!pose) {

             if (pose_matrix) pose = CImg<floatT>(pose_matrix,4,4,1,1,false);

             else pose = CImg<floatT>::identity_matrix(4);

           }

           init = false;

           redraw = true;

         }


         // Rotate and Draw 3D object

         if (redraw) {

           const float

             r00 = pose(0,0), r10 = pose(1,0), r20 = pose(2,0), r30 = pose(3,0),

             r01 = pose(0,1), r11 = pose(1,1), r21 = pose(2,1), r31 = pose(3,1),

             r02 = pose(0,2), r12 = pose(1,2), r22 = pose(2,2), r32 = pose(3,2);

           if ((clicked && render_motion>=0) || (!clicked && render_static>=0)) {

             if (centering) cimg_forX(centered_vertices,l) {

                 const float x = centered_vertices(l,0), y = centered_vertices(l,1), z = centered_vertices(l,2);

                 rotated_vertices(l,0) = r00*x + r10*y + r20*z + r30;

                 rotated_vertices(l,1) = r01*x + r11*y + r21*z + r31;

                 rotated_vertices(l,2) = r02*x + r12*y + r22*z + r32;

               } else cimg_forX(vertices,l) {

                 const float

                   x = (float)vertices(l,0),

                   y = (float)vertices(l,1),

                   z = (float)vertices(l,2);

                 rotated_vertices(l,0) = r00*x + r10*y + r20*z + r30;

                 rotated_vertices(l,1) = r01*x + r11*y + r21*z + r31;

                 rotated_vertices(l,2) = r02*x + r12*y + r22*z + r32;

               }

           } else {

             if (!centering) cimg_forX(bbox_vertices,l) {

                 const float x = bbox_vertices(l,0), y = bbox_vertices(l,1), z = bbox_vertices(l,2);

                 rotated_bbox_vertices(l,0) = r00*x + r10*y + r20*z + r30;

                 rotated_bbox_vertices(l,1) = r01*x + r11*y + r21*z + r31;

                 rotated_bbox_vertices(l,2) = r02*x + r12*y + r22*z + r32;

               } else cimg_forX(bbox_vertices,l) {

                 const float x = (bbox_vertices(l,0) - dx)*ratio, y = (bbox_vertices(l,1) - dy)*ratio, z = (bbox_vertices(l,2) - dz)*ratio;

                 rotated_bbox_vertices(l,0) = r00*x + r10*y + r20*z + r30;

                 rotated_bbox_vertices(l,1) = r01*x + r11*y + r21*z + r31;

                 rotated_bbox_vertices(l,2) = r02*x + r12*y + r22*z + r32;

               }

           }


           // Draw object

           visu = visu0;

           if ((clicked && render_motion<0) || (!clicked && render_static<0))

             visu.draw_object3d(visu.width/2.0f,visu.height/2.0f,0,rotated_bbox_vertices,bbox_primitives,bbox_colors,bbox_opacities,2,false,focale).

               draw_object3d(visu.width/2.0f,visu.height/2.0f,0,rotated_bbox_vertices,bbox_primitives,bbox_colors2,1,false,focale);

           else visu.draw_object3d(visu.width/2.0f,visu.height/2.0f,0,

                                   rotated_vertices,primitives,ncolors,opacities,clicked?render_motion:render_static,

                                   double_sided,focale,visu.dimx()/2.0f,visu.dimy()/2.0f,-5000,specular_light,specular_shine,

                                   (!clicked && render_static>0)?zbuffer.fill(0):CImg<floatT>::empty());


           // Draw axes

           if (display_axes) {

             const float Xaxes = 25, Yaxes = visu.height - 35.0f;

             cimg_forX(axes_vertices,l) {

               const float x = axes_vertices(l,0), y = axes_vertices(l,1), z = axes_vertices(l,2);

               rotated_axes_vertices(l,0) = r00*x + r10*y + r20*z;

               rotated_axes_vertices(l,1) = r01*x + r11*y + r21*z;

               rotated_axes_vertices(l,2) = r02*x + r12*y + r22*z;

             }

             axes_opacities(0,0) = (rotated_axes_vertices(1,2)>0)?0.5f:1.0f;

             axes_opacities(1,0) = (rotated_axes_vertices(2,2)>0)?0.5f:1.0f;

             axes_opacities(2,0) = (rotated_axes_vertices(3,2)>0)?0.5f:1.0f;

             visu.draw_object3d(Xaxes,Yaxes,0,rotated_axes_vertices,axes_primitives,axes_colors,axes_opacities,1,false,focale).

               draw_text((int)(Xaxes+rotated_axes_vertices(4,0)),

                         (int)(Yaxes+rotated_axes_vertices(4,1)),

                         "X",axes_colors[0].data,0,axes_opacities(0,0),11).

               draw_text((int)(Xaxes+rotated_axes_vertices(5,0)),

                         (int)(Yaxes+rotated_axes_vertices(5,1)),

                         "Y",axes_colors[1].data,0,axes_opacities(1,0),11).

               draw_text((int)(Xaxes+rotated_axes_vertices(6,0)),

                         (int)(Yaxes+rotated_axes_vertices(6,1)),

                         "Z",axes_colors[2].data,0,axes_opacities(2,0),11);

           }

           visu.display(disp);

           if (!clicked || render_motion==render_static) redraw = false;

         }


         // Handle user interaction

         disp.wait();

         if ((disp.button || disp.wheel) && disp.mouse_x>=0 && disp.mouse_y>=0) {

           redraw = true;

           if (!clicked) { x0 = x1 = disp.mouse_x; y0 = y1 = disp.mouse_y; if (!disp.wheel) clicked = true; }

           else { x1 = disp.mouse_x; y1 = disp.mouse_y; }

           if (disp.button&1) {

             const float

               R = 0.45f*cimg::min(disp.width,disp.height),

               R2 = R*R,

               u0 = (float)(x0-disp.dimx()/2),

               v0 = (float)(y0-disp.dimy()/2),

               u1 = (float)(x1-disp.dimx()/2),

               v1 = (float)(y1-disp.dimy()/2),

               n0 = (float)std::sqrt(u0*u0+v0*v0),

               n1 = (float)std::sqrt(u1*u1+v1*v1),

               nu0 = n0>R?(u0*R/n0):u0,

               nv0 = n0>R?(v0*R/n0):v0,

               nw0 = (float)std::sqrt(cimg::max(0,R2-nu0*nu0-nv0*nv0)),

               nu1 = n1>R?(u1*R/n1):u1,

               nv1 = n1>R?(v1*R/n1):v1,

               nw1 = (float)std::sqrt(cimg::max(0,R2-nu1*nu1-nv1*nv1)),

               u = nv0*nw1-nw0*nv1,

               v = nw0*nu1-nu0*nw1,

               w = nv0*nu1-nu0*nv1,

               n = (float)std::sqrt(u*u+v*v+w*w),

               alpha = (float)std::asin(n/R2);

             rot_mat = CImg<floatT>::rotation_matrix(u,v,w,alpha);

             rot_mat *= pose.get_crop(0,0,2,2);

             pose.draw_image(rot_mat);

             x0=x1; y0=y1;

           }

           if (disp.button&2) { pose(3,2)+=(y1-y0); x0 = x1; y0 = y1; }

           if (disp.wheel) { pose(3,2)-=focale*disp.wheel/10; disp.wheel = 0; }

           if (disp.button&4) { pose(3,0)+=(x1-x0); pose(3,1)+=(y1-y0); x0 = x1; y0 = y1; }

           if ((disp.button&1) && (disp.button&2)) { init = true; disp.button = 0; x0 = x1; y0 = y1; pose = CImg<floatT>::identity_matrix(4); }

         } else if (clicked) { x0 = x1; y0 = y1; clicked = false; redraw = true; }


         switch (key = disp.key) {

         case 0 : case cimg::keyCTRLLEFT : disp.key = key = 0; break;

         case cimg::keyD: if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,false),

                                      CImgDisplay::_fitscreen(3*disp.width/2,3*disp.height/2,1,128,-100,true),false).is_resized = true;

           disp.key = key = 0;

         } break;

         case cimg::keyC : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(2*disp.width/3,2*disp.height/3,1),false).is_resized = true;

           disp.key = key = 0;

         } break;

         case cimg::keyR : if (disp.is_keyCTRLLEFT) {

           disp.normalscreen().resize(cimg_fitscreen(width,height,depth),false).is_resized = true;

           disp.key = key = 0;

         } break;

         case cimg::keyF : if (disp.is_keyCTRLLEFT) {

           if (!ns_width || !ns_height ||

               ns_width>(unsigned int)disp.screen_dimx() || ns_height>(unsigned int)disp.screen_dimy()) {

             ns_width = disp.screen_dimx()*3U/4;

             ns_height = disp.screen_dimy()*3U/4;

           }

           if (disp.is_fullscreen) disp.resize(ns_width,ns_height,false);

           else {

             ns_width = (unsigned int)disp.width; ns_height = disp.height;

             disp.resize(disp.screen_dimx(),disp.screen_dimy(),false);

           }

           disp.toggle_fullscreen().is_resized = true;

           disp.key = key = 0;

           } break;

         case cimg::keyZ : if (disp.is_keyCTRLLEFT) { // Enable/Disable Z-buffer

           if (zbuffer) zbuffer.assign();

           else zbuffer.assign(disp.width,disp.height,1,1,0);

           disp.key = key = 0; redraw = true;

         } break;

         case cimg::keyS : if (disp.is_keyCTRLLEFT) { // Save snapshot

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.bmp",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           (+visu).draw_text(2,2,"Saving BMP snapshot...",foreground_color,background_color,1,11).display(disp);

           visu.save(filename);

           visu.draw_text(2,2,"Snapshot '%s' saved.",foreground_color,background_color,1,11,filename).display(disp);

           disp.key = key = 0;

         } break;

         case cimg::keyO : if (disp.is_keyCTRLLEFT) { // Save object as an .OFF file

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.off",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           visu.draw_text(2,2,"Saving object...",foreground_color,background_color,1,11).display(disp);

           vertices.save_off(filename,primitives,ncolors);

           visu.draw_text(2,2,"Object '%s' saved.",foreground_color,background_color,1,11,filename).display(disp);

           disp.key = key = 0;

         } break;

 #ifdef cimg_use_board

         case cimg::keyP : if (disp.is_keyCTRLLEFT) { // Save object as a .EPS file

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.eps",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           visu.draw_text(2,2,"Saving EPS snapshot...",foreground_color,background_color,1,11).display(disp);

           LibBoard::Board board;

           (+visu).draw_object3d(board,visu.width/2.0f,visu.height/2.0f,0,

                                 rotated_vertices,primitives,ncolors,opacities,clicked?render_motion:render_static,

                                 double_sided,focale,visu.dimx()/2.0f,visu.dimy()/2.0f,-5000,specular_light,specular_shine,

                                 zbuffer.fill(0));

           board.saveEPS(filename);

           visu.draw_text(2,2,"Object '%s' saved.",foreground_color,background_color,1,11,filename).display(disp);

           disp.key = key = 0;

         } break;

         case cimg::keyV : if (disp.is_keyCTRLLEFT) { // Save object as a .SVG file

           static unsigned int snap_number = 0;

           char filename[32] = { 0 };

           std::FILE *file;

           do {

             std::sprintf(filename,"CImg_%.4u.svg",snap_number++);

             if ((file=std::fopen(filename,"r"))!=0) std::fclose(file);

           } while (file);

           visu.draw_text(2,2,"Saving SVG snapshot...",foreground_color,background_color,1,11).display(disp);

           LibBoard::Board board;

           (+visu).draw_object3d(board,visu.width/2.0f,visu.height/2.0f,0,

                                 rotated_vertices,primitives,ncolors,opacities,clicked?render_motion:render_static,

                                 double_sided,focale,visu.dimx()/2.0f,visu.dimy()/2.0f,-5000,specular_light,specular_shine,

                                 zbuffer.fill(0));

           board.saveSVG(filename);

           visu.draw_text(2,2,"Object '%s' saved.",foreground_color,background_color,1,11,filename).display(disp);

           disp.key = key = 0;

         } break;

 #endif

         }

         if (disp.is_resized) { disp.resize(false); visu0 = get_resize(disp,1); if (zbuffer) zbuffer.assign(disp.width,disp.height); redraw = true; }

       }

       if (pose_matrix) std::memcpy(pose_matrix,pose.data,16*sizeof(float));

       disp.button = 0;

       disp.key = key;

       return *this;

     }


     const CImg<T>& display_graph(CImgDisplay &disp,

                                  const unsigned int plot_type=1, const unsigned int vertex_type=1,

                                  const char *const labelx=0, const double xmin=0, const double xmax=0,

                                  const char *const labely=0, const double ymin=0, const double ymax=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::display_graph() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       const unsigned int siz = width*height*depth, onormalization = disp.normalization;

       if (!disp) { char ntitle[64] = { 0 }; std::sprintf(ntitle,"CImg<%s>",pixel_type()); disp.assign(640,480,ntitle,0); }

       disp.show().flush().normalization = 0;

       double y0 = ymin, y1 = ymax, nxmin = xmin, nxmax = xmax;

       if (nxmin==nxmax) { nxmin = 0; nxmax = siz; }

       int x0 = 0, x1 = dimx()*dimy()*dimz()-1, key = 0;


       for (bool reset_view = true, resize_disp = false; !key && !disp.is_closed; ) {

         if (reset_view) { x0 = 0; x1 = dimx()*dimy()*dimz()-1; y0 = ymin; y1 = ymax; reset_view = false; }

         CImg<T> zoom(x1-x0+1,1,1,dimv());

         cimg_forV(*this,k) zoom.get_shared_channel(k) = CImg<T>(ptr(x0,0,0,k),x1-x0+1,1,1,1,true);


         if (y0==y1) y0 = zoom.minmax(y1);

         if (y0==y1) { --y0; ++y1; }

         const CImg<intT> selection = zoom.get_select_graph(disp,plot_type,vertex_type,

                                                            labelx,nxmin + x0*(nxmax-nxmin)/siz,nxmin + (x1+1)*(nxmax-nxmin)/siz,

                                                            labely,y0,y1);


         const int mouse_x = disp.mouse_x, mouse_y = disp.mouse_y;

         if (selection[0]>=0 && selection[2]>=0) {

           x1 = x0 + selection[2];

           x0 += selection[0];

           if (x0==x1) reset_view = true;

           if (selection[1]>=0 && selection[3]>=0) {

             y0 = y1 - selection[3]*(y1-y0)/(disp.dimy()-32);

             y1 -= selection[1]*(y1-y0)/(disp.dimy()-32);

           }

         } else {

           bool go_in = false, go_out = false, go_left = false, go_right = false, go_up = false, go_down = false;

           switch (key = disp.key) {

           case cimg::keyHOME : case cimg::keyBACKSPACE : reset_view = resize_disp = true; key = 0; break;

           case cimg::keyPADADD : go_in = true; key = 0; break;

           case cimg::keyPADSUB : go_out = true; key = 0; break;

           case cimg::keyARROWLEFT : case cimg::keyPAD4 : go_left = true; key = 0; break;

           case cimg::keyARROWRIGHT : case cimg::keyPAD6 : go_right = true; key = 0; break;

           case cimg::keyARROWUP : case cimg::keyPAD8 : go_up = true; key = 0; break;

           case cimg::keyARROWDOWN : case cimg::keyPAD2 : go_down = true; key = 0; break;

           case cimg::keyPAD7 : go_left = true; go_up = true; key = 0; break;

           case cimg::keyPAD9 : go_right = true; go_up = true; key = 0; break;

           case cimg::keyPAD1 : go_left = true; go_down = true; key = 0; break;

           case cimg::keyPAD3 : go_right = true; go_down = true; key = 0; break;

           }

           if (disp.wheel) go_out = !(go_in = disp.wheel>0);


           if (go_in) {

             const int

               xsiz = x1 - x0,

               mx = (mouse_x-16)*xsiz/(disp.dimx()-32),

               cx = x0 + (mx<0?0:(mx>=xsiz?xsiz:mx));

             if (x1-x0>4) {

               x0 = cx - 7*(cx-x0)/8; x1 = cx + 7*(x1-cx)/8;

               if (disp.is_keyCTRLLEFT) {

                 const double

                   ysiz = y1 - y0,

                   my = (mouse_y-16)*ysiz/(disp.dimy()-32),

                   cy = y1 - (my<0?0:(my>=ysiz?ysiz:my));

                 y0 = cy - 7*(cy-y0)/8; y1 = cy + 7*(y1-cy)/8;

               } else y0 = y1 = 0;

             }

           }

           if (go_out) {

             const int deltax = (x1-x0)/8, ndeltax = deltax?deltax:(siz>1?1:0);

             x0-=ndeltax; x1+=ndeltax;

             if (x0<0) { x1-=x0; x0 = 0; if (x1>=(int)siz) x1 = (int)siz-1; }

             if (x1>=(int)siz) { x0-=(x1-siz+1); x1 = (int)siz-1; if (x0<0) x0 = 0; }

             if (disp.is_keyCTRLLEFT) {

               const double deltay = (y1-y0)/8, ndeltay = deltay?deltay:0.01;

               y0-=ndeltay; y1+=ndeltay;

             }

           }

           if (go_left) {

             const int delta = (x1-x0)/5, ndelta = delta?delta:1;

             if (x0-ndelta>=0) { x0-=ndelta; x1-=ndelta; }

             else { x1-=x0; x0 = 0; }

             go_left = false;

           }

           if (go_right) {

             const int delta = (x1-x0)/5, ndelta = delta?delta:1;

             if (x1+ndelta<(int)siz) { x0+=ndelta; x1+=ndelta; }

             else { x0+=(siz-1-x1); x1 = siz-1; }

             go_right = false;

           }

           if (go_up) {

             const double delta = (y1-y0)/10, ndelta = delta?delta:1;

             y0+=ndelta; y1+=ndelta;

             go_up = false;

           }

           if (go_down) {

             const double delta = (y1-y0)/10, ndelta = delta?delta:1;

             y0-=ndelta; y1-=ndelta;

             go_down = false;

           }

         }

       }

       disp.normalization = onormalization;

       return *this;

     }


     const CImg<T>& display_graph(const char *const title=0,

                                  const unsigned int plot_type=1, const unsigned int vertex_type=1,

                                  const char *const labelx=0, const double xmin=0, const double xmax=0,

                                  const char *const labely=0, const double ymin=0, const double ymax=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::display_graph() : Instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),width,height,depth,dim,data);

       char ntitle[64] = { 0 }; if (!title) std::sprintf(ntitle,"CImg<%s>",pixel_type());

       CImgDisplay disp(cimg_fitscreen(640,480,1),title?title:ntitle,0);

       return display_graph(disp,plot_type,vertex_type,labelx,xmin,xmax,labely,ymin,ymax);

     }


     const CImg<T>& save(const char *const filename, const int number=-1) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save() : Instance image (%u,%u,%u,%u,%p) cannot be saved as a (null) filename.",

                                     pixel_type(),width,height,depth,dim,data);

       const char *ext = cimg::split_filename(filename);

       char nfilename[1024] = { 0 };

       const char *const fn = (number>=0)?cimg::number_filename(filename,number,6,nfilename):filename;

 #ifdef cimg_save_plugin

       cimg_save_plugin(fn);

 #endif

 #ifdef cimg_save_plugin1

       cimg_save_plugin1(fn);

 #endif

 #ifdef cimg_save_plugin2

       cimg_save_plugin2(fn);

 #endif

 #ifdef cimg_save_plugin3

       cimg_save_plugin3(fn);

 #endif

 #ifdef cimg_save_plugin4

       cimg_save_plugin4(fn);

 #endif

 #ifdef cimg_save_plugin5

       cimg_save_plugin5(fn);

 #endif

 #ifdef cimg_save_plugin6

       cimg_save_plugin6(fn);

 #endif

 #ifdef cimg_save_plugin7

       cimg_save_plugin7(fn);

 #endif

 #ifdef cimg_save_plugin8

       cimg_save_plugin8(fn);

 #endif

       // ASCII formats

       if (!cimg::strcasecmp(ext,"asc")) return save_ascii(fn);

       if (!cimg::strcasecmp(ext,"dlm") ||

           !cimg::strcasecmp(ext,"txt")) return save_dlm(fn);

       if (!cimg::strcasecmp(ext,"cpp") ||

           !cimg::strcasecmp(ext,"hpp") ||

           !cimg::strcasecmp(ext,"h") ||

           !cimg::strcasecmp(ext,"c")) return save_cpp(fn);


       // 2D binary formats

       if (!cimg::strcasecmp(ext,"bmp")) return save_bmp(fn);

       if (!cimg::strcasecmp(ext,"jpg") ||

           !cimg::strcasecmp(ext,"jpeg") ||

           !cimg::strcasecmp(ext,"jpe") ||

           !cimg::strcasecmp(ext,"jfif") ||

           !cimg::strcasecmp(ext,"jif")) return save_jpeg(fn);

       if (!cimg::strcasecmp(ext,"rgb")) return save_rgb(fn);

       if (!cimg::strcasecmp(ext,"rgba")) return save_rgba(fn);

       if (!cimg::strcasecmp(ext,"png")) return save_png(fn);

       if (!cimg::strcasecmp(ext,"pgm") ||

           !cimg::strcasecmp(ext,"ppm") ||

           !cimg::strcasecmp(ext,"pnm")) return save_pnm(fn);

       if (!cimg::strcasecmp(ext,"tif") ||

           !cimg::strcasecmp(ext,"tiff")) return save_tiff(fn);


       // 3D binary formats

       if (!cimg::strcasecmp(ext,"cimgz")) return save_cimg(fn,true);

       if (!cimg::strcasecmp(ext,"cimg") || !*ext) return save_cimg(fn,false);

       if (!cimg::strcasecmp(ext,"dcm")) return save_medcon_external(fn);

       if (!cimg::strcasecmp(ext,"hdr") ||

           !cimg::strcasecmp(ext,"nii")) return save_analyze(fn);

       if (!cimg::strcasecmp(ext,"inr")) return save_inr(fn);

       if (!cimg::strcasecmp(ext,"pan")) return save_pandore(fn);

       if (!cimg::strcasecmp(ext,"raw")) return save_raw(fn);


       // Archive files

       if (!cimg::strcasecmp(ext,"gz")) return save_gzip_external(fn);


       // Image sequences

       if (!cimg::strcasecmp(ext,"yuv")) return save_yuv(fn,true);

       if (!cimg::strcasecmp(ext,"avi") ||

           !cimg::strcasecmp(ext,"mov") ||

           !cimg::strcasecmp(ext,"asf") ||

           !cimg::strcasecmp(ext,"divx") ||

           !cimg::strcasecmp(ext,"flv") ||

           !cimg::strcasecmp(ext,"mpg") ||

           !cimg::strcasecmp(ext,"m1v") ||

           !cimg::strcasecmp(ext,"m2v") ||

           !cimg::strcasecmp(ext,"m4v") ||

           !cimg::strcasecmp(ext,"mjp") ||

           !cimg::strcasecmp(ext,"mkv") ||

           !cimg::strcasecmp(ext,"mpe") ||

           !cimg::strcasecmp(ext,"movie") ||

           !cimg::strcasecmp(ext,"ogm") ||

           !cimg::strcasecmp(ext,"qt") ||

           !cimg::strcasecmp(ext,"rm") ||

           !cimg::strcasecmp(ext,"vob") ||

           !cimg::strcasecmp(ext,"wmv") ||

           !cimg::strcasecmp(ext,"xvid") ||

           !cimg::strcasecmp(ext,"mpeg")) return save_ffmpeg(fn);

       return save_other(fn);

     }


     // Save the image as an ASCII file (ASCII Raw + simple header) (internal).

     const CImg<T>& _save_ascii(std::FILE *const file, const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_ascii() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_ascii() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"w");

       std::fprintf(nfile,"%u %u %u %u\n",width,height,depth,dim);

       const T* ptrs = data;

       cimg_forYZV(*this,y,z,v) {

         cimg_forX(*this,x) std::fprintf(nfile,"%g ",(double)*(ptrs++));

         std::fputc('\n',nfile);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_ascii(const char *const filename) const {

       return _save_ascii(0,filename);

     }


     const CImg<T>& save_ascii(std::FILE *const file) const {

       return _save_ascii(file,0);

     }


     // Save the image as a C or CPP source file (internal).

     const CImg<T>& _save_cpp(std::FILE *const file, const char *const filename) const {

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_cpp() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_cpp() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"w");

       char varname[1024] = { 0 };

       if (filename) std::sscanf(cimg::basename(filename),"%1023[a-zA-Z0-9_]",varname);

       if (!*varname) std::sprintf(varname,"unnamed");

       std::fprintf(nfile,

                    "/* Define image '%s' of size %ux%ux%ux%u and type '%s' */\n"

                    "%s data_%s[] = { \n  ",

                    varname,width,height,depth,dim,pixel_type(),pixel_type(),varname);

       for (unsigned int off = 0, siz = size()-1; off<=siz; ++off) {

         std::fprintf(nfile,cimg::type<T>::format(),cimg::type<T>::format((*this)[off]));

         if (off==siz) std::fprintf(nfile," };\n");

         else if (!((off+1)%16)) std::fprintf(nfile,",\n  ");

         else std::fprintf(nfile,", ");

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_cpp(const char *const filename) const {

       return _save_cpp(0,filename);

     }


     const CImg<T>& save_cpp(std::FILE *const file) const {

       return _save_cpp(file,0);

     }


     // Save the image as a DLM file (internal).

     const CImg<T>& _save_dlm(std::FILE *const file, const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_dlm() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_dlm() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (depth>1)

         cimg::warn("CImg<%s>::save_dlm() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Pixel values along Z will be unrolled.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (dim>1)

         cimg::warn("CImg<%s>::save_dlm() : File '%s', instance image (%u,%u,%u,%u,%p) is multispectral. "

                    "Pixel values along V will be unrolled.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);


       std::FILE *const nfile = file?file:cimg::fopen(filename,"w");

       const T* ptrs = data;

       cimg_forYZV(*this,y,z,v) {

         cimg_forX(*this,x) std::fprintf(nfile,"%g%s",(double)*(ptrs++),(x==dimx()-1)?"":",");

         std::fputc('\n',nfile);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_dlm(const char *const filename) const {

       return _save_dlm(0,filename);

     }


     const CImg<T>& save_dlm(std::FILE *const file) const {

       return _save_dlm(file,0);

     }


    // Save the image as a BMP file (internal).

     const CImg<T>& _save_bmp(std::FILE *const file, const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_bmp() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_bmp() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (depth>1)

         cimg::warn("CImg<%s>::save_bmp() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (dim>3)

         cimg::warn("CImg<%s>::save_bmp() : File '%s', instance image (%u,%u,%u,%u,%p) is multispectral. Only the three first channels will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);


       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       unsigned char header[54] = { 0 }, align_buf[4] = { 0 };

       const unsigned int

         align = (4 - (3*width)%4)%4,

         buf_size = (3*width+align)*dimy(),

         file_size = 54 + buf_size;

       header[0] = 'B'; header[1] = 'M';

       header[0x02] = file_size&0xFF;

       header[0x03] = (file_size>>8)&0xFF;

       header[0x04] = (file_size>>16)&0xFF;

       header[0x05] = (file_size>>24)&0xFF;

       header[0x0A] = 0x36;

       header[0x0E] = 0x28;

       header[0x12] = width&0xFF;

       header[0x13] = (width>>8)&0xFF;

       header[0x14] = (width>>16)&0xFF;

       header[0x15] = (width>>24)&0xFF;

       header[0x16] = height&0xFF;

       header[0x17] = (height>>8)&0xFF;

       header[0x18] = (height>>16)&0xFF;

       header[0x19] = (height>>24)&0xFF;

       header[0x1A] = 1;

       header[0x1B] = 0;

       header[0x1C] = 24;

       header[0x1D] = 0;

       header[0x22] = buf_size&0xFF;

       header[0x23] = (buf_size>>8)&0xFF;

       header[0x24] = (buf_size>>16)&0xFF;

       header[0x25] = (buf_size>>24)&0xFF;

       header[0x27] = 0x1;

       header[0x2B] = 0x1;

       cimg::fwrite(header,54,nfile);


       const T

         *pR = ptr(0,height-1,0,0),

         *pG = (dim>=2)?ptr(0,height-1,0,1):0,

         *pB = (dim>=3)?ptr(0,height-1,0,2):0;


       switch (dim) {

       case 1 : {

         cimg_forY(*this,y) { cimg_forX(*this,x) {

           const unsigned char val = (unsigned char)*(pR++);

           std::fputc(val,nfile); std::fputc(val,nfile); std::fputc(val,nfile);

         }

         cimg::fwrite(align_buf,align,nfile);

         pR-=2*width;

         }} break;

       case 2 : {

         cimg_forY(*this,y) { cimg_forX(*this,x) {

           std::fputc(0,nfile);

           std::fputc((unsigned char)(*(pG++)),nfile);

           std::fputc((unsigned char)(*(pR++)),nfile);

         }

         cimg::fwrite(align_buf,align,nfile);

         pR-=2*width; pG-=2*width;

         }} break;

       default : {

         cimg_forY(*this,y) { cimg_forX(*this,x) {

           std::fputc((unsigned char)(*(pB++)),nfile);

           std::fputc((unsigned char)(*(pG++)),nfile);

           std::fputc((unsigned char)(*(pR++)),nfile);

         }

         cimg::fwrite(align_buf,align,nfile);

         pR-=2*width; pG-=2*width; pB-=2*width;

         }

       }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_bmp(const char *const filename) const {

       return _save_bmp(0,filename);

     }


     const CImg<T>& save_bmp(std::FILE *const file) const {

       return _save_bmp(file,0);

     }


     // Save a file in JPEG format (internal).

     const CImg<T>& _save_jpeg(std::FILE *const file, const char *const filename, const unsigned int quality) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_jpeg() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_jpeg() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (depth>1)

         cimg::warn("CImg<%s>::save_jpeg() : File '%s, instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

 #ifndef cimg_use_jpeg

       if (!file) return save_other(filename,quality);

       else throw CImgIOException("CImg<%s>::save_jpeg() : Cannot save a JPEG image in a *FILE output. Use libjpeg instead.",

                                  pixel_type());

 #else

       // Fill pixel buffer

       unsigned char *buf;

       unsigned int dimbuf = 0;

       J_COLOR_SPACE colortype = JCS_RGB;

       switch (dim) {

       case 1 : { // Greyscale images

         unsigned char *buf2 = buf = new unsigned char[width*height*(dimbuf=1)];

         colortype = JCS_GRAYSCALE;

         const T *ptr_g = data;

         cimg_forXY(*this,x,y) *(buf2++) = (unsigned char)*(ptr_g++);

       } break;

       case 2 : { // RG images

         unsigned char *buf2 = buf = new unsigned char[width*height*(dimbuf=3)];

         const T *ptr_r = ptr(0,0,0,0), *ptr_g = ptr(0,0,0,1);

         colortype = JCS_RGB;

         cimg_forXY(*this,x,y) {

           *(buf2++) = (unsigned char)*(ptr_r++);

           *(buf2++) = (unsigned char)*(ptr_g++);

           *(buf2++) = 0;

         }

       } break;

       case 3 : { // RGB images

         unsigned char *buf2 = buf = new unsigned char[width*height*(dimbuf=3)];

         const T *ptr_r = ptr(0,0,0,0), *ptr_g = ptr(0,0,0,1), *ptr_b = ptr(0,0,0,2);

         colortype = JCS_RGB;

         cimg_forXY(*this,x,y) {

           *(buf2++) = (unsigned char)*(ptr_r++);

           *(buf2++) = (unsigned char)*(ptr_g++);

           *(buf2++) = (unsigned char)*(ptr_b++);

         }

       } break;

       default : { // CMYK images

         unsigned char *buf2 = buf = new unsigned char[width*height*(dimbuf=4)];

         const T *ptr_r = ptr(0,0,0,0), *ptr_g = ptr(0,0,0,1), *ptr_b = ptr(0,0,0,2), *ptr_a = ptr(0,0,0,3);

         colortype = JCS_CMYK;

         cimg_forXY(*this,x,y) {

           *(buf2++) = (unsigned char)*(ptr_r++);

           *(buf2++) = (unsigned char)*(ptr_g++);

           *(buf2++) = (unsigned char)*(ptr_b++);

           *(buf2++) = (unsigned char)*(ptr_a++);

         }

       }

       }


       // Call libjpeg functions

       struct jpeg_compress_struct cinfo;

       struct jpeg_error_mgr jerr;

       cinfo.err = jpeg_std_error(&jerr);

       jpeg_create_compress(&cinfo);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       jpeg_stdio_dest(&cinfo,nfile);

       cinfo.image_width = width;

       cinfo.image_height = height;

       cinfo.input_components = dimbuf;

       cinfo.in_color_space = colortype;

       jpeg_set_defaults(&cinfo);

       jpeg_set_quality(&cinfo,quality<100?quality:100,TRUE);

       jpeg_start_compress(&cinfo,TRUE);


       const unsigned int row_stride = width*dimbuf;

       JSAMPROW row_pointer[1];

       while (cinfo.next_scanline < cinfo.image_height) {

         row_pointer[0] = &buf[cinfo.next_scanline*row_stride];

         jpeg_write_scanlines(&cinfo,row_pointer,1);

       }

       jpeg_finish_compress(&cinfo);


       delete[] buf;

       if (!file) cimg::fclose(nfile);

       jpeg_destroy_compress(&cinfo);

       return *this;

 #endif

     }


     const CImg<T>& save_jpeg(const char *const filename, const unsigned int quality=100) const {

       return _save_jpeg(0,filename,quality);

     }


     const CImg<T>& save_jpeg(std::FILE *const file, const unsigned int quality=100) const {

       return _save_jpeg(file,0,quality);

     }


     const CImg<T>& save_magick(const char *const filename, const unsigned int bytes_per_pixel=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_magick() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       unsigned int foo = bytes_per_pixel; foo = 0;

 #ifdef cimg_use_magick

       double stmin, stmax = (double)maxmin(stmin);

       if (depth>1)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename,width,height,depth,dim,data);

       if (dim>3)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) is multispectral. Only the three first channels will be saved.",

                    pixel_type(),filename,width,height,depth,dim,data);

       if (stmin<0 || (bytes_per_pixel==1 && stmax>=256) || stmax>=65536)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) has pixel values in [%g,%g]. Probable type overflow.",

                    pixel_type(),filename,width,height,depth,dim,data,stmin,stmax);

       Magick::Image image(Magick::Geometry(width,height),"black");

       image.type(Magick::TrueColorType);

       image.depth(bytes_per_pixel?(8*bytes_per_pixel):(stmax>=256?16:8));

       const T

         *rdata = ptr(0,0,0,0),

         *gdata = dim>1?ptr(0,0,0,1):0,

         *bdata = dim>2?ptr(0,0,0,2):0;

       Magick::PixelPacket *pixels = image.getPixels(0,0,width,height);

       switch (dim) {

       case 1 : // Scalar images

         for (unsigned int off = width*height; off; --off) {

           pixels->red = pixels->green = pixels->blue = (Magick::Quantum)*(rdata++);

           ++pixels;

         }

         break;

       case 2 : // RG images

         for (unsigned int off = width*height; off; --off) {

           pixels->red = (Magick::Quantum)*(rdata++);

           pixels->green = (Magick::Quantum)*(gdata++);

           pixels->blue = 0; ++pixels;

         }

         break;

       default : // RGB images

         for (unsigned int off = width*height; off; --off) {

           pixels->red = (Magick::Quantum)*(rdata++);

           pixels->green = (Magick::Quantum)*(gdata++);

           pixels->blue = (Magick::Quantum)*(bdata++);

           ++pixels;

         }

       }

       image.syncPixels();

       image.write(filename);

 #else

       throw CImgIOException("CImg<%s>::save_magick() : File '%s', Magick++ library has not been linked.",

                             pixel_type(),filename);

 #endif

       return *this;

     }


     // Save an image to a PNG file (internal).

     // Most of this function has been written by Eric Fausett

     const CImg<T>& _save_png(std::FILE *const file, const char *const filename, const unsigned int bytes_per_pixel=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_png() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_png() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (depth>1)

         cimg::warn("CImg<%s>::save_png() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       unsigned int foo = bytes_per_pixel; foo = 0;

 #ifndef cimg_use_png

       if (!file) return save_other(filename);

       else throw CImgIOException("CImg<%s>::save_png() : Cannot save a PNG image in a *FILE output. You must use 'libpng' to do this instead.",

                                  pixel_type());

 #else

       const char *volatile nfilename = filename; // two 'volatile' here to remove a g++ warning due to 'setjmp'.

       std::FILE *volatile nfile = file?file:cimg::fopen(nfilename,"wb");


       double stmin, stmax = (double)maxmin(stmin);

       if (depth>1)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename,width,height,depth,dim,data);

       if (dim>3)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) is multispectral. Only the three first channels will be saved.",

                    pixel_type(),filename,width,height,depth,dim,data);

       if (stmin<0 || (bytes_per_pixel==1 && stmax>=256) || stmax>=65536)

         cimg::warn("CImg<%s>::save_magick() : File '%s', instance image (%u,%u,%u,%u,%p) has pixel values in [%g,%g]. Probable type overflow.",

                    pixel_type(),filename,width,height,depth,dim,data,stmin,stmax);


       // Setup PNG structures for write

       png_voidp user_error_ptr = 0;

       png_error_ptr user_error_fn = 0, user_warning_fn = 0;

       png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,user_error_ptr, user_error_fn, user_warning_fn);

       if(!png_ptr){

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::save_png() : File '%s', error when initializing 'png_ptr' data structure.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_infop info_ptr = png_create_info_struct(png_ptr);

       if (!info_ptr) {

         png_destroy_write_struct(&png_ptr,(png_infopp)0);

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::save_png() : File '%s', error when initializing 'info_ptr' data structure.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       if (setjmp(png_jmpbuf(png_ptr))) {

         png_destroy_write_struct(&png_ptr, &info_ptr);

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::save_png() : File '%s', unknown fatal error.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_init_io(png_ptr, nfile);

       png_uint_32 width = dimx(), height = dimy();

       const int bit_depth = bytes_per_pixel?(bytes_per_pixel*8):(stmax>=256?16:8);

       int color_type;

       switch (dimv()) {

       case 1 : color_type = PNG_COLOR_TYPE_GRAY; break;

       case 2 : color_type = PNG_COLOR_TYPE_GRAY_ALPHA; break;

       case 3 : color_type = PNG_COLOR_TYPE_RGB; break;

       default : color_type = PNG_COLOR_TYPE_RGB_ALPHA;

       }

       const int interlace_type = PNG_INTERLACE_NONE;

       const int compression_type = PNG_COMPRESSION_TYPE_DEFAULT;

       const int filter_method = PNG_FILTER_TYPE_DEFAULT;

       png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type, interlace_type,compression_type, filter_method);

       png_write_info(png_ptr, info_ptr);

       const int byte_depth = bit_depth>>3;

       const int numChan = dimv()>4?4:dimv();

       const int pixel_bit_depth_flag = numChan * (bit_depth-1);


       // Allocate Memory for Image Save and Fill pixel data

       png_bytep *imgData = new png_byte*[height];

       for (unsigned int row = 0; row<height; ++row) imgData[row] = new png_byte[byte_depth*numChan*width];

       const T *pC0 = ptr(0,0,0,0);

       switch (pixel_bit_depth_flag) {

       case 7 :  { // Gray 8-bit

         cimg_forY(*this,y) {

           unsigned char *ptrd = imgData[y];

           cimg_forX(*this,x) *(ptrd++) = (unsigned char)*(pC0++);

         }

       } break;

       case 14 : { // Gray w/ Alpha 8-bit

         const T *pC1 = ptr(0,0,0,1);

         cimg_forY(*this,y) {

           unsigned char *ptrd = imgData[y];

           cimg_forX(*this,x) {

             *(ptrd++) = (unsigned char)*(pC0++);

             *(ptrd++) = (unsigned char)*(pC1++);

           }

         }

       } break;

       case 21 :  { // RGB 8-bit

         const T *pC1 = ptr(0,0,0,1), *pC2 = ptr(0,0,0,2);

         cimg_forY(*this,y) {

           unsigned char *ptrd = imgData[y];

           cimg_forX(*this,x) {

             *(ptrd++) = (unsigned char)*(pC0++);

             *(ptrd++) = (unsigned char)*(pC1++);

             *(ptrd++) = (unsigned char)*(pC2++);

           }

         }

       } break;

       case 28 : { // RGB x/ Alpha 8-bit

         const T *pC1 = ptr(0,0,0,1), *pC2 = ptr(0,0,0,2), *pC3 = ptr(0,0,0,3);

         cimg_forY(*this,y){

           unsigned char *ptrd = imgData[y];

           cimg_forX(*this,x){

             *(ptrd++) = (unsigned char)*(pC0++);

             *(ptrd++) = (unsigned char)*(pC1++);

             *(ptrd++) = (unsigned char)*(pC2++);

             *(ptrd++) = (unsigned char)*(pC3++);

           }

         }

       } break;

       case 15 : { // Gray 16-bit

         cimg_forY(*this,y){

           unsigned short *ptrd = (unsigned short*)(imgData[y]);

           cimg_forX(*this,x) *(ptrd++) = (unsigned short)*(pC0++);

           if (!cimg::endianness()) cimg::invert_endianness((unsigned short*)imgData[y],width);

         }

       } break;

       case 30 : { // Gray w/ Alpha 16-bit

         const T *pC1 = ptr(0,0,0,1);

         cimg_forY(*this,y){

           unsigned short *ptrd = (unsigned short*)(imgData[y]);

           cimg_forX(*this,x) {

             *(ptrd++) = (unsigned short)*(pC0++);

             *(ptrd++) = (unsigned short)*(pC1++);

           }

           if (!cimg::endianness()) cimg::invert_endianness((unsigned short*)imgData[y],2*width);

         }

       } break;

       case 45 : { // RGB 16-bit

         const T *pC1 = ptr(0,0,0,1), *pC2 = ptr(0,0,0,2);

         cimg_forY(*this,y) {

           unsigned short *ptrd = (unsigned short*)(imgData[y]);

           cimg_forX(*this,x) {

             *(ptrd++) = (unsigned short)*(pC0++);

             *(ptrd++) = (unsigned short)*(pC1++);

             *(ptrd++) = (unsigned short)*(pC2++);

           }

           if (!cimg::endianness()) cimg::invert_endianness((unsigned short*)imgData[y],3*width);

         }

       } break;

       case 60 : { // RGB w/ Alpha 16-bit

         const T *pC1 = ptr(0,0,0,1), *pC2 = ptr(0,0,0,2), *pC3 = ptr(0,0,0,3);

         cimg_forY(*this,y) {

           unsigned short *ptrd = (unsigned short*)(imgData[y]);

           cimg_forX(*this,x) {

             *(ptrd++) = (unsigned short)*(pC0++);

             *(ptrd++) = (unsigned short)*(pC1++);

             *(ptrd++) = (unsigned short)*(pC2++);

             *(ptrd++) = (unsigned short)*(pC3++);

           }

           if (!cimg::endianness()) cimg::invert_endianness((unsigned short*)imgData[y],4*width);

         }

       } break;

       default :

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImg<%s>::save_png() : File '%s', unknown fatal error.",

                               pixel_type(),nfilename?nfilename:"(FILE*)");

       }

       png_write_image(png_ptr, imgData);

       png_write_end(png_ptr, info_ptr);

       png_destroy_write_struct(&png_ptr, &info_ptr);


       // Deallocate Image Write Memory

       cimg_forY(*this,n) delete[] imgData[n];

       delete[] imgData;

       if (!file) cimg::fclose(nfile);

       return *this;

 #endif

     }


     const CImg<T>& save_png(const char *const filename, const unsigned int bytes_per_pixel=0) const {

       return _save_png(0,filename,bytes_per_pixel);

     }


     const CImg<T>& save_png(std::FILE *const file, const unsigned int bytes_per_pixel=0) const {

       return _save_png(file,0,bytes_per_pixel);

     }


     // Save the image as a PNM file (internal function).

     const CImg<T>& _save_pnm(std::FILE *const file, const char *const filename, const unsigned int bytes_per_pixel=0) const {

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_pnm() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_pnm() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       double stmin, stmax = (double)maxmin(stmin);

       if (depth>1)

         cimg::warn("CImg<%s>::save_pnm() : File '%s', instance image (%u,%u,%u,%u,%p) is volumetric. Only the first slice will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (dim>3)

         cimg::warn("CImg<%s>::save_pnm() : File '%s', instance image (%u,%u,%u,%u,%p) is multispectral. Only the three first channels will be saved.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (stmin<0 || (bytes_per_pixel==1 && stmax>=256) || stmax>=65536)

         cimg::warn("CImg<%s>::save_pnm() : File '%s', instance image (%u,%u,%u,%u,%p) has pixel values in [%g,%g]. Probable type overflow.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data,stmin,stmax);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       const T

         *ptrR = ptr(0,0,0,0),

         *ptrG = (dim>=2)?ptr(0,0,0,1):0,

         *ptrB = (dim>=3)?ptr(0,0,0,2):0;

       const unsigned int buf_size = width*height*(dim==1?1:3);


       std::fprintf(nfile,"P%c\n# CREATOR: CImg Library (original size = %ux%ux%ux%u)\n%u %u\n%u\n",

                    (dim==1?'5':'6'),width,height,depth,dim,width,height,stmax<256?255:(stmax<4096?4095:65535));


       switch (dim) {

       case 1 : { // Scalar image

         if (bytes_per_pixel==1 || (!bytes_per_pixel && stmax<256)) { // Binary PGM 8 bits

           unsigned char *ptrd = new unsigned char[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) *(xptrd++) = (unsigned char)*(ptrR++);

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         } else {             // Binary PGM 16 bits

           unsigned short *ptrd = new unsigned short[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) *(xptrd++) = (unsigned short)*(ptrR++);

           if (!cimg::endianness()) cimg::invert_endianness(ptrd,buf_size);

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         }

       } break;

       case 2 : { // RG image

         if (bytes_per_pixel==1 || (!bytes_per_pixel && stmax<256)) { // Binary PPM 8 bits

           unsigned char *ptrd = new unsigned char[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) {

             *(xptrd++) = (unsigned char)*(ptrR++);

             *(xptrd++) = (unsigned char)*(ptrG++);

             *(xptrd++) = 0;

           }

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         } else {             // Binary PPM 16 bits

           unsigned short *ptrd = new unsigned short[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) {

             *(xptrd++) = (unsigned short)*(ptrR++);

             *(xptrd++) = (unsigned short)*(ptrG++);

             *(xptrd++) = 0;

           }

           if (!cimg::endianness()) cimg::invert_endianness(ptrd,buf_size);

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         }

       } break;

       default : { // RGB image

         if (bytes_per_pixel==1 || (!bytes_per_pixel && stmax<256)) { // Binary PPM 8 bits

           unsigned char *ptrd = new unsigned char[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) {

             *(xptrd++) = (unsigned char)*(ptrR++);

             *(xptrd++) = (unsigned char)*(ptrG++);

             *(xptrd++) = (unsigned char)*(ptrB++);

           }

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         } else {             // Binary PPM 16 bits

           unsigned short *ptrd = new unsigned short[buf_size], *xptrd = ptrd;

           cimg_forXY(*this,x,y) {

             *(xptrd++) = (unsigned short)*(ptrR++);

             *(xptrd++) = (unsigned short)*(ptrG++);

             *(xptrd++) = (unsigned short)*(ptrB++);

           }

           if (!cimg::endianness()) cimg::invert_endianness(ptrd,buf_size);

           cimg::fwrite(ptrd,buf_size,nfile);

           delete[] ptrd;

         }

       }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_pnm(const char *const filename, const unsigned int bytes_per_pixel=0) const {

       return _save_pnm(0,filename,bytes_per_pixel);

     }


     const CImg<T>& save_pnm(std::FILE *const file, const unsigned int bytes_per_pixel=0) const {

       return _save_pnm(file,0,bytes_per_pixel);

     }


     // Save the image as a RGB file (internal).

     const CImg<T>& _save_rgb(std::FILE *const file, const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_rgb() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_rgb() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (dim!=3)

         cimg::warn("CImg<%s>::save_rgb() : File '%s', instance image (%u,%u,%u,%u,%p) has not exactly 3 channels.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       const unsigned int wh = width*height;

       unsigned char *buffer = new unsigned char[3*wh], *nbuffer=buffer;

       const T

         *ptr1 = ptr(0,0,0,0),

         *ptr2 = dim>1?ptr(0,0,0,1):0,

         *ptr3 = dim>2?ptr(0,0,0,2):0;

       switch (dim) {

       case 1 : { // Scalar image

         for (unsigned int k = 0; k<wh; ++k) {

           const unsigned char val = (unsigned char)*(ptr1++);

           *(nbuffer++) = val;

           *(nbuffer++) = val;

           *(nbuffer++) = val;

         }} break;

       case 2 : { // RG image

         for (unsigned int k = 0; k<wh; ++k) {

           *(nbuffer++) = (unsigned char)(*(ptr1++));

           *(nbuffer++) = (unsigned char)(*(ptr2++));

           *(nbuffer++) = 0;

         }} break;

       default : { // RGB image

         for (unsigned int k = 0; k<wh; ++k) {

           *(nbuffer++) = (unsigned char)(*(ptr1++));

           *(nbuffer++) = (unsigned char)(*(ptr2++));

           *(nbuffer++) = (unsigned char)(*(ptr3++));

         }

       }

       }

       cimg::fwrite(buffer,3*wh,nfile);

       if (!file) cimg::fclose(nfile);

       delete[] buffer;

       return *this;

     }


     const CImg<T>& save_rgb(const char *const filename) const {

       return _save_rgb(0,filename);

     }


     const CImg<T>& save_rgb(std::FILE *const file) const {

       return _save_rgb(file,0);

     }


     // Save the image as a RGBA file (internal).

     const CImg<T>& _save_rgba(std::FILE *const file, const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_rgba() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_rgba() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (dim!=4)

         cimg::warn("CImg<%s>::save_rgba() : File '%s, instance image (%u,%u,%u,%u,%p) has not exactly 4 channels.",

                    pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       const unsigned int wh = width*height;

       unsigned char *buffer = new unsigned char[4*wh], *nbuffer=buffer;

       const T

         *ptr1 = ptr(0,0,0,0),

         *ptr2 = dim>1?ptr(0,0,0,1):0,

         *ptr3 = dim>2?ptr(0,0,0,2):0,

         *ptr4 = dim>3?ptr(0,0,0,3):0;

       switch (dim) {

       case 1 : { // Scalar images

         for (unsigned int k = 0; k<wh; ++k) {

           const unsigned char val = (unsigned char)*(ptr1++);

           *(nbuffer++) = val;

           *(nbuffer++) = val;

           *(nbuffer++) = val;

           *(nbuffer++) = 255;

         }} break;

       case 2 : { // RG images

         for (unsigned int k = 0; k<wh; ++k) {

           *(nbuffer++) = (unsigned char)(*(ptr1++));

           *(nbuffer++) = (unsigned char)(*(ptr2++));

           *(nbuffer++) = 0;

           *(nbuffer++) = 255;

         }} break;

       case 3 : { // RGB images

         for (unsigned int k = 0; k<wh; ++k) {

           *(nbuffer++) = (unsigned char)(*(ptr1++));

           *(nbuffer++) = (unsigned char)(*(ptr2++));

           *(nbuffer++) = (unsigned char)(*(ptr3++));

           *(nbuffer++) = 255;

         }} break;

       default : { // RGBA images

         for (unsigned int k = 0; k<wh; ++k) {

           *(nbuffer++) = (unsigned char)(*(ptr1++));

           *(nbuffer++) = (unsigned char)(*(ptr2++));

           *(nbuffer++) = (unsigned char)(*(ptr3++));

           *(nbuffer++) = (unsigned char)(*(ptr4++));

         }

       }

       }

       cimg::fwrite(buffer,4*wh,nfile);

       if (!file) cimg::fclose(nfile);

       delete[] buffer;

       return *this;

     }


     const CImg<T>& save_rgba(const char *const filename) const {

       return _save_rgba(0,filename);

     }


     const CImg<T>& save_rgba(std::FILE *const file) const {

       return _save_rgba(file,0);

     }


     // Save a plane into a tiff file

 #ifdef cimg_use_tiff


 #define _cimg_save_tif(types,typed) \

     if (!std::strcmp(types,pixel_type())) { const typed foo = (typed)0; return _save_tiff(tif,directory,foo); }


     template<typename t>

     const CImg<T>& _save_tiff(TIFF *tif, const unsigned int directory, const t& pixel_t) const {

       if (is_empty() || !tif || pixel_t) return *this;

       const char *const filename = TIFFFileName(tif);

       uint32 rowsperstrip = (uint32)-1;

       uint16 spp = dim, bpp = sizeof(t)*8, photometric, compression = COMPRESSION_NONE;

       if (spp==3 || spp==4) photometric = PHOTOMETRIC_RGB;

       else photometric = PHOTOMETRIC_MINISBLACK;

       TIFFSetDirectory(tif,directory);

       TIFFSetField(tif,TIFFTAG_IMAGEWIDTH,width);

       TIFFSetField(tif,TIFFTAG_IMAGELENGTH,height);

       TIFFSetField(tif,TIFFTAG_ORIENTATION,ORIENTATION_TOPLEFT);

       TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,spp);

       if (cimg::type<t>::is_float()) TIFFSetField(tif,TIFFTAG_SAMPLEFORMAT,3);

       else if (cimg::type<t>::min()==0) TIFFSetField(tif,TIFFTAG_SAMPLEFORMAT,1);

       else TIFFSetField(tif,TIFFTAG_SAMPLEFORMAT,2);

       TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,bpp);

       TIFFSetField(tif,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG);

       TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,photometric);

       TIFFSetField(tif,TIFFTAG_COMPRESSION,compression);

       rowsperstrip = TIFFDefaultStripSize(tif,rowsperstrip);

       TIFFSetField(tif,TIFFTAG_ROWSPERSTRIP,rowsperstrip);

       TIFFSetField(tif,TIFFTAG_FILLORDER,FILLORDER_MSB2LSB);

       TIFFSetField(tif,TIFFTAG_SOFTWARE,"CImg");

       t *const buf = (t*)_TIFFmalloc(TIFFStripSize(tif));

       if (buf) {

         for (unsigned int row = 0; row<height; row+=rowsperstrip) {

           uint32 nrow = (row + rowsperstrip>height?height-row:rowsperstrip);

           tstrip_t strip = TIFFComputeStrip(tif,row,0);

           tsize_t i = 0;

           for (unsigned int rr = 0; rr<nrow; ++rr)

             for (unsigned int cc = 0; cc<width; ++cc)

               for (unsigned int vv = 0; vv<spp; ++vv)

                 buf[i++] = (t)(*this)(cc,row + rr,0,vv);

           if (TIFFWriteEncodedStrip(tif,strip,buf,i*sizeof(t))<0)

             throw CImgException("CImg<%s>::save_tiff() : File '%s', an error has occured while writing a strip.",

                                 pixel_type(),filename?filename:"(FILE*)");

         }

         _TIFFfree(buf);

       }

       TIFFWriteDirectory(tif);

       return (*this);

     }


     const CImg<T>& _save_tiff(TIFF *tif, const unsigned int directory) const {

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;

       _cimg_save_tif("bool",uchar);

       _cimg_save_tif("char",char);

       _cimg_save_tif("unsigned char",uchar);

       _cimg_save_tif("short",short);

       _cimg_save_tif("unsigned short",ushort);

       _cimg_save_tif("int",int);

       _cimg_save_tif("unsigned int",uint);

       _cimg_save_tif("long",int);

       _cimg_save_tif("unsigned long",uint);

       _cimg_save_tif("float",float);

       _cimg_save_tif("double",float);

       const char *const filename = TIFFFileName(tif);

       throw CImgException("CImg<%s>::save_tiff() : File '%s', pixel type is not supported.",

                           pixel_type(),filename?filename:"(FILE*)");

       return *this;

     }

 #endif


     const CImg<T>& save_tiff(const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_tiff() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_tiff() : Specified filename is (null) for instance image (%u,%u,%u,%u,%p).",

                                     pixel_type(),width,height,depth,dim,data);

 #ifdef cimg_use_tiff

       TIFF *tif = TIFFOpen(filename,"w");

       if (tif) {

         cimg_forZ(*this,z) get_slice(z)._save_tiff(tif,z);

         TIFFClose(tif);

       } else throw CImgException("CImg<%s>::save_tiff() : File '%s', error while opening file stream for writing.",

                                  pixel_type(),filename);

 #else

       return save_other(filename);

 #endif

       return *this;

     }


     const CImg<T>& save_analyze(const char *const filename, const float *const voxsize=0) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_analyze() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_analyze() :  Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       std::FILE *file;

       char header[348] = { 0 }, hname[1024] = { 0 }, iname[1024] = { 0 };

       const char *ext = cimg::split_filename(filename);

       short datatype=-1;

       std::memset(header,0,348);

       if (!ext[0]) { std::sprintf(hname,"%s.hdr",filename); std::sprintf(iname,"%s.img",filename); }

       if (!cimg::strncasecmp(ext,"hdr",3)) {

         std::strcpy(hname,filename); std::strcpy(iname,filename); std::sprintf(iname+std::strlen(iname)-3,"img");

       }

       if (!cimg::strncasecmp(ext,"img",3)) {

         std::strcpy(hname,filename); std::strcpy(iname,filename); std::sprintf(hname+std::strlen(iname)-3,"hdr");

       }

       if (!cimg::strncasecmp(ext,"nii",3)) {

         std::strcpy(hname,filename); iname[0] = 0;

       }

       ((int*)(header))[0] = 348;

       std::sprintf(header+4,"CImg");

       std::sprintf(header+14," ");

       ((short*)(header+36))[0] = 4096;

       ((char*)(header+38))[0] = 114;

       ((short*)(header+40))[0] = 4;

       ((short*)(header+40))[1] = width;

       ((short*)(header+40))[2] = height;

       ((short*)(header+40))[3] = depth;

       ((short*)(header+40))[4] = dim;

       if (!cimg::strcasecmp(pixel_type(),"bool"))           datatype = 2;

       if (!cimg::strcasecmp(pixel_type(),"unsigned char"))  datatype = 2;

       if (!cimg::strcasecmp(pixel_type(),"char"))           datatype = 2;

       if (!cimg::strcasecmp(pixel_type(),"unsigned short")) datatype = 4;

       if (!cimg::strcasecmp(pixel_type(),"short"))          datatype = 4;

       if (!cimg::strcasecmp(pixel_type(),"unsigned int"))   datatype = 8;

       if (!cimg::strcasecmp(pixel_type(),"int"))            datatype = 8;

       if (!cimg::strcasecmp(pixel_type(),"unsigned long"))  datatype = 8;

       if (!cimg::strcasecmp(pixel_type(),"long"))           datatype = 8;

       if (!cimg::strcasecmp(pixel_type(),"float"))          datatype = 16;

       if (!cimg::strcasecmp(pixel_type(),"double"))         datatype = 64;

       if (datatype<0)

         throw CImgIOException("CImg<%s>::save_analyze() : Cannot save image '%s' since pixel type (%s)"

                               "is not handled in Analyze7.5 specifications.\n",

                               pixel_type(),filename,pixel_type());

       ((short*)(header+70))[0] = datatype;

       ((short*)(header+72))[0] = sizeof(T);

       ((float*)(header+112))[0] = 1;

       ((float*)(header+76))[0] = 0;

       if (voxsize) {

         ((float*)(header+76))[1] = voxsize[0];

         ((float*)(header+76))[2] = voxsize[1];

         ((float*)(header+76))[3] = voxsize[2];

       } else ((float*)(header+76))[1] = ((float*)(header+76))[2] = ((float*)(header+76))[3] = 1;

       file = cimg::fopen(hname,"wb");

       cimg::fwrite(header,348,file);

       if (iname[0]) { cimg::fclose(file); file = cimg::fopen(iname,"wb"); }

       cimg::fwrite(data,size(),file);

       cimg::fclose(file);

       return *this;

     }


     const CImg<T>& save_cimg(const char *const filename, const bool compress=false) const {

       CImgList<T>(*this,true).save_cimg(filename,compress);

       return *this;

     }


     // Save the image as a .cimg file.

     const CImg<T>& save_cimg(std::FILE *const file, const bool compress=false) const {

       CImgList<T>(*this,true).save_cimg(file,compress);

       return *this;

     }


     const CImg<T>& save_cimg(const char *const filename,

                              const unsigned int n0,

                              const unsigned int x0, const unsigned int y0,

                              const unsigned int z0, const unsigned int v0) const {

       CImgList<T>(*this,true).save_cimg(filename,n0,x0,y0,z0,v0);

       return *this;

     }


     const CImg<T>& save_cimg(std::FILE *const file,

                              const unsigned int n0,

                              const unsigned int x0, const unsigned int y0,

                              const unsigned int z0, const unsigned int v0) const {

       CImgList<T>(*this,true).save_cimg(file,n0,x0,y0,z0,v0);

       return *this;

     }


     static void save_empty_cimg(const char *const filename,

                                 const unsigned int dx, const unsigned int dy=1,

                                 const unsigned int dz=1, const unsigned int dv=1) {

       return CImgList<T>::save_empty_cimg(filename,1,dx,dy,dz,dv);

     }


     static void save_empty_cimg(std::FILE *const file,

                                 const unsigned int dx, const unsigned int dy=1,

                                 const unsigned int dz=1, const unsigned int dv=1) {

       return CImgList<T>::save_empty_cimg(file,1,dx,dy,dz,dv);

     }


     // Save the image as an INRIMAGE-4 file (internal).

     const CImg<T>& _save_inr(std::FILE *const file, const char *const filename, const float *const voxsize) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_inr() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_inr() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       int inrpixsize=-1;

       const char *inrtype = "unsigned fixed\nPIXSIZE=8 bits\nSCALE=2**0";

       if (!cimg::strcasecmp(pixel_type(),"unsigned char"))  { inrtype = "unsigned fixed\nPIXSIZE=8 bits\nSCALE=2**0"; inrpixsize = 1; }

       if (!cimg::strcasecmp(pixel_type(),"char"))           { inrtype = "fixed\nPIXSIZE=8 bits\nSCALE=2**0"; inrpixsize = 1; }

       if (!cimg::strcasecmp(pixel_type(),"unsigned short")) { inrtype = "unsigned fixed\nPIXSIZE=16 bits\nSCALE=2**0";inrpixsize = 2; }

       if (!cimg::strcasecmp(pixel_type(),"short"))          { inrtype = "fixed\nPIXSIZE=16 bits\nSCALE=2**0"; inrpixsize = 2; }

       if (!cimg::strcasecmp(pixel_type(),"unsigned int"))   { inrtype = "unsigned fixed\nPIXSIZE=32 bits\nSCALE=2**0";inrpixsize = 4; }

       if (!cimg::strcasecmp(pixel_type(),"int"))            { inrtype = "fixed\nPIXSIZE=32 bits\nSCALE=2**0"; inrpixsize = 4; }

       if (!cimg::strcasecmp(pixel_type(),"float"))          { inrtype = "float\nPIXSIZE=32 bits"; inrpixsize = 4; }

       if (!cimg::strcasecmp(pixel_type(),"double"))         { inrtype = "float\nPIXSIZE=64 bits"; inrpixsize = 8; }

       if (inrpixsize<=0)

         throw CImgIOException("CImg<%s>::save_inr() : Don't know how to save images of '%s'",

                               pixel_type(),pixel_type());

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       char header[257] = { 0 };

       int err = std::sprintf(header,"#INRIMAGE-4#{\nXDIM=%u\nYDIM=%u\nZDIM=%u\nVDIM=%u\n",width,height,depth,dim);

       if (voxsize) err += std::sprintf(header+err,"VX=%g\nVY=%g\nVZ=%g\n",voxsize[0],voxsize[1],voxsize[2]);

       err += std::sprintf(header+err,"TYPE=%s\nCPU=%s\n",inrtype,cimg::endianness()?"sun":"decm");

       std::memset(header+err,'\n',252-err);

       std::memcpy(header+252,"##}\n",4);

       cimg::fwrite(header,256,nfile);

       cimg_forXYZ(*this,x,y,z) cimg_forV(*this,k) cimg::fwrite(&((*this)(x,y,z,k)),1,nfile);

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_inr(const char *const filename, const float *const voxsize=0) const {

       return _save_inr(0,filename,voxsize);

     }


     const CImg<T>& save_inr(std::FILE *const file, const float *const voxsize=0) const {

       return _save_inr(file,0,voxsize);

     }


     // Save the image as a PANDORE-5 file (internal).

     unsigned int _save_pandore_header_length(unsigned int id, unsigned int *dims, const unsigned int colorspace) const {

       unsigned int nbdims = 0;

       if (id==2 || id==3 || id==4)    { dims[0] = 1;   dims[1] = width;  nbdims = 2; }

       if (id==5 || id==6 || id==7)    { dims[0] = 1;   dims[1] = height; dims[2] = width;  nbdims=3; }

       if (id==8 || id==9 || id==10)   { dims[0] = dim; dims[1] = depth;  dims[2] = height; dims[3] = width; nbdims = 4; }

       if (id==16 || id==17 || id==18) { dims[0] = 3;   dims[1] = height; dims[2] = width;  dims[3] = colorspace; nbdims = 4; }

       if (id==19 || id==20 || id==21) { dims[0] = 3;   dims[1] = depth;  dims[2] = height; dims[3] = width; dims[4] = colorspace; nbdims = 5; }

       if (id==22 || id==23 || id==25) { dims[0] = dim; dims[1] = width;  nbdims = 2; }

       if (id==26 || id==27 || id==29) { dims[0] = dim; dims[1] = height; dims[2] = width;  nbdims=3; }

       if (id==30 || id==31 || id==33) { dims[0] = dim; dims[1] = depth;  dims[2] = height; dims[3] = width; nbdims = 4; }

       return nbdims;

     }


     const CImg<T>& _save_pandore(std::FILE *const file, const char *const filename, const unsigned int colorspace) const {

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;


 #define __cimg_save_pandore_case(dtype) \

        dtype *buffer = new dtype[size()]; \

        const T *ptrs = data; \

        cimg_foroff(*this,off) *(buffer++) = (dtype)(*(ptrs++)); \

        buffer-=size(); \

        cimg::fwrite(buffer,size(),nfile); \

        delete[] buffer


 #define _cimg_save_pandore_case(sy,sz,sv,stype,id) \

       if (!saved && (sy?(sy==height):true) && (sz?(sz==depth):true) && (sv?(sv==dim):true) && !std::strcmp(stype,pixel_type())) { \

         unsigned int *iheader = (unsigned int*)(header+12); \

         nbdims = _save_pandore_header_length((*iheader=id),dims,colorspace); \

         cimg::fwrite(header,36,nfile); \

         if (sizeof(ulong)==4) { ulong ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (ulong)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \

         else if (sizeof(uint)==4) { uint ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (uint)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \

         else if (sizeof(ushort)==4) { ushort ndims[5] = { 0 }; for (int d = 0; d<5; ++d) ndims[d] = (ushort)dims[d]; cimg::fwrite(ndims,nbdims,nfile); } \

         else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \

                                    "supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \

                                    depth,dim,data); \

         if (id==2 || id==5 || id==8 || id==16 || id==19 || id==22 || id==26 || id==30) { \

           __cimg_save_pandore_case(uchar); \

         } else if (id==3 || id==6 || id==9 || id==17 || id==20 || id==23 || id==27 || id==31) { \

           if (sizeof(ulong)==4) { __cimg_save_pandore_case(ulong); } \

           else if (sizeof(uint)==4) { __cimg_save_pandore_case(uint); } \

           else if (sizeof(ushort)==4) { __cimg_save_pandore_case(ushort); } \

           else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \

                                      "supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \

                                      depth,dim,data); \

         } else if (id==4 || id==7 || id==10 || id==18 || id==21 || id==25 || id==29 || id==33) { \

           if (sizeof(double)==4) { __cimg_save_pandore_case(double); } \

           else if (sizeof(float)==4) { __cimg_save_pandore_case(float); } \

           else throw CImgIOException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p), output type is not" \

                                      "supported on this architecture.",pixel_type(),filename?filename:"(FILE*)",width,height, \

                                      depth,dim,data); \

         } \

         saved = true; \

       }


       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_pandore() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_pandore() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       unsigned char header[36] = { 'P','A','N','D','O','R','E','0','4',0,0,0,

                                    0,0,0,0,'C','I','m','g',0,0,0,0,0,'N','o',' ','d','a','t','e',0,0,0,0 };

       unsigned int nbdims, dims[5] = { 0 };

       bool saved = false;

       _cimg_save_pandore_case(1,1,1,"unsigned char",2);

       _cimg_save_pandore_case(1,1,1,"char",3);

       _cimg_save_pandore_case(1,1,1,"short",3);

       _cimg_save_pandore_case(1,1,1,"unsigned short",3);

       _cimg_save_pandore_case(1,1,1,"unsigned int",3);

       _cimg_save_pandore_case(1,1,1,"int",3);

       _cimg_save_pandore_case(1,1,1,"unsigned long",4);

       _cimg_save_pandore_case(1,1,1,"long",3);

       _cimg_save_pandore_case(1,1,1,"float",4);

       _cimg_save_pandore_case(1,1,1,"double",4);


       _cimg_save_pandore_case(0,1,1,"unsigned char",5);

       _cimg_save_pandore_case(0,1,1,"char",6);

       _cimg_save_pandore_case(0,1,1,"short",6);

       _cimg_save_pandore_case(0,1,1,"unsigned short",6);

       _cimg_save_pandore_case(0,1,1,"unsigned int",6);

       _cimg_save_pandore_case(0,1,1,"int",6);

       _cimg_save_pandore_case(0,1,1,"unsigned long",7);

       _cimg_save_pandore_case(0,1,1,"long",6);

       _cimg_save_pandore_case(0,1,1,"float",7);

       _cimg_save_pandore_case(0,1,1,"double",7);


       _cimg_save_pandore_case(0,0,1,"unsigned char",8);

       _cimg_save_pandore_case(0,0,1,"char",9);

       _cimg_save_pandore_case(0,0,1,"short",9);

       _cimg_save_pandore_case(0,0,1,"unsigned short",9);

       _cimg_save_pandore_case(0,0,1,"unsigned int",9);

       _cimg_save_pandore_case(0,0,1,"int",9);

       _cimg_save_pandore_case(0,0,1,"unsigned long",10);

       _cimg_save_pandore_case(0,0,1,"long",9);

       _cimg_save_pandore_case(0,0,1,"float",10);

       _cimg_save_pandore_case(0,0,1,"double",10);


       _cimg_save_pandore_case(0,1,3,"unsigned char",16);

       _cimg_save_pandore_case(0,1,3,"char",17);

       _cimg_save_pandore_case(0,1,3,"short",17);

       _cimg_save_pandore_case(0,1,3,"unsigned short",17);

       _cimg_save_pandore_case(0,1,3,"unsigned int",17);

       _cimg_save_pandore_case(0,1,3,"int",17);

       _cimg_save_pandore_case(0,1,3,"unsigned long",18);

       _cimg_save_pandore_case(0,1,3,"long",17);

       _cimg_save_pandore_case(0,1,3,"float",18);

       _cimg_save_pandore_case(0,1,3,"double",18);


       _cimg_save_pandore_case(0,0,3,"unsigned char",19);

       _cimg_save_pandore_case(0,0,3,"char",20);

       _cimg_save_pandore_case(0,0,3,"short",20);

       _cimg_save_pandore_case(0,0,3,"unsigned short",20);

       _cimg_save_pandore_case(0,0,3,"unsigned int",20);

       _cimg_save_pandore_case(0,0,3,"int",20);

       _cimg_save_pandore_case(0,0,3,"unsigned long",21);

       _cimg_save_pandore_case(0,0,3,"long",20);

       _cimg_save_pandore_case(0,0,3,"float",21);

       _cimg_save_pandore_case(0,0,3,"double",21);


       _cimg_save_pandore_case(1,1,0,"unsigned char",22);

       _cimg_save_pandore_case(1,1,0,"char",23);

       _cimg_save_pandore_case(1,1,0,"short",23);

       _cimg_save_pandore_case(1,1,0,"unsigned short",23);

       _cimg_save_pandore_case(1,1,0,"unsigned int",23);

       _cimg_save_pandore_case(1,1,0,"int",23);

       _cimg_save_pandore_case(1,1,0,"unsigned long",25);

       _cimg_save_pandore_case(1,1,0,"long",23);

       _cimg_save_pandore_case(1,1,0,"float",25);

       _cimg_save_pandore_case(1,1,0,"double",25);


       _cimg_save_pandore_case(0,1,0,"unsigned char",26);

       _cimg_save_pandore_case(0,1,0,"char",27);

       _cimg_save_pandore_case(0,1,0,"short",27);

       _cimg_save_pandore_case(0,1,0,"unsigned short",27);

       _cimg_save_pandore_case(0,1,0,"unsigned int",27);

       _cimg_save_pandore_case(0,1,0,"int",27);

       _cimg_save_pandore_case(0,1,0,"unsigned long",29);

       _cimg_save_pandore_case(0,1,0,"long",27);

       _cimg_save_pandore_case(0,1,0,"float",29);

       _cimg_save_pandore_case(0,1,0,"double",29);


       _cimg_save_pandore_case(0,0,0,"unsigned char",30);

       _cimg_save_pandore_case(0,0,0,"char",31);

       _cimg_save_pandore_case(0,0,0,"short",31);

       _cimg_save_pandore_case(0,0,0,"unsigned short",31);

       _cimg_save_pandore_case(0,0,0,"unsigned int",31);

       _cimg_save_pandore_case(0,0,0,"int",31);

       _cimg_save_pandore_case(0,0,0,"unsigned long",33);

       _cimg_save_pandore_case(0,0,0,"long",31);

       _cimg_save_pandore_case(0,0,0,"float",33);

       _cimg_save_pandore_case(0,0,0,"double",33);


       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_pandore(const char *const filename, const unsigned int colorspace=0) const {

       return _save_pandore(0,filename,colorspace);

     }


     const CImg<T>& save_pandore(std::FILE *const file, const unsigned int colorspace=0) const {

       return _save_pandore(file,0,colorspace);

     }


    // Save the image as a RAW file (internal).

     const CImg<T>& _save_raw(std::FILE *const file, const char *const filename, const bool multiplexed) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_raw() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_raw() : Instance image (%u,%u,%u,%u,%p), specified file is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       if (!multiplexed) cimg::fwrite(data,size(),nfile);

       else {

         CImg<T> buf(dim);

         cimg_forXYZ(*this,x,y,z) {

           cimg_forV(*this,k) buf[k] = (*this)(x,y,z,k);

           cimg::fwrite(buf.data,dim,nfile);

         }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImg<T>& save_raw(const char *const filename, const bool multiplexed=false) const {

       return _save_raw(0,filename,multiplexed);

     }


     const CImg<T>& save_raw(std::FILE *const file, const bool multiplexed=false) const {

       return _save_raw(file,0,multiplexed);

     }


     const CImg<T>& save_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                const unsigned int fps=25) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_ffmpeg() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_ffmpeg() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       if (!fps)

         throw CImgArgumentException("CImg<%s>::save_ffmpeg() : File '%s', specified framerate is 0.",

                                     pixel_type(),filename);

 #ifndef cimg_use_ffmpeg

       return save_ffmpeg_external(filename,first_frame,last_frame);

 #else

       get_split('z').save_ffmpeg(filename,first_frame,last_frame,fps);

 #endif

       return *this;

     }


     const CImg<T>& save_yuv(const char *const filename, const bool rgb2yuv=true) const {

       get_split('z').save_yuv(filename,rgb2yuv);

       return *this;

     }


     const CImg<T>& save_yuv(std::FILE *const file, const bool rgb2yuv=true) const {

       get_split('z').save_yuv(file,rgb2yuv);

       return *this;

     }


    // Save OFF files (internal).

     template<typename tf, typename tc>

     const CImg<T>& _save_off(std::FILE *const file, const char *const filename,

                              const CImgList<tf>& primitives, const CImgList<tc>& colors) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_off() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,height,depth,dim,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_off() : Specified filename is (null).",

                                     pixel_type());

       if (height<3) return get_resize(-100,3,1,1,0)._save_off(file,filename,primitives,colors);

       CImgList<tc> _colors;

       if (!colors) _colors.insert(primitives.width,CImg<tc>::vector(200,200,200));

       const CImgList<tc>& ncolors = colors?colors:_colors;


       std::FILE *const nfile = file?file:cimg::fopen(filename,"w");

       std::fprintf(nfile,"OFF\n%u %u %u\n",width,primitives.width,3*primitives.width);

       cimg_forX(*this,i) std::fprintf(nfile,"%f %f %f\n",(float)((*this)(i,0)),(float)((*this)(i,1)),(float)((*this)(i,2)));

       cimglist_for(primitives,l) {

         const unsigned int prim = primitives[l].size();

         const bool textured = (prim>4);

         const CImg<tc>& color = ncolors[l];

         const unsigned int s = textured?color.dimv():color.size();

         const float

           r = textured?(s>0?(float)(color.get_shared_channel(0).mean()/255.0f):1.0f):(s>0?(float)(color(0)/255.0f):1.0f),

           g = textured?(s>1?(float)(color.get_shared_channel(1).mean()/255.0f):r)   :(s>1?(float)(color(1)/255.0f):r),

           b = textured?(s>2?(float)(color.get_shared_channel(2).mean()/255.0f):r)   :(s>2?(float)(color(2)/255.0f):r);


         switch (prim) {

         case 1 :

           std::fprintf(nfile,"1 %u %f %f %f\n",(unsigned int)primitives(l,0),r,g,b);

           break;

         case 2 : case 6 :

           std::fprintf(nfile,"2 %u %u %f %f %f\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,1),r,g,b);

           break;

         case 3 : case 9 :

           std::fprintf(nfile,"3 %u %u %u %f %f %f\n",(unsigned int)primitives(l,0),(unsigned int)primitives(l,2),

                        (unsigned int)primitives(l,1),r,g,b);

           break;

         case 4 : case 12 :

           std::fprintf(nfile,"4 %u %u %u %u %f %f %f\n",

                        (unsigned int)primitives(l,0),(unsigned int)primitives(l,3),(unsigned int)primitives(l,2),

                        (unsigned int)primitives(l,1),r,g,b);

           break;

         }

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     template<typename tf, typename tc>

     const CImg<T>& save_off(const char *const filename,

                             const CImgList<tf>& primitives, const CImgList<tc>& colors) const {

       return _save_off(0,filename,primitives,colors);

     }


     template<typename tf, typename tc>

     const CImg<T>& save_off(std::FILE *const file,

                             const CImgList<tf>& primitives, const CImgList<tc>& colors) const {

       return _save_off(file,0,primitives,colors);

     }


     const CImg<T>& save_ffmpeg_external(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                         const char *const codec="mpeg2video") const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_ffmpeg_external() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_ffmpeg_external() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       get_split('z').save_ffmpeg_external(filename,first_frame,last_frame,codec);

       return *this;

     }


     const CImg<T>& save_graphicsmagick_external(const char *const filename, const unsigned int quality=100) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_graphicsmagick_external() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_graphicsmagick_external() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       char command[1024] = { 0 }, filetmp[512] = { 0 };

       std::FILE *file;

       do {

         if (dim==1) std::sprintf(filetmp,"%s%c%s.pgm",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         else std::sprintf(filetmp,"%s%c%s.ppm",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       save_pnm(filetmp);

       std::sprintf(command,"%s -quality %u%% %s \"%s\"",cimg::graphicsmagick_path(),quality,filetmp,filename);

       cimg::system(command);

       file = std::fopen(filename,"rb");

       if (!file)

         throw CImgIOException("CImg<%s>::save_graphicsmagick_external() : Failed to save image '%s'.\n\n"

                               "Path of 'gm' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"\n",

                               pixel_type(),filename,cimg::graphicsmagick_path(),filetmp);

       if (file) cimg::fclose(file);

       std::remove(filetmp);

       return *this;

     }


     const CImg<T>& save_gzip_external(const char *const filename) const {

       if (!filename)

         throw CImgIOException("CImg<%s>::save_gzip_external() : Cannot save (null) filename.",

                               pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       const char

         *ext = cimg::split_filename(filename,body),

         *ext2 = cimg::split_filename(body,0);

       std::FILE *file;

       do {

         if (!cimg::strcasecmp(ext,"gz")) {

           if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);

           else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         } else {

           if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);

           else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         }

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       save(filetmp);

       std::sprintf(command,"%s -c %s > \"%s\"",cimg::gzip_path(),filetmp,filename);

       cimg::system(command);

       file = std::fopen(filename,"rb");

       if (!file)

         throw CImgIOException("CImgList<%s>::save_gzip_external() : File '%s' cannot be saved.",

                               pixel_type(),filename);

       else cimg::fclose(file);

       std::remove(filetmp);

       return *this;

     }


     const CImg<T>& save_imagemagick_external(const char *const filename, const unsigned int quality=100) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_imagemagick_external() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_imagemagick_external() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);

       char command[1024] = { 0 }, filetmp[512] = { 0 };

       std::FILE *file;

       do {

         std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),dim==1?"pgm":"ppm");

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       save_pnm(filetmp);

       std::sprintf(command,"%s -quality %u%% %s \"%s\"",cimg::imagemagick_path(),quality,filetmp,filename);

       cimg::system(command);

       file = std::fopen(filename,"rb");

       if (!file)

         throw CImgIOException("CImg<%s>::save_imagemagick_external() : Failed to save image '%s'.\n\n"

                               "Path of 'convert' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"\n",

                               pixel_type(),filename,cimg::imagemagick_path(),filetmp);

       if (file) cimg::fclose(file);

       std::remove(filetmp);

       return *this;

     }


     const CImg<T>& save_medcon_external(const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_medcon_external() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save_medcon_external() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                                     pixel_type(),width,height,depth,dim,data);


       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       std::FILE *file;

       do {

         std::sprintf(filetmp,"%s.hdr",cimg::filenamerand());

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       save_analyze(filetmp);

       std::sprintf(command,"%s -w -c dicom -o %s -f %s",cimg::medcon_path(),filename,filetmp);

       cimg::system(command);

       std::remove(filetmp);

       cimg::split_filename(filetmp,body);

       std::sprintf(filetmp,"%s.img",body);

       std::remove(filetmp);

       std::sprintf(command,"m000-%s",filename);

       file = std::fopen(command,"rb");

       if (!file) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::save_medcon_external() : Failed to save image '%s'.\n\n"

                               "Path of 'medcon' : \"%s\"\n"

                               "Path of temporary filename : \"%s\"",

                               pixel_type(),filename,cimg::medcon_path(),filetmp);

       } else cimg::fclose(file);

       std::rename(command,filename);

       return *this;

     }


     // Try to save the image if other extension is provided.

     const CImg<T>& save_other(const char *const filename, const unsigned int quality=100) const {

       if (is_empty())

         throw CImgInstanceException("CImg<%s>::save_other() : File '%s', instance image (%u,%u,%u,%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,height,depth,dim,data);

       if (!filename)

         throw CImgIOException("CImg<%s>::save_other() : Instance image (%u,%u,%u,%u,%p), specified filename is (null).",

                               pixel_type());

       const unsigned int omode = cimg::exception_mode();

       bool is_saved = true;

       cimg::exception_mode() = 0;

       try { save_magick(filename); }

       catch (CImgException&) {

         try { save_imagemagick_external(filename,quality); }

         catch (CImgException&) {

           try { save_graphicsmagick_external(filename,quality); }

           catch (CImgException&) {

             is_saved = false;

           }

         }

       }

       cimg::exception_mode() = omode;

       if (!is_saved)

         throw CImgIOException("CImg<%s>::save_other() : File '%s' cannot be saved.\n"

                               "Check you have either the ImageMagick or GraphicsMagick package installed.",

                               pixel_type(),filename);

       return *this;

     }


     // Get a 40x38 color logo of a 'danger' item (internal).

     static CImg<T> logo40x38() {

       static bool first_time = true;

       static CImg<T> res(40,38,1,3);

       if (first_time) {

         const unsigned char *ptrs = cimg::logo40x38;

         T *ptr1 = res.ptr(0,0,0,0), *ptr2 = res.ptr(0,0,0,1), *ptr3 = res.ptr(0,0,0,2);

         for (unsigned int off = 0; off<res.width*res.height;) {

           const unsigned char n = *(ptrs++), r = *(ptrs++), g = *(ptrs++), b = *(ptrs++);

           for (unsigned int l = 0; l<n; ++off, ++l) { *(ptr1++) = (T)r; *(ptr2++) = (T)g; *(ptr3++) = (T)b; }

         }

         first_time = false;

       }

       return res;

     }


   };


   /*

    #-----------------------------------------

    #

    #

    #

    # Definition of the CImgList<T> structure

    #

    #

    #

    #------------------------------------------

    */


   template<typename T>

   struct CImgList {


     unsigned int width;


     unsigned int allocated_width;


     CImg<T> *data;


     typedef CImg<T>* iterator;


     typedef const CImg<T>* const_iterator;


     typedef T value_type;


     // Define common T-dependant types.

     typedef typename cimg::superset<T,bool>::type Tbool;

     typedef typename cimg::superset<T,unsigned char>::type Tuchar;

     typedef typename cimg::superset<T,char>::type Tchar;

     typedef typename cimg::superset<T,unsigned short>::type Tushort;

     typedef typename cimg::superset<T,short>::type Tshort;

     typedef typename cimg::superset<T,unsigned int>::type Tuint;

     typedef typename cimg::superset<T,int>::type Tint;

     typedef typename cimg::superset<T,unsigned long>::type Tulong;

     typedef typename cimg::superset<T,long>::type Tlong;

     typedef typename cimg::superset<T,float>::type Tfloat;

     typedef typename cimg::superset<T,double>::type Tdouble;

     typedef typename cimg::last<T,bool>::type boolT;

     typedef typename cimg::last<T,unsigned char>::type ucharT;

     typedef typename cimg::last<T,char>::type charT;

     typedef typename cimg::last<T,unsigned short>::type ushortT;

     typedef typename cimg::last<T,short>::type shortT;

     typedef typename cimg::last<T,unsigned int>::type uintT;

     typedef typename cimg::last<T,int>::type intT;

     typedef typename cimg::last<T,unsigned long>::type ulongT;

     typedef typename cimg::last<T,long>::type longT;

     typedef typename cimg::last<T,float>::type floatT;

     typedef typename cimg::last<T,double>::type doubleT;


     //---------------------------

     //


     //---------------------------

 #ifdef cimglist_plugin

 #include cimglist_plugin

 #endif

 #ifdef cimglist_plugin1

 #include cimglist_plugin1

 #endif

 #ifdef cimglist_plugin2

 #include cimglist_plugin2

 #endif

 #ifdef cimglist_plugin3

 #include cimglist_plugin3

 #endif

 #ifdef cimglist_plugin4

 #include cimglist_plugin4

 #endif

 #ifdef cimglist_plugin5

 #include cimglist_plugin5

 #endif

 #ifdef cimglist_plugin6

 #include cimglist_plugin6

 #endif

 #ifdef cimglist_plugin7

 #include cimglist_plugin7

 #endif

 #ifdef cimglist_plugin8

 #include cimglist_plugin8

 #endif


     //--------------------------------------------------------

     //


     //--------------------------------------------------------


     ~CImgList() {

       if (data) delete[] data;

     }


     CImgList():

       width(0),allocated_width(0),data(0) {}


     explicit CImgList(const unsigned int n):width(n) {

       data = new CImg<T>[allocated_width = cimg::max(16UL,cimg::nearest_pow2(n))];

     }


     CImgList(const unsigned int n, const unsigned int width, const unsigned int height=1,

              const unsigned int depth=1, const unsigned int dim=1):

       width(0),allocated_width(0),data(0) {

       assign(n);

       cimglist_apply(*this,assign)(width,height,depth,dim);

     }


     CImgList(const unsigned int n, const unsigned int width, const unsigned int height,

              const unsigned int depth, const unsigned int dim, const T val):

       width(0),allocated_width(0),data(0) {

       assign(n);

       cimglist_apply(*this,assign)(width,height,depth,dim,val);

     }


     CImgList(const unsigned int n, const unsigned int width, const unsigned int height,

              const unsigned int depth, const unsigned int dim, const int val0, const int val1, ...):

       width(0),allocated_width(0),data(0) {

 #define _CImgList_stdarg(t) { \

         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); \

       }

       _CImgList_stdarg(int);

     }


     CImgList(const unsigned int n, const unsigned int width, const unsigned int height,

              const unsigned int depth, const unsigned int dim, const double val0, const double val1, ...):

       width(0),allocated_width(0),data(0) {

       _CImgList_stdarg(double);

     }


     template<typename t>

     CImgList(const unsigned int n, const CImg<t>& img, const bool shared=false):width(0),allocated_width(0),data(0) {

       assign(n);

       cimglist_apply(*this,assign)(img,shared);

     }


     template<typename t>

     explicit CImgList(const CImg<t>& img, const bool shared=false):width(0),allocated_width(0),data(0) {

       assign(1);

       data[0].assign(img,shared);

     }


     template<typename t1, typename t2>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const bool shared=false):width(0),allocated_width(0),data(0) {

       assign(2);

       data[0].assign(img1,shared); data[1].assign(img2,shared);

     }


     template<typename t1, typename t2, typename t3>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(3);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared);

     }


     template<typename t1, typename t2, typename t3, typename t4>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(4);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

              const CImg<t5>& img5, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(5);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared);

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

              const CImg<t5>& img5, const CImg<t6>& img6, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(6);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared);

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6, typename t7>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

              const CImg<t5>& img5, const CImg<t6>& img6, const CImg<t7>& img7, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(7);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared);

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6, typename t7, typename t8>

     CImgList(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

              const CImg<t5>& img5, const CImg<t6>& img6, const CImg<t7>& img7, const CImg<t8>& img8, const bool shared=false):

       width(0),allocated_width(0),data(0) {

       assign(8);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared); data[7].assign(img8,shared);

     }


     template<typename t>

     CImgList(const CImgList<t>& list):width(0),allocated_width(0),data(0) {

       assign(list.width);

       cimglist_for(*this,l) data[l].assign(list[l],false);

     }


     CImgList(const CImgList<T>& list):width(0),allocated_width(0),data(0) {

       assign(list.width);

       cimglist_for(*this,l) data[l].assign(list[l],list[l].is_shared);

     }


     template<typename t>

     CImgList(const CImgList<t>& list, const bool shared):width(0),allocated_width(0),data(0) {

       assign(list.width);

       cimglist_for(*this,l) data[l].assign(list[l],shared);

     }


     explicit CImgList(const char *const filename):width(0),allocated_width(0),data(0) {

       assign(filename);

     }


     explicit CImgList(const CImgDisplay &disp):width(0),allocated_width(0),data(0) {

       assign(disp);

     }


     CImgList<T> get_shared() {

       CImgList<T> res(width);

       cimglist_for(*this,l) res[l].assign(data[l],true);

       return res;

     }


     const CImgList<T> get_shared() const {

       CImgList<T> res(width);

       cimglist_for(*this,l) res[l].assign(data[l],true);

       return res;

     }


     CImgList<T>& clear() {

       return assign();

     }


     CImgList<T>& assign() {

       if (data) delete[] data;

       width = allocated_width = 0;

       data = 0;

       return *this;

     }


     CImgList<T>& assign(const unsigned int n) {

       if (n) {

         if (allocated_width<n || allocated_width>(n<<2)) {

           if (data) delete[] data;

           data = new CImg<T>[allocated_width=cimg::max(16UL,cimg::nearest_pow2(n))];

         }

         width = n;

       } else assign();

       return *this;

     }


     CImgList<T>& assign(const unsigned int n, const unsigned int width, const unsigned int height=1,

                         const unsigned int depth=1, const unsigned int dim=1) {

       assign(n);

       cimglist_apply(*this,assign)(width,height,depth,dim);

       return *this;

     }


     CImgList<T>& assign(const unsigned int n, const unsigned int width, const unsigned int height,

                         const unsigned int depth, const unsigned int dim, const T val) {

       assign(n);

       cimglist_apply(*this,assign)(width,height,depth,dim,val);

       return *this;

     }


     CImgList<T>& assign(const unsigned int n, const unsigned int width, const unsigned int height,

                         const unsigned int depth, const unsigned int dim, const int val0, const int val1, ...) {

       _CImgList_stdarg(int);

       return *this;

     }


     CImgList<T>& assign(const unsigned int n, const unsigned int width, const unsigned int height,

                         const unsigned int depth, const unsigned int dim, const double val0, const double val1, ...) {

       _CImgList_stdarg(double);

       return *this;

     }


     template<typename t>

     CImgList<T>& assign(const CImgList<t>& list, const bool shared=false) {

       assign(list.width);

       cimglist_for(*this,l) data[l].assign(list[l],shared);

       return *this;

     }


     template<typename t>

     CImgList<T>& assign(const unsigned int n, const CImg<t>& img, const bool shared=false) {

       assign(n);

       cimglist_apply(*this,assign)(img,shared);

       return *this;

     }


     template<typename t>

     CImgList<T>& assign(const CImg<t>& img, const bool shared=false) {

       assign(1);

       data[0].assign(img,shared);

       return *this;

     }


     template<typename t1, typename t2>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const bool shared=false) {

       assign(2);

       data[0].assign(img1,shared); data[1].assign(img2,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const bool shared=false) {

       assign(3);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3, typename t4>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

                         const bool shared=false) {

       assign(4);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

                         const CImg<t5>& img5, const bool shared=false) {

       assign(5);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

                         const CImg<t5>& img5, const CImg<t6>& img6, const bool shared=false) {

       assign(6);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6, typename t7>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

                         const CImg<t5>& img5, const CImg<t6>& img6, const CImg<t7>& img7, const bool shared=false) {

       assign(7);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared);

       return *this;

     }


     template<typename t1, typename t2, typename t3, typename t4, typename t5, typename t6, typename t7, typename t8>

     CImgList<T>& assign(const CImg<t1>& img1, const CImg<t2>& img2, const CImg<t3>& img3, const CImg<t4>& img4,

                         const CImg<t5>& img5, const CImg<t6>& img6, const CImg<t7>& img7, const CImg<t8>& img8,

                         const bool shared=false) {

       assign(8);

       data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);

       data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared); data[7].assign(img8,shared);

       return *this;

     }


     CImgList<T>& assign(const char *const filename) {

       return load(filename);

     }


     CImgList<T>& assign(const CImgDisplay &disp) {

       return assign(CImg<T>(disp));

     }


     template<typename t>

     CImgList<T>& transfer_to(CImgList<t>& list) {

       list.assign(size());

       cimglist_for(*this,l) data[l].transfer_to(list[l]);

       assign();

       return list;

     }


     CImgList<T>& transfer_to(CImgList<T>& list) {

       list.assign();

       return swap(list);

     }


     template<typename t>

     CImgList<t>& transfer_to(CImgList<t>& list, const unsigned int pos) {

       if (is_empty()) return list;

       const unsigned int npos = pos>list.width?list.width:pos;

       list.insert(width,npos);

       cimglist_for(*this,l) (*this)[l].transfer_to(list.at(npos+l));

       assign();

       return list;

     }


     CImgList<T>& swap(CImgList<T>& list) {

       cimg::swap(width,list.width);

       cimg::swap(allocated_width,list.allocated_width);

       cimg::swap(data,list.data);

       return list;

     }


     static CImgList<T>& empty() {

       static CImgList<T> _empty;

       return _empty.assign();

     }


     //------------------------------------------

     //


     //------------------------------------------


     CImg<T>& operator[](const unsigned int pos) {

 #if cimg_debug>=3

       if (pos>=width) {

         cimg::warn("CImgList<%s>::operator[] : bad list position %u, in a list of %u images",

                    pixel_type(),pos,width);

         return *data;

       }

 #endif

       return data[pos];

     }


     const CImg<T>& operator[](const unsigned int pos) const {

 #if cimg_debug>=3

       if (pos>=width) {

         cimg::warn("CImgList<%s>::operator[] : bad list position %u, in a list of %u images",

                    pixel_type(),pos,width);

         return *data;

       }

 #endif

       return data[pos];

     }


     CImg<T>& operator()(const unsigned int pos) {

       return (*this)[pos];

     }


     const CImg<T>& operator()(const unsigned int pos) const {

       return (*this)[pos];

     }


     T& operator()(const unsigned int pos, const unsigned int x, const unsigned int y=0,

                   const unsigned int z=0, const unsigned int v=0) {

       return (*this)[pos](x,y,z,v);

     }

     const T& operator()(const unsigned int pos, const unsigned int x, const unsigned int y=0,

                         const unsigned int z=0, const unsigned int v=0) const {

       return (*this)[pos](x,y,z,v);

     }


     operator bool() const {

       return !is_empty();

     }


     template<typename t>

     CImgList<T>& operator=(const CImg<t>& img) {

       return assign(img);

     }


     CImgList<T>& operator=(const CImgDisplay& disp) {

       return assign(disp);

     }


     template<typename t>

     CImgList<T>& operator=(const CImgList<t>& list) {

       return assign(list);

     }


     CImgList<T>& operator=(const CImgList<T>& list) {

       return assign(list);

     }


     CImgList<T>& operator=(const char *const filename) {

       return assign(filename);

     }


     CImgList<T> operator+() const {

       return CImgList<T>(*this,false);

     }


     template<typename t>

     CImgList<T>& operator,(const CImg<t>& img) {

       return insert(img);

     }


     template<typename t>

     CImgList<T>& operator,(const CImgList<t>& list) {

       return insert(list);

     }


     CImg<T> operator>(const char axis) const {

       return get_append(axis,'p');

     }


     CImgList<T> operator<(const char axis) const {

       return get_split(axis);

     }


     //-------------------------------------

     //


     //-------------------------------------


     static const char* pixel_type() {

       return cimg::type<T>::string();

     }


     int dimx() const {

       return (int)width;

     }


     unsigned int size() const {

       return width;

     }


     CImg<T> *ptr() {

       return data;

     }


     const CImg<T> *ptr() const {

       return data;

     }


 #if cimg_debug>=3

     CImg<T> *ptr(const unsigned int l) {

       if (l>=size()) {

         cimg::warn("CImgList<%s>::ptr() : Asked for a pointer at position %u, outside the list range %u",

                    pixel_type(),l,size());

         return data;

       }

       return data + l;

     }


     const CImg<T> *ptr(const unsigned int l) const {

       return const_cast<CImgList<T>*>(this)->ptr(l);

     }

 #else

     CImg<T> *ptr(const unsigned int l) {

       return data + l;

     }


     const CImg<T> *ptr(const unsigned int l) const {

       return data + l;

     }

 #endif


     iterator begin() {

       return data;

     }


     const_iterator begin() const {

       return data;

     }


     iterator end() {

       return data + width;

     }


     const_iterator end() const {

       return data + width;

     }


     CImg<T>& front() {

       return *data;

     }


     const CImg<T>& front() const {

       return *data;

     }


     const CImg<T>& back() const {

       return *(data + width - 1);

     }


     CImg<T>& back() {

       return *(data + width - 1);

     }


     CImg<T>& at(const int pos) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::at() : Instance list is empty.",

                                     pixel_type());

       return data[pos<0?0:pos>=(int)width?(int)width-1:pos];

     }


     T& atNXYZV(const int pos, const int x, const int y, const int z, const int v, const T out_val) {

       return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXYZV(x,y,z,v,out_val);

     }


     T atNXYZV(const int pos, const int x, const int y, const int z, const int v, const T out_val) const {

       return (pos<0 || pos>=(int)width)?out_val:data[pos].atXYZV(x,y,z,v,out_val);

     }


     T& atNXYZV(const int pos, const int x, const int y, const int z, const int v) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXYZV() : Instance list is empty.",

                                     pixel_type());

       return _atNXYZV(pos,x,y,z,v);

     }


     T atNXYZV(const int pos, const int x, const int y, const int z, const int v) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXYZV() : Instance list is empty.",

                                     pixel_type());

       return _atNXYZV(pos,x,y,z,v);

     }


     T& _atNXYZV(const int pos, const int x, const int y, const int z, const int v) {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZV(x,y,z,v);

     }


     T _atNXYZV(const int pos, const int x, const int y, const int z, const int v) const {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZV(x,y,z,v);

     }


     T& atNXYZ(const int pos, const int x, const int y, const int z, const int v, const T out_val) {

       return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXYZ(x,y,z,v,out_val);

     }


     T atNXYZ(const int pos, const int x, const int y, const int z, const int v, const T out_val) const {

       return (pos<0 || pos>=(int)width)?out_val:data[pos].atXYZ(x,y,z,v,out_val);

     }


     T& atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXYZ() : Instance list is empty.",

                                     pixel_type());

       return _atNXYZ(pos,x,y,z,v);

     }


     T atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXYZ() : Instance list is empty.",

                                     pixel_type());

       return _atNXYZ(pos,x,y,z,v);

     }


     T& _atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZ(x,y,z,v);

     }


     T _atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) const {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZ(x,y,z,v);

     }


     T& atNXY(const int pos, const int x, const int y, const int z, const int v, const T out_val) {

       return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXY(x,y,z,v,out_val);

     }


     T atNXY(const int pos, const int x, const int y, const int z, const int v, const T out_val) const {

       return (pos<0 || pos>=(int)width)?out_val:data[pos].atXY(x,y,z,v,out_val);

     }


     T& atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXY() : Instance list is empty.",

                                     pixel_type());

       return _atNXY(pos,x,y,z,v);

     }


     T atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNXY() : Instance list is empty.",

                                     pixel_type());

       return _atNXY(pos,x,y,z,v);

     }


     T& _atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXY(x,y,z,v);

     }


     T _atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) const {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXY(x,y,z,v);

     }


     T& atNX(const int pos, const int x, const int y, const int z, const int v, const T out_val) {

       return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atX(x,y,z,v,out_val);

     }


     T atNX(const int pos, const int x, const int y, const int z, const int v, const T out_val) const {

       return (pos<0 || pos>=(int)width)?out_val:data[pos].atX(x,y,z,v,out_val);

     }


     T& atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNX() : Instance list is empty.",

                                     pixel_type());

       return _atNX(pos,x,y,z,v);

     }


     T atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atNX() : Instance list is empty.",

                                     pixel_type());

       return _atNX(pos,x,y,z,v);

     }


     T& _atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atX(x,y,z,v);

     }


     T _atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) const {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atX(x,y,z,v);

     }


     T& atN(const int pos, const int x, const int y, const int z, const int v, const T out_val) {

       return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):(*this)(pos,x,y,z,v);

     }


     T atN(const int pos, const int x, const int y, const int z, const int v, const T out_val) const {

       return (pos<0 || pos>=(int)width)?out_val:(*this)(pos,x,y,z,v);

     }


     T& atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atN() : Instance list is empty.",

                                     pixel_type());

       return _atN(pos,x,y,z,v);

     }


     T atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::atN() : Instance list is empty.",

                                     pixel_type());

       return _atN(pos,x,y,z,v);

     }


     T& _atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)](x,y,z,v);

     }


     T _atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const {

       return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)](x,y,z,v);

     }


     CImg<charT> value_string(const char separator=',', const unsigned int max_size=0) const {

       if (is_empty()) return CImg<ucharT>(1,1,1,1,0);

       CImgList<charT> items;

       for (unsigned int l = 0; l<width-1; ++l) {

         CImg<charT> item = data[l].value_string(separator,0);

         item.back() = separator;

         item.transfer_to(items);

       }

       data[width-1].value_string(separator,0).transfer_to(items);

       CImg<charT> res; (items>'x').transfer_to(res);

       if (max_size) { res.crop(0,max_size); res(max_size) = 0; }

       return res;

     }


     //-------------------------------------

     //


     //-------------------------------------


     bool is_empty() const {

       return (!data || !width);

     }


     bool is_sameN(const unsigned int n) const {

       return (width==n);

     }


     template<typename t>

     bool is_sameN(const CImgList<t>& list) const {

       return (width==list.width);

     }


     // Define useful dimension check functions.

     // (not documented because they are macro-generated).

 #define _cimglist_def_is_same1(axis) \

     bool is_same##axis(const unsigned int val) const { \

       bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis(val); return res; \

     } \

     bool is_sameN##axis(const unsigned int n, const unsigned int val) const { \

       return is_sameN(n) && is_same##axis(val); \

     } \


 #define _cimglist_def_is_same2(axis1,axis2) \

     bool is_same##axis1##axis2(const unsigned int val1, const unsigned int val2) const { \

       bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis1##axis2(val1,val2); return res; \

     } \

     bool is_sameN##axis1##axis2(const unsigned int n, const unsigned int val1, const unsigned int val2) const { \

       return is_sameN(n) && is_same##axis1##axis2(val1,val2); \

     } \


 #define _cimglist_def_is_same3(axis1,axis2,axis3) \

     bool is_same##axis1##axis2##axis3(const unsigned int val1, const unsigned int val2, const unsigned int val3) const { \

       bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis1##axis2##axis3(val1,val2,val3); return res; \

     } \

     bool is_sameN##axis1##axis2##axis3(const unsigned int n, const unsigned int val1, const unsigned int val2, const unsigned int val3) const { \

       return is_sameN(n) && is_same##axis1##axis2##axis3(val1,val2,val3); \

     } \


 #define _cimglist_def_is_same(axis) \

     template<typename t> bool is_same##axis(const CImg<t>& img) const { \

       bool res = true; for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_same##axis(img); return res; \

     } \

     template<typename t> bool is_same##axis(const CImgList<t>& list) const { \

       const unsigned int lmin = cimg::min(width,list.width); \

       bool res = true; for (unsigned int l = 0; l<lmin && res; ++l) res = data[l].is_same##axis(list[l]); return res; \

     } \

     template<typename t> bool is_sameN##axis(const unsigned int n, const CImg<t>& img) const { \

       return (is_sameN(n) && is_same##axis(img)); \

     } \

     template<typename t> bool is_sameN##axis(const CImgList<t>& list) const { \

       return (is_sameN(list) && is_same##axis(list)); \

     }


     _cimglist_def_is_same(XY)

     _cimglist_def_is_same(XZ)

     _cimglist_def_is_same(XV)

     _cimglist_def_is_same(YZ)

     _cimglist_def_is_same(YV)

     _cimglist_def_is_same(XYZ)

     _cimglist_def_is_same(XYV)

     _cimglist_def_is_same(YZV)

     _cimglist_def_is_same(XYZV)

     _cimglist_def_is_same1(X)

     _cimglist_def_is_same1(Y)

     _cimglist_def_is_same1(Z)

     _cimglist_def_is_same1(V)

     _cimglist_def_is_same2(X,Y)

     _cimglist_def_is_same2(X,Z)

     _cimglist_def_is_same2(X,V)

     _cimglist_def_is_same2(Y,Z)

     _cimglist_def_is_same2(Y,V)

     _cimglist_def_is_same2(Z,V)

     _cimglist_def_is_same3(X,Y,Z)

     _cimglist_def_is_same3(X,Y,V)

     _cimglist_def_is_same3(X,Z,V)

     _cimglist_def_is_same3(Y,Z,V)


     bool is_sameXYZV(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const {

       bool res = true;

       for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_sameXYZV(dx,dy,dz,dv);

       return res;

     }


     bool is_sameNXYZV(const unsigned int n, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const {

       return is_sameN(n) && is_sameXYZV(dx,dy,dz,dv);

     }


     bool containsNXYZV(const int n, const int x=0, const int y=0, const int z=0, const int v=0) const {

       if (is_empty()) return false;

       return n>=0 && n<(int)width && x>=0 && x<data[n].dimx() && y>=0 && y<data[n].dimy() && z>=0 && z<data[n].dimz() && v>=0 && v<data[n].dimv();

     }


     bool containsN(const int n) const {

       if (is_empty()) return false;

       return n>=0 && n<(int)width;

     }


     template<typename t>

     bool contains(const T& pixel, t& n, t& x, t&y, t& z, t& v) const {

       if (is_empty()) return false;

       cimglist_for(*this,l) if (data[l].contains(pixel,x,y,z,v)) { n = (t)l; return true; }

       return false;

     }


     template<typename t>

     bool contains(const T& pixel, t& n, t& x, t&y, t& z) const {

       t v;

       return contains(pixel,n,x,y,z,v);

     }


     template<typename t>

     bool contains(const T& pixel, t& n, t& x, t&y) const {

       t z,v;

       return contains(pixel,n,x,y,z,v);

     }


     template<typename t>

     bool contains(const T& pixel, t& n, t& x) const {

       t y,z,v;

       return contains(pixel,n,x,y,z,v);

     }


     template<typename t>

     bool contains(const T& pixel, t& n) const {

       t x,y,z,v;

       return contains(pixel,n,x,y,z,v);

     }


     bool contains(const T& pixel) const {

       unsigned int n,x,y,z,v;

       return contains(pixel,n,x,y,z,v);

     }


     template<typename t>

     bool contains(const CImg<T>& img, t& n) const {

       if (is_empty()) return false;

       const CImg<T> *const ptr = &img;

       cimglist_for(*this,i) if (data+i==ptr) { n = (t)i; return true; }

       return false;

     }


     bool contains(const CImg<T>& img) const {

       unsigned int n;

       return contains(img,n);

     }


     //-------------------------------------

     //


     //-------------------------------------


     T& min() {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::min() : Instance image list is empty.",

                                     pixel_type());

       T *ptrmin = data->data;

       T min_value = *ptrmin;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);

       }

       return *ptrmin;

     }


     const T& min() const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::min() : Instance image list is empty.",

                                     pixel_type());

       const T *ptrmin = data->data;

       T min_value = *ptrmin;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);

       }

       return *ptrmin;

     }


     T& max() {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::max() : Instance image list is empty.",

                                     pixel_type());

       T *ptrmax = data->data;

       T max_value = *ptrmax;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);

       }

       return *ptrmax;

     }


     const T& max() const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::max() : Instance image list is empty.",

                                     pixel_type());

       const T *ptrmax = data->data;

       T max_value = *ptrmax;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);

       }

       return *ptrmax;

     }


     template<typename t>

     T& minmax(t& max_val) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::minmax() : Instance image list is empty.",

                                     pixel_type());

       T *ptrmin = data->data;

       T min_value = *ptrmin, max_value = min_value;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) {

           const T val = *ptr;

           if (val<min_value) { min_value = val; ptrmin = ptr; }

           if (val>max_value) max_value = val;

         }

       }

       max_val = (t)max_value;

       return *ptrmin;

     }


     template<typename t>

     const T& minmax(t& max_val) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::minmax() : Instance image list is empty.",

                                     pixel_type());

       const T *ptrmin = data->data;

       T min_value = *ptrmin, max_value = min_value;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) {

           const T val = *ptr;

           if (val<min_value) { min_value = val; ptrmin = ptr; }

           if (val>max_value) max_value = val;

         }

       }

       max_val = (t)max_value;

       return *ptrmin;

     }


     template<typename t>

     T& maxmin(t& min_val) {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::maxmin() : Instance image list is empty.",

                                     pixel_type());

       T *ptrmax = data->data;

       T min_value = *ptrmax, max_value = min_value;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) {

           const T val = *ptr;

           if (val>max_value) { max_value = val; ptrmax = ptr; }

           if (val<min_value) min_value = val;

         }

       }

       min_val = (t)min_value;

       return *ptrmax;

     }


     template<typename t>

     const T& maxmin(t& min_val) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::maxmin() : Instance image list is empty.",

                                     pixel_type());

       const T *ptrmax = data->data;

       T min_value = *ptrmax, max_value = min_value;

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         cimg_for(img,ptr,T) {

           const T val = *ptr;

           if (val>max_value) { max_value = val; ptrmax = ptr; }

           if (val<min_value) min_value = val;

         }

       }

       min_val = (t)min_value;

       return *ptrmax;

     }


     //---------------------------

     //


     //---------------------------


     template<typename t>

     CImgList<T>& insert(const CImg<t>& img, const unsigned int pos=~0U, const bool shared=false) {

       const unsigned int npos = pos==~0U?width:pos;

       if (npos>width)

         throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert image (%u,%u,%u,%u,%p) at position %u in a list "

                                     "containing %u elements",

                                     pixel_type(),img.width,img.height,img.depth,img.dim,img.data,npos,width);

       if (shared)

         throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert a shared image CImg<%s> in a CImgList<%s>",

                                     pixel_type(),img.pixel_type(),pixel_type());

       CImg<T> *new_data = (++width>allocated_width)?new CImg<T>[allocated_width?(allocated_width<<=1):(allocated_width=16)]:0;

       if (!width || !data) {

         data = new_data;

         *data = img;

       } else {

         if (new_data) {

           if (npos) std::memcpy(new_data,data,sizeof(CImg<T>)*npos);

           if (npos!=width-1) std::memcpy(new_data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));

           std::memset(data,0,sizeof(CImg<T>)*(width-1));

           delete[] data;

           data = new_data;

         }

         else if (npos!=width-1) std::memmove(data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));

         data[npos].width = data[npos].height = data[npos].depth = data[npos].dim = 0; data[npos].data = 0;

         data[npos] = img;

       }

       return *this;

     }


     CImgList<T>& insert(const CImg<T>& img, const unsigned int pos=~0U, const bool shared=false) {

       const unsigned int npos = pos==~0U?width:pos;

       if (npos>width)

         throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert at position %u into a list with %u elements",

                                     pixel_type(),npos,width);

       if (&img>=data && &img<data + width) return insert(+img,pos,shared);

       CImg<T> *new_data = (++width>allocated_width)?new CImg<T>[allocated_width?(allocated_width<<=1):(allocated_width=16)]:0;

       if (!width || !data) {

         data = new_data;

         if (shared && img) {

           data->width = img.width; data->height = img.height; data->depth = img.depth; data->dim = img.dim;

           data->is_shared = true; data->data = img.data;

         } else *data = img;

       }

       else {

         if (new_data) {

           if (npos) std::memcpy(new_data,data,sizeof(CImg<T>)*npos);

           if (npos!=width-1) std::memcpy(new_data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));

           if (shared && img) {

             new_data[npos].width = img.width; new_data[npos].height = img.height; new_data[npos].depth = img.depth;

             new_data[npos].dim = img.dim; new_data[npos].is_shared = true; new_data[npos].data = img.data;

           } else {

             new_data[npos].width = new_data[npos].height = new_data[npos].depth = new_data[npos].dim = 0; new_data[npos].data = 0;

             new_data[npos] = img;

           }

           std::memset(data,0,sizeof(CImg<T>)*(width-1));

           delete[] data;

           data = new_data;

         } else {

           if (npos!=width-1) std::memmove(data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));

           if (shared && img) {

             data[npos].width = img.width; data[npos].height = img.height; data[npos].depth = img.depth; data[npos].dim = img.dim;

             data[npos].is_shared = true; data[npos].data = img.data;

           } else {

             data[npos].width = data[npos].height = data[npos].depth = data[npos].dim = 0; data[npos].data = 0;

             data[npos] = img;

           }

         }

       }

       return *this;

     }


     template<typename t>

     CImgList<T> get_insert(const CImg<t>& img, const unsigned int pos=~0U, const bool shared=false) const {

       return (+*this).insert(img,pos,shared);

     }


     CImgList<T>& insert(const unsigned int n, const unsigned int pos=~0U) {

       CImg<T> foo;

       if (!n) return *this;

       const unsigned int npos = pos==~0U?width:pos;

       for (unsigned int i = 0; i<n; ++i) insert(foo,npos+i);

       return *this;

     }


     CImgList<T> get_insert(const unsigned int n, const unsigned int pos=~0U) const {

       return (+*this).insert(n,pos);

     }


     template<typename t>

     CImgList<T>& insert(const unsigned int n, const CImg<t>& img, const unsigned int pos=~0U, const bool shared=false) {

       if (!n) return *this;

       const unsigned int npos = pos==~0U?width:pos;

       insert(img,npos,shared);

       for (unsigned int i = 1; i<n; ++i) insert(data[npos],npos+i,shared);

       return *this;

     }


     template<typename t>

     CImgList<T> get_insert(const unsigned int n, const CImg<t>& img, const unsigned int pos=~0U, const bool shared=false) const {

       return (+*this).insert(n,img,pos,shared);

     }


     template<typename t>

     CImgList<T>& insert(const CImgList<t>& list, const unsigned int pos=~0U, const bool shared=false) {

       const unsigned int npos = pos==~0U?width:pos;

       if ((void*)this!=(void*)&list) cimglist_for(list,l) insert(list[l],npos+l,shared);

       else insert(CImgList<T>(list),npos,shared);

       return *this;

     }


     template<typename t>

     CImgList<T> get_insert(const CImgList<t>& list, const unsigned int pos=~0U, const bool shared=false) const {

       return (+*this).insert(list,pos,shared);

     }


     template<typename t>

     CImgList<T>& insert(const unsigned int n, const CImgList<t>& list, const unsigned int pos=~0U, const bool shared=false) {

       if (!n) return *this;

       const unsigned int npos = pos==~0U?width:pos;

       for (unsigned int i = 0; i<n; ++i) insert(list,npos,shared);

       return *this;

     }


     template<typename t>

     CImgList<T> get_insert(const unsigned int n, const CImgList<t>& list, const unsigned int pos=~0U, const bool shared=false) const {

       return (+*this).insert(n,list,pos,shared);

     }


     CImgList<T>& remove(const unsigned int pos1, const unsigned int pos2) {

       const unsigned int

         npos1 = pos1<pos2?pos1:pos2,

         tpos2 = pos1<pos2?pos2:pos1,

         npos2 = tpos2<width?tpos2:width-1;

       if (npos1>=width)

         cimg::warn("CImgList<%s>::remove() : Cannot remove images from a list (%p,%u), at positions %u->%u.",

                    pixel_type(),data,width,npos1,tpos2);

       else {

         if (tpos2>=width)

           cimg::warn("CImgList<%s>::remove() : Cannot remove all images from a list (%p,%u), at positions %u->%u.",

                      pixel_type(),data,width,npos1,tpos2);

         for (unsigned int k = npos1; k<=npos2; ++k) data[k].assign();

         const unsigned int nb = 1 + npos2 - npos1;

         if (!(width-=nb)) return assign();

         if (width>(allocated_width>>2) || allocated_width<=8) { // Removing items without reallocation.

           if (npos1!=width) std::memmove(data+npos1,data+npos2+1,sizeof(CImg<T>)*(width - npos1));

           std::memset(data + width,0,sizeof(CImg<T>)*nb);

         } else { // Removing items with reallocation.

           allocated_width>>=2;

           while (allocated_width>8 && width<(allocated_width>>1)) allocated_width>>=1;

           CImg<T> *new_data = new CImg<T>[allocated_width];

           if (npos1) std::memcpy(new_data,data,sizeof(CImg<T>)*npos1);

           if (npos1!=width) std::memcpy(new_data+npos1,data+npos2+1,sizeof(CImg<T>)*(width-npos1));

           if (width!=allocated_width) std::memset(new_data+width,0,sizeof(allocated_width - width));

           std::memset(data,0,sizeof(CImg<T>)*(width+nb));

           delete[] data;

           data = new_data;

         }

       }

       return *this;

     }


     CImgList<T> get_remove(const unsigned int pos1, const unsigned int pos2) const {

       return (+*this).remove(pos1,pos2);

     }


     CImgList<T>& remove(const unsigned int pos) {

       return remove(pos,pos);

     }


     CImgList<T> get_remove(const unsigned int pos) const {

       return (+*this).remove(pos);

     }


     CImgList<T>& remove() {

       if (width) return remove(width-1);

       else cimg::warn("CImgList<%s>::remove() : List is empty",

                       pixel_type());

       return *this;

     }


     CImgList<T> get_remove() const {

       return (+*this).remove();

     }


     CImgList<T>& reverse() {

       for (unsigned int l = 0; l<width/2; ++l) (*this)[l].swap((*this)[width-1-l]);

       return *this;

     }


     CImgList<T> get_reverse() const {

       return (+*this).reverse();

     }


     CImgList<T>& images(const unsigned int i0, const unsigned int i1) {

       return get_images(i0,i1).transfer_to(*this);

     }


     CImgList<T> get_images(const unsigned int i0, const unsigned int i1) const {

       if (i0>i1 || i1>=width)

         throw CImgArgumentException("CImgList<%s>::images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",

                                     pixel_type(),i0,i1,width,data);

       CImgList<T> res(i1-i0+1);

       cimglist_for(res,l) res[l].assign(data[i0+l]);

       return res;

     }


     CImgList<T> get_shared_images(const unsigned int i0, const unsigned int i1) {

       if (i0>i1 || i1>=width)

         throw CImgArgumentException("CImgList<%s>::get_shared_images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",

                                     pixel_type(),i0,i1,width,data);

       CImgList<T> res(i1-i0+1);

       cimglist_for(res,l) res[l].assign(data[i0+l],true);

       return res;

     }


     const CImgList<T> get_shared_images(const unsigned int i0, const unsigned int i1) const {

       if (i0>i1 || i1>=width)

         throw CImgArgumentException("CImgList<%s>::get_shared_images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",

                                     pixel_type(),i0,i1,width,data);

       CImgList<T> res(i1-i0+1);

       cimglist_for(res,l) res[l].assign(data[i0+l],true);

       return res;

     }


     CImg<T> get_append(const char axis, const char align='p') const {

       if (align!='p' && align!='c' && align!='n')

         throw CImgArgumentException("CImg<%s>::get_append() : Invalid alignment parameter '%c' (should be 'p','c' or 'n').",

                                     pixel_type(),align);

       if (is_empty()) return CImg<T>();

       if (width==1) return +((*this)[0]);

       unsigned int dx = 0, dy = 0, dz = 0, dv = 0, pos = 0;

       CImg<T> res;

       switch (cimg::uncase(axis)) {

       case 'x' : { // Along the X-axis.

         cimglist_for(*this,l) {

           const CImg<T>& img = (*this)[l];

           dx += img.width; dy = cimg::max(dy,img.height); dz = cimg::max(dz,img.depth); dv = cimg::max(dv,img.dim);

         }

         res.assign(dx,dy,dz,dv,0);

         if (res) switch (cimg::uncase(align)) {

         case 'p' : {

           cimglist_for(*this,l) {

             res.draw_image(pos,(*this)[l]);

             pos+=(*this)[l].width;

           }

         } break;

         case 'c' : {

           cimglist_for(*this,l) {

             res.draw_image(pos,(dy-(*this)[l].height)/2,(dz-(*this)[l].depth)/2,(dv-(*this)[l].dim)/2,(*this)[l]);

             pos+=(*this)[l].width;

           }

         } break;

         default : {

           cimglist_for(*this,l) {

             res.draw_image(pos,dy-(*this)[l].height,dz-(*this)[l].depth,dv-(*this)[l].dim,(*this)[l]);

             pos+=(*this)[l].width;

           }

         }}

       } break;

       case 'y' : { // Along the Y-axis.

         cimglist_for(*this,l) {

           const CImg<T>& img = (*this)[l];

           dx = cimg::max(dx,img.width); dy += img.height; dz = cimg::max(dz,img.depth); dv = cimg::max(dv,img.dim);

         }

         res.assign(dx,dy,dz,dv,0);

         if (res) switch (cimg::uncase(align)) {

         case 'p' : {

           cimglist_for(*this,l) { res.draw_image(0,pos,(*this)[l]); pos+=(*this)[l].height; }

         } break;

         case 'c' : {

           cimglist_for(*this,l) {

             res.draw_image((dx-(*this)[l].width)/2,pos,(dz-(*this)[l].depth)/2,(dv-(*this)[l].dim)/2,(*this)[l]);

             pos+=(*this)[l].height;

           }

         } break;

         default : {

           cimglist_for(*this,l) {

             res.draw_image(dx-(*this)[l].width,pos,dz-(*this)[l].depth,dv-(*this)[l].dim,(*this)[l]);

             pos+=(*this)[l].height;

           }

         }}

       } break;

       case 'z' : { // Along the Z-axis.

         cimglist_for(*this,l) {

           const CImg<T>& img = (*this)[l];

           dx = cimg::max(dx,img.width); dy = cimg::max(dy,img.height); dz += img.depth; dv = cimg::max(dv,img.dim);

         }

         res.assign(dx,dy,dz,dv,0);

         if (res) switch (cimg::uncase(align)) {

         case 'p' : {

           cimglist_for(*this,l) { res.draw_image(0,0,pos,(*this)[l]); pos+=(*this)[l].depth; }

         } break;

         case 'c' : {

           cimglist_for(*this,l) {

             res.draw_image((dx-(*this)[l].width)/2,(dy-(*this)[l].height)/2,pos,(dv-(*this)[l].dim)/2,(*this)[l]);

             pos+=(*this)[l].depth;

           }

         } break;

         default : {

           cimglist_for(*this,l) {

             res.draw_image(dx-(*this)[l].width,dy-(*this)[l].height,pos,dv-(*this)[l].dim,(*this)[l]);

             pos+=(*this)[l].depth;

           }

         }}

       } break;

       case 'v' : { // Along the V-axis.

         cimglist_for(*this,l) {

           const CImg<T>& img = (*this)[l];

           dx = cimg::max(dx,img.width); dy = cimg::max(dy,img.height); dz = cimg::max(dz,img.depth); dv += img.dim;

         }

         res.assign(dx,dy,dz,dv,0);

         if (res) switch (cimg::uncase(align)) {

         case 'p' : {

           cimglist_for(*this,l) { res.draw_image(0,0,0,pos,(*this)[l]); pos+=(*this)[l].dim; }

         } break;

         case 'c' : {

           cimglist_for(*this,l) {

             res.draw_image((dx-(*this)[l].width)/2,(dy-(*this)[l].height)/2,(dz-(*this)[l].depth)/2,pos,(*this)[l]);

             pos+=(*this)[l].dim;

           }

         } break;

         default : {

           cimglist_for(*this,l) {

             res.draw_image(dx-(*this)[l].width,dy-(*this)[l].height,dz-(*this)[l].depth,pos,(*this)[l]);

             pos+=(*this)[l].dim;

           }

         }}

       } break;

       default :

         throw CImgArgumentException("CImgList<%s>::get_append() : Invalid axis parameter '%c' (should be 'x','y','z' or 'v').",

                                     pixel_type(),axis);

       }

       return res;

     }


     CImgList<T>& split(const char axis, const int nb=0) {

       return get_split(axis,nb).transfer_to(*this);

     }


     CImgList<T> get_split(const char axis, const int nb=0) const {

       CImgList<T> res;

       cimglist_for(*this,l) data[l].get_split(axis,nb).transfer_to(res,~0U);

       return res;

     }


     template<typename t>

     CImgList<T>& push_back(const CImg<t>& img) {

       return insert(img);

     }


     template<typename t>

     CImgList<T>& push_front(const CImg<t>& img) {

       return insert(img,0);

     }


     template<typename t>

     CImgList<T>& push_back(const CImgList<t>& list) {

       return insert(list);

     }


     template<typename t>

     CImgList<T>& push_front(const CImgList<t>& list) {

       return insert(list,0);

     }


     CImgList<T>& pop_back() {

       return remove(width-1);

     }


     CImgList<T>& pop_front() {

       return remove(0);

     }


     CImgList<T>& erase(const iterator iter) {

       return remove(iter-data);

     }


     //----------------------------------

     //


     //----------------------------------


     CImgList<T>& load(const char *const filename) {

       const char *ext = cimg::split_filename(filename);

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       assign();

       try {

 #ifdef cimglist_load_plugin

         cimglist_load_plugin(filename);

 #endif

 #ifdef cimglist_load_plugin1

         cimglist_load_plugin1(filename);

 #endif

 #ifdef cimglist_load_plugin2

         cimglist_load_plugin2(filename);

 #endif

 #ifdef cimglist_load_plugin3

         cimglist_load_plugin3(filename);

 #endif

 #ifdef cimglist_load_plugin4

         cimglist_load_plugin4(filename);

 #endif

 #ifdef cimglist_load_plugin5

         cimglist_load_plugin5(filename);

 #endif

 #ifdef cimglist_load_plugin6

         cimglist_load_plugin6(filename);

 #endif

 #ifdef cimglist_load_plugin7

         cimglist_load_plugin7(filename);

 #endif

 #ifdef cimglist_load_plugin8

         cimglist_load_plugin8(filename);

 #endif

         if (!cimg::strcasecmp(ext,"tif") ||

             !cimg::strcasecmp(ext,"tiff")) load_tiff(filename);

         if (!cimg::strcasecmp(ext,"cimg") ||

             !cimg::strcasecmp(ext,"cimgz") ||

             !ext[0]) load_cimg(filename);

         if (!cimg::strcasecmp(ext,"rec") ||

             !cimg::strcasecmp(ext,"par")) load_parrec(filename);

         if (!cimg::strcasecmp(ext,"avi") ||

             !cimg::strcasecmp(ext,"mov") ||

             !cimg::strcasecmp(ext,"asf") ||

             !cimg::strcasecmp(ext,"divx") ||

             !cimg::strcasecmp(ext,"flv") ||

             !cimg::strcasecmp(ext,"mpg") ||

             !cimg::strcasecmp(ext,"m1v") ||

             !cimg::strcasecmp(ext,"m2v") ||

             !cimg::strcasecmp(ext,"m4v") ||

             !cimg::strcasecmp(ext,"mjp") ||

             !cimg::strcasecmp(ext,"mkv") ||

             !cimg::strcasecmp(ext,"mpe") ||

             !cimg::strcasecmp(ext,"movie") ||

             !cimg::strcasecmp(ext,"ogm") ||

             !cimg::strcasecmp(ext,"qt") ||

             !cimg::strcasecmp(ext,"rm") ||

             !cimg::strcasecmp(ext,"vob") ||

             !cimg::strcasecmp(ext,"wmv") ||

             !cimg::strcasecmp(ext,"xvid") ||

             !cimg::strcasecmp(ext,"mpeg")) load_ffmpeg(filename);

         if (!cimg::strcasecmp(ext,"gz")) load_gzip_external(filename);

         if (is_empty()) throw CImgIOException("CImgList<%s>::load()",pixel_type());

       } catch (CImgIOException& e) {

         if (!cimg::strncasecmp(e.message,"cimg::fopen()",13)) {

           cimg::exception_mode() = omode;

           throw CImgIOException("CImgList<%s>::load() : File '%s' cannot be opened.",pixel_type(),filename);

         } else try {

           assign(1);

           data->load(filename);

         } catch (CImgException&) {

           assign();

         }

       }

       cimg::exception_mode() = omode;

       if (is_empty())

         throw CImgIOException("CImgList<%s>::load() : File '%s', format not recognized.",pixel_type(),filename);

       return *this;

     }


     static CImgList<T> get_load(const char *const filename) {

       return CImgList<T>().load(filename);

     }


     CImgList<T>& load_cimg(const char *const filename) {

       return _load_cimg(0,filename);

     }


     static CImgList<T> get_load_cimg(const char *const filename) {

       return CImgList<T>().load_cimg(filename);

     }


     CImgList<T>& load_cimg(std::FILE *const file) {

       return _load_cimg(file,0);

     }


     static CImgList<T> get_load_cimg(std::FILE *const file) {

       return CImgList<T>().load_cimg(file);

     }


     CImgList<T>& _load_cimg(std::FILE *const file, const char *const filename) {

 #ifdef cimg_use_zlib

 #define _cimgz_load_cimg_case(Tss) { \

    Bytef *const cbuf = new Bytef[csiz]; \

    cimg::fread(cbuf,csiz,nfile); \

    raw.assign(W,H,D,V); \

    unsigned long destlen = (unsigned long)raw.size()*sizeof(T); \

    uncompress((Bytef*)raw.data,&destlen,cbuf,csiz); \

    delete[] cbuf; \

    const Tss *ptrs = raw.data; \

    for (unsigned int off = raw.size(); off; --off) *(ptrd++) = (T)*(ptrs++); \

 }

 #else

 #define _cimgz_load_cimg_case(Tss) \

    throw CImgIOException("CImgList<%s>::load_cimg() : File '%s' contains compressed data, zlib must be used",\

                          pixel_type(),filename?filename:"(FILE*)");

 #endif


 #define _cimg_load_cimg_case(Ts,Tss) \

       if (!loaded && !cimg::strcasecmp(Ts,str_pixeltype)) { \

         for (unsigned int l = 0; l<N; ++l) { \

           j = 0; while ((i=std::fgetc(nfile))!='\n' && i>=0) tmp[j++] = (char)i; tmp[j] = 0; \

           W = H = D = V = 0; csiz = 0; \

           if ((err = std::sscanf(tmp,"%u %u %u %u #%u",&W,&H,&D,&V,&csiz))<4) \

             throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Image %u has an invalid size (%u,%u,%u,%u)\n", \

                                   pixel_type(),filename?filename:("(FILE*)"),W,H,D,V); \

           if (W*H*D*V>0) { \

             CImg<Tss> raw; \

             CImg<T> &img = data[l]; \

             img.assign(W,H,D,V); \

             T *ptrd = img.data; \

             if (err==5) _cimgz_load_cimg_case(Tss) \

             else for (int toread = (int)img.size(); toread>0; ) { \

               raw.assign(cimg::min(toread,cimg_iobuffer)); \

               cimg::fread(raw.data,raw.width,nfile); \

               if (endian!=cimg::endianness()) cimg::invert_endianness(raw.data,raw.width); \

               toread-=raw.width; \

               const Tss *ptrs = raw.data; \

               for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++); \

             } \

           } \

         } \

         loaded = true; \

       }


       if (!filename && !file)

         throw CImgArgumentException("CImgList<%s>::load_cimg() : Cannot load (null) filename.",

                                     pixel_type());

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;

       const int cimg_iobuffer = 12*1024*1024;

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       bool loaded = false, endian = cimg::endianness();

       char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };

       unsigned int j, err, N = 0, W, H, D, V, csiz;

       int i;

       j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;

       err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);

       if (err<2) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Unknow CImg RAW header.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       if (!cimg::strncasecmp("little",str_endian,6)) endian = false;

       else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;

       assign(N);

       _cimg_load_cimg_case("bool",bool);

       _cimg_load_cimg_case("unsigned_char",uchar);

       _cimg_load_cimg_case("uchar",uchar);

       _cimg_load_cimg_case("char",char);

       _cimg_load_cimg_case("unsigned_short",ushort);

       _cimg_load_cimg_case("ushort",ushort);

       _cimg_load_cimg_case("short",short);

       _cimg_load_cimg_case("unsigned_int",uint);

       _cimg_load_cimg_case("uint",uint);

       _cimg_load_cimg_case("int",int);

       _cimg_load_cimg_case("unsigned_long",ulong);

       _cimg_load_cimg_case("ulong",ulong);

       _cimg_load_cimg_case("long",long);

       _cimg_load_cimg_case("float",float);

       _cimg_load_cimg_case("double",double);

       if (!loaded) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', cannot read images of pixels coded as '%s'.",

                               pixel_type(),filename?filename:"(FILE*)",str_pixeltype);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImgList<T>& load_cimg(const char *const filename,

                            const unsigned int n0, const unsigned int n1,

                            const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                            const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1) {

       return _load_cimg(0,filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

     }


     static CImgList<T> get_load_cimg(const char *const filename,

                                      const unsigned int n0, const unsigned int n1,

                                      const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                                      const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1) {

       return CImgList<T>().load_cimg(filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

     }


     CImgList<T>& load_cimg(std::FILE *const file,

                            const unsigned int n0, const unsigned int n1,

                            const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                            const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1) {

       return _load_cimg(file,0,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

     }


     static CImgList<T> get_load_cimg(std::FILE *const file,

                                      const unsigned int n0, const unsigned int n1,

                                      const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                                      const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1) {

       return CImgList<T>().load_cimg(file,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

     }


     CImgList<T>& _load_cimg(std::FILE *const file, const char *const filename,

                             const unsigned int n0, const unsigned int n1,

                             const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0,

                             const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1) {

 #define _cimg_load_cimg_case2(Ts,Tss) \

       if (!loaded && !cimg::strcasecmp(Ts,str_pixeltype)) { \

         for (unsigned int l = 0; l<=nn1; ++l) { \

           j = 0; while ((i=std::fgetc(nfile))!='\n' && i>=0) 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) { \

             if (l<n0 || x0>=W || y0>=H || z0>=D || v0>=D) std::fseek(nfile,W*H*D*V*sizeof(Tss),SEEK_CUR); \

             else { \

               const unsigned int \

                 nx1 = x1>=W?W-1:x1, \

                 ny1 = y1>=H?H-1:y1, \

                 nz1 = z1>=D?D-1:z1, \

                 nv1 = v1>=V?V-1:v1; \

               CImg<Tss> raw(1 + nx1 - x0); \

               CImg<T> &img = data[l - n0]; \

               img.assign(1 + nx1 - x0,1 + ny1 - y0,1 + nz1 - z0,1 + nv1 - v0); \

               T *ptrd = img.data; \

               const unsigned int skipvb = v0*W*H*D*sizeof(Tss); \

               if (skipvb) std::fseek(nfile,skipvb,SEEK_CUR); \

               for (unsigned int v = 1 + nv1 - v0; v; --v) { \

                 const unsigned int skipzb = z0*W*H*sizeof(Tss); \

                 if (skipzb) std::fseek(nfile,skipzb,SEEK_CUR); \

                 for (unsigned int z = 1 + nz1 - z0; z; --z) { \

                   const unsigned int skipyb = y0*W*sizeof(Tss); \

                   if (skipyb) std::fseek(nfile,skipyb,SEEK_CUR); \

                   for (unsigned int y = 1 + ny1 - y0; y; --y) { \

                     const unsigned int skipxb = x0*sizeof(Tss); \

                     if (skipxb) std::fseek(nfile,skipxb,SEEK_CUR); \

                     cimg::fread(raw.data,raw.width,nfile); \

                     if (endian!=cimg::endianness()) cimg::invert_endianness(raw.data,raw.width); \

                     const Tss *ptrs = raw.data; \

                     for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++); \

                     const unsigned int skipxe = (W-1-nx1)*sizeof(Tss); \

                     if (skipxe) std::fseek(nfile,skipxe,SEEK_CUR); \

                   } \

                   const unsigned int skipye = (H-1-ny1)*W*sizeof(Tss); \

                   if (skipye) std::fseek(nfile,skipye,SEEK_CUR); \

                 } \

                 const unsigned int skipze = (D-1-nz1)*W*H*sizeof(Tss); \

                 if (skipze) std::fseek(nfile,skipze,SEEK_CUR); \

               } \

               const unsigned int skipve = (V-1-nv1)*W*H*D*sizeof(Tss); \

               if (skipve) std::fseek(nfile,skipve,SEEK_CUR); \

             } \

           } \

         } \

         loaded = true; \

       }


       if (!filename && !file)

         throw CImgArgumentException("CImgList<%s>::load_cimg() : Cannot load (null) filename.",

                                     pixel_type());

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;

       if (n1<n0 || x1<x0 || y1<y0 || z1<z0 || v1<v0)

         throw CImgArgumentException("CImgList<%s>::load_cimg() : File '%s', Bad sub-region coordinates [%u->%u] "

                                     "(%u,%u,%u,%u)->(%u,%u,%u,%u).",

                                     pixel_type(),filename?filename:"(FILE*)",

                                     n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       bool loaded = false, endian = cimg::endianness();

       char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };

       unsigned int j, err, N, W, H, D, V;

       int i;

       j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;

       err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);

       if (err<2) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Unknow CImg RAW header.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       if (!cimg::strncasecmp("little",str_endian,6)) endian = false;

       else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;

       const unsigned int nn1 = n1>=N?N-1:n1;

       assign(1+nn1-n0);

       _cimg_load_cimg_case2("bool",bool);

       _cimg_load_cimg_case2("unsigned_char",uchar);

       _cimg_load_cimg_case2("uchar",uchar);

       _cimg_load_cimg_case2("char",char);

       _cimg_load_cimg_case2("unsigned_short",ushort);

       _cimg_load_cimg_case2("ushort",ushort);

       _cimg_load_cimg_case2("short",short);

       _cimg_load_cimg_case2("unsigned_int",uint);

       _cimg_load_cimg_case2("uint",uint);

       _cimg_load_cimg_case2("int",int);

       _cimg_load_cimg_case2("unsigned_long",ulong);

       _cimg_load_cimg_case2("ulong",ulong);

       _cimg_load_cimg_case2("long",long);

       _cimg_load_cimg_case2("float",float);

       _cimg_load_cimg_case2("double",double);

       if (!loaded) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', cannot read images of pixels coded as '%s'.",

                               pixel_type(),filename?filename:"(FILE*)",str_pixeltype);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     CImgList<T>& load_parrec(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::load_parrec() : Cannot load (null) filename.",

                                     pixel_type());

       char body[1024] = { 0 }, filenamepar[1024] = { 0 }, filenamerec[1024] = { 0 };

       const char *ext = cimg::split_filename(filename,body);

       if (!std::strcmp(ext,"par")) { std::strcpy(filenamepar,filename); std::sprintf(filenamerec,"%s.rec",body); }

       if (!std::strcmp(ext,"PAR")) { std::strcpy(filenamepar,filename); std::sprintf(filenamerec,"%s.REC",body); }

       if (!std::strcmp(ext,"rec")) { std::strcpy(filenamerec,filename); std::sprintf(filenamepar,"%s.par",body); }

       if (!std::strcmp(ext,"REC")) { std::strcpy(filenamerec,filename); std::sprintf(filenamepar,"%s.PAR",body); }

       std::FILE *file = cimg::fopen(filenamepar,"r");


       // Parse header file

       CImgList<floatT> st_slices;

       CImgList<uintT> st_global;

       int err;

       char line[256] = { 0 };

       do { err=std::fscanf(file,"%255[^\n]%*c",line); } while (err!=EOF && (line[0]=='#' || line[0]=='.'));

       do {

         unsigned int sn,sizex,sizey,pixsize;

         float rs,ri,ss;

         err = std::fscanf(file,"%u%*u%*u%*u%*u%*u%*u%u%*u%u%u%g%g%g%*[^\n]",&sn,&pixsize,&sizex,&sizey,&ri,&rs,&ss);

         if (err==7) {

           CImg<floatT>::vector((float)sn,(float)pixsize,(float)sizex,(float)sizey,ri,rs,ss,0).transfer_to(st_slices);

           unsigned int i; for (i = 0; i<st_global.width && sn<=st_global[i][2]; ++i) {}

           if (i==st_global.width) CImg<uintT>::vector(sizex,sizey,sn).transfer_to(st_global);

           else {

             CImg<uintT> &vec = st_global[i];

             if (sizex>vec[0]) vec[0] = sizex;

             if (sizey>vec[1]) vec[1] = sizey;

             vec[2] = sn;

           }

           st_slices[st_slices.width-1][7] = (float)i;

         }

       } while (err==7);


       // Read data

       std::FILE *file2 = cimg::fopen(filenamerec,"rb");

       cimglist_for(st_global,l) {

         const CImg<uintT>& vec = st_global[l];

         CImg<T>(vec[0],vec[1],vec[2]).transfer_to(*this);

       }


       cimglist_for(st_slices,l) {

         const CImg<floatT>& vec = st_slices[l];

         const unsigned int

           sn = (unsigned int)vec[0]-1,

           pixsize = (unsigned int)vec[1],

           sizex = (unsigned int)vec[2],

           sizey = (unsigned int)vec[3],

           imn = (unsigned int)vec[7];

         const float ri = vec[4], rs = vec[5], ss = vec[6];

         switch (pixsize) {

         case 8 : {

           CImg<ucharT> buf(sizex,sizey);

           cimg::fread(buf.data,sizex*sizey,file2);

           if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);

           CImg<T>& img = (*this)[imn];

           cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));

         } break;

         case 16 : {

           CImg<ushortT> buf(sizex,sizey);

           cimg::fread(buf.data,sizex*sizey,file2);

           if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);

           CImg<T>& img = (*this)[imn];

           cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));

         } break;

         case 32 : {

           CImg<uintT> buf(sizex,sizey);

           cimg::fread(buf.data,sizex*sizey,file2);

           if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);

           CImg<T>& img = (*this)[imn];

           cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));

         } break;

         default :

           cimg::fclose(file);

           cimg::fclose(file2);

           throw CImgIOException("CImg<%s>::load_parrec() : File '%s', cannot handle image with pixsize = %d bits.",

                                 pixel_type(),filename,pixsize);

         }

       }

       cimg::fclose(file);

       cimg::fclose(file2);

       if (!width)

         throw CImgIOException("CImg<%s>::load_parrec() : File '%s' does not appear to be a valid PAR-REC file.",

                               pixel_type(),filename);

       return *this;

     }


     static CImgList<T> get_load_parrec(const char *const filename) {

       return CImgList<T>().load_parrec(filename);

     }


     CImgList<T>& load_yuv(const char *const filename,

                           const unsigned int sizex, const unsigned int sizey,

                           const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                           const unsigned int step_frame=1, const bool yuv2rgb=true) {

       return _load_yuv(0,filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);

     }


     static CImgList<T> get_load_yuv(const char *const filename,

                                     const unsigned int sizex, const unsigned int sizey=1,

                                     const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                     const unsigned int step_frame=1, const bool yuv2rgb=true) {

       return CImgList<T>().load_yuv(filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);

     }


     CImgList<T>& load_yuv(std::FILE *const file,

                           const unsigned int sizex, const unsigned int sizey,

                           const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                           const unsigned int step_frame=1, const bool yuv2rgb=true) {

       return _load_yuv(file,0,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);

     }


     static CImgList<T> get_load_yuv(std::FILE *const file,

                                     const unsigned int sizex, const unsigned int sizey=1,

                                     const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                     const unsigned int step_frame=1, const bool yuv2rgb=true) {

       return CImgList<T>().load_yuv(file,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);

     }


     CImgList<T>& _load_yuv(std::FILE *const file, const char *const filename,

                            const unsigned int sizex, const unsigned int sizey,

                            const unsigned int first_frame, const unsigned int last_frame,

                            const unsigned int step_frame, const bool yuv2rgb) {

       if (!filename && !file)

         throw CImgArgumentException("CImgList<%s>::load_yuv() : Cannot load (null) filename.",

                                     pixel_type());

       if (sizex%2 || sizey%2)

         throw CImgArgumentException("CImgList<%s>::load_yuv() : File '%s', image dimensions along X and Y must be "

                                     "even numbers (given are %ux%u)\n",

                                     pixel_type(),filename?filename:"(FILE*)",sizex,sizey);

       if (!sizex || !sizey)

         throw CImgArgumentException("CImgList<%s>::load_yuv() : File '%s', given image sequence size (%u,%u) is invalid",

                                     pixel_type(),filename?filename:"(FILE*)",sizex,sizey);


       const unsigned int

         nfirst_frame = first_frame<last_frame?first_frame:last_frame,

         nlast_frame = first_frame<last_frame?last_frame:first_frame,

         nstep_frame = step_frame?step_frame:1;


       CImg<ucharT> tmp(sizex,sizey,1,3), UV(sizex/2,sizey/2,1,2);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");

       bool stopflag = false;

       int err;

       if (nfirst_frame) {

         err = std::fseek(nfile,nfirst_frame*(sizex*sizey + sizex*sizey/2),SEEK_CUR);

         if (err) {

           if (!file) cimg::fclose(nfile);

           throw CImgIOException("CImgList<%s>::load_yuv() : File '%s' doesn't contain frame number %u "

                                 "(out of range error).",

                                 pixel_type(),filename?filename:"(FILE*)",nfirst_frame);

         }

       }

       unsigned int frame;

       for (frame = nfirst_frame; !stopflag && frame<=nlast_frame; frame+=nstep_frame) {

         tmp.fill(0);

         // *TRY* to read the luminance part, do not replace by cimg::fread !

         err = (int)std::fread((void*)(tmp.data),1,(size_t)(tmp.width*tmp.height),nfile);

         if (err!=(int)(tmp.width*tmp.height)) {

           stopflag = true;

           if (err>0)

             cimg::warn("CImgList<%s>::load_yuv() : File '%s' contains incomplete data,"

                        " or given image dimensions (%u,%u) are incorrect.",

                        pixel_type(),filename?filename:"(FILE*)",sizex,sizey);

         } else {

           UV.fill(0);

           // *TRY* to read the luminance part, do not replace by cimg::fread !

           err = (int)std::fread((void*)(UV.data),1,(size_t)(UV.size()),nfile);

           if (err!=(int)(UV.size())) {

             stopflag = true;

             if (err>0)

               cimg::warn("CImgList<%s>::load_yuv() : File '%s' contains incomplete data,"

                          " or given image dimensions (%u,%u) are incorrect.",

                          pixel_type(),filename?filename:"(FILE*)",sizex,sizey);

           } else {

             cimg_forXY(UV,x,y) {

               const int x2 = x*2, y2 = y*2;

               tmp(x2,y2,1) = tmp(x2+1,y2,1) = tmp(x2,y2+1,1) = tmp(x2+1,y2+1,1) = UV(x,y,0);

               tmp(x2,y2,2) = tmp(x2+1,y2,2) = tmp(x2,y2+1,2) = tmp(x2+1,y2+1,2) = UV(x,y,1);

             }

             if (yuv2rgb) tmp.YCbCrtoRGB();

             insert(tmp);

             if (nstep_frame>1) std::fseek(nfile,(nstep_frame-1)*(sizex*sizey + sizex*sizey/2),SEEK_CUR);

           }

         }

       }

       if (stopflag && nlast_frame!=~0U && frame!=nlast_frame)

         cimg::warn("CImgList<%s>::load_yuv() : File '%s', frame %d not reached since only %u frames were found in the file.",

                    pixel_type(),filename?filename:"(FILE*)",nlast_frame,frame-1,filename);

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     // This piece of code has been firstly created by David Starweather (starkdg(at)users(dot)sourceforge(dot)net)

     // I modified it afterwards for direct inclusion in the library core.

     CImgList<T>& load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                              const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false) {

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::load_ffmpeg() : Cannot load (null) filename.",

                                     pixel_type());

       const unsigned int

         nfirst_frame = first_frame<last_frame?first_frame:last_frame,

         nlast_frame = first_frame<last_frame?last_frame:first_frame,

         nstep_frame = step_frame?step_frame:1;

       assign();


 #ifndef cimg_use_ffmpeg

       if ((nfirst_frame || nlast_frame!=~0U || nstep_frame>1) || (resume && (pixel_format || !pixel_format)))

         throw CImgArgumentException("CImg<%s>::load_ffmpeg() : File '%s', reading sub-frames from a video file requires the use of ffmpeg.\n"

                                     "('cimg_use_ffmpeg' must be defined).",

                                     pixel_type(),filename);

       return load_ffmpeg_external(filename);

 #else

       const unsigned int ffmpeg_pixfmt = pixel_format?PIX_FMT_RGB24:PIX_FMT_GRAY8;

       avcodec_register_all();

       av_register_all();

       static AVFormatContext *format_ctx = 0;

       static AVCodecContext *codec_ctx = 0;

       static AVCodec *codec = 0;

       static AVFrame *avframe = avcodec_alloc_frame(), *converted_frame = avcodec_alloc_frame();

       static int vstream = 0;


       if (resume) {

         if (!format_ctx || !codec_ctx || !codec || !avframe || !converted_frame)

           throw CImgArgumentException("CImgList<%s>::load_ffmpeg() : File '%s', cannot resume due to unallocated FFMPEG structures.",

                                       pixel_type(),filename);

       } else {

         // Open video file, find main video stream and codec.

         if (format_ctx) av_close_input_file(format_ctx);

         if (av_open_input_file(&format_ctx,filename,0,0,0)!=0)

           throw CImgIOException("CImgList<%s>::load_ffmpeg() : File '%s' cannot be opened.",

                                 pixel_type(),filename);

         if (!avframe || !converted_frame || av_find_stream_info(format_ctx)<0) {

           av_close_input_file(format_ctx); format_ctx = 0;

           cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot retrieve stream information.\n"

                      "Trying with external ffmpeg executable.",

                      pixel_type(),filename);

           return load_ffmpeg_external(filename);

         }

 #if cimg_debug>=3

         dump_format(format_ctx,0,0,0);

 #endif


         // Special command : Return informations on main video stream.

         // as a vector 1x4 containing : (nb_frames,width,height,fps).

         if (!first_frame && !last_frame && !step_frame) {

           for (vstream = 0; vstream<(int)(format_ctx->nb_streams); ++vstream)

             if (format_ctx->streams[vstream]->codec->codec_type==CODEC_TYPE_VIDEO) break;

           if (vstream==(int)format_ctx->nb_streams) assign();

           else {

             CImgList<doubleT> timestamps;

             int nb_frames;

             AVPacket packet;

             // Count frames and store timestamps.

             for (nb_frames = 0; av_read_frame(format_ctx,&packet)>=0; av_free_packet(&packet))

               if (packet.stream_index==vstream) {

                 CImg<doubleT>::vector((double)packet.pts).transfer_to(timestamps);

                 ++nb_frames;

               }

             // Get frame with, height and fps.

             const int

               framew = format_ctx->streams[vstream]->codec->width,

               frameh = format_ctx->streams[vstream]->codec->height;

             const float

               num = (float)(format_ctx->streams[vstream]->r_frame_rate).num,

               den = (float)(format_ctx->streams[vstream]->r_frame_rate).den,

               fps = num/den;

             // Return infos as a list.

             assign(2);

             (*this)[0].assign(1,4).fill((T)nb_frames,(T)framew,(T)frameh,(T)fps);

             (*this)[1] = (timestamps>'y');

           }

           av_close_input_file(format_ctx); format_ctx = 0;

           return *this;

         }


         for (vstream = 0; vstream<(int)(format_ctx->nb_streams) &&

                format_ctx->streams[vstream]->codec->codec_type!=CODEC_TYPE_VIDEO; ) ++vstream;

         if (vstream==(int)format_ctx->nb_streams) {

           cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot retrieve video stream.\n"

                      "Trying with external ffmpeg executable.",

                      pixel_type(),filename);

           av_close_input_file(format_ctx); format_ctx = 0;

           return load_ffmpeg_external(filename);

         }

         codec_ctx = format_ctx->streams[vstream]->codec;

         codec = avcodec_find_decoder(codec_ctx->codec_id);

         if (!codec) {

           cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot find video codec.\n"

                      "Trying with external ffmpeg executable.",

                      pixel_type(),filename);

           return load_ffmpeg_external(filename);

         }

         if (avcodec_open(codec_ctx,codec)<0) { // Open codec

           cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot open video codec.\n"

                      "Trying with external ffmpeg executable.",

                      pixel_type(),filename);

           return load_ffmpeg_external(filename);

         }

       }


       // Read video frames

       const unsigned int numBytes = avpicture_get_size(ffmpeg_pixfmt,codec_ctx->width,codec_ctx->height);

       uint8_t *const buffer = new uint8_t[numBytes];

       avpicture_fill((AVPicture *)converted_frame,buffer,ffmpeg_pixfmt,codec_ctx->width,codec_ctx->height);

       const T foo = (T)0;

       AVPacket packet;

       for (unsigned int frame = 0, next_frame = nfirst_frame; frame<=nlast_frame && av_read_frame(format_ctx,&packet)>=0; ) {

         if (packet.stream_index==(int)vstream) {

           int decoded = 0;

           avcodec_decode_video(codec_ctx,avframe,&decoded,packet.data,packet.size);

           if (decoded) {

             if (frame==next_frame) {

               SwsContext *c = sws_getContext(codec_ctx->width,codec_ctx->height,codec_ctx->pix_fmt,codec_ctx->width,

                                              codec_ctx->height,ffmpeg_pixfmt,1,0,0,0);

               sws_scale(c,avframe->data,avframe->linesize,0,codec_ctx->height,converted_frame->data,converted_frame->linesize);

               if (ffmpeg_pixfmt==PIX_FMT_RGB24) {

                 CImg<ucharT> next_image(*converted_frame->data,3,codec_ctx->width,codec_ctx->height,1,true);

                 next_image._get_permute_axes("yzvx",foo).transfer_to(*this);

               } else {

                 CImg<ucharT> next_image(*converted_frame->data,1,codec_ctx->width,codec_ctx->height,1,true);

                 next_image._get_permute_axes("yzvx",foo).transfer_to(*this);

               }

               next_frame+=nstep_frame;

             }

             ++frame;

           }

           av_free_packet(&packet);

           if (next_frame>nlast_frame) break;

         }

       }

       delete[] buffer;

 #endif

       return *this;

     }


     static CImgList<T> get_load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                        const unsigned int step_frame=1, const bool pixel_format=true) {

       return CImgList<T>().load_ffmpeg(filename,first_frame,last_frame,step_frame,pixel_format);

     }


     CImgList<T>& load_ffmpeg_external(const char *const filename) {

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::load_ffmpeg_external() : Cannot load (null) filename.",

                                     pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, filetmp2[512] = { 0 };

       std::FILE *file = 0;

       do {

         std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         std::sprintf(filetmp2,"%s_000001.ppm",filetmp);

         if ((file=std::fopen(filetmp2,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(filetmp2,"%s_%%6d.ppm",filetmp);

 #if cimg_OS!=2

       std::sprintf(command,"%s -i \"%s\" %s >/dev/null 2>&1",cimg::ffmpeg_path(),filename,filetmp2);

 #else

       std::sprintf(command,"\"%s -i \"%s\" %s\" >NUL 2>&1",cimg::ffmpeg_path(),filename,filetmp2);

 #endif

       cimg::system(command,0);

       const unsigned int omode = cimg::exception_mode();

       cimg::exception_mode() = 0;

       assign();

       unsigned int i = 1;

       for (bool stopflag = false; !stopflag; ++i) {

         std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,i);

         CImg<T> img;

         try { img.load_pnm(filetmp2); }

         catch (CImgException&) { stopflag = true; }

         if (img) { img.transfer_to(*this); std::remove(filetmp2); }

       }

       cimg::exception_mode() = omode;

       if (is_empty())

         throw CImgIOException("CImgList<%s>::load_ffmpeg_external() : Failed to open image sequence '%s'.\n"

                               "Check the filename and if the 'ffmpeg' tool is installed on your system.",

                               pixel_type(),filename);

       return *this;

     }


     static CImgList<T> get_load_ffmpeg_external(const char *const filename) {

       return CImgList<T>().load_ffmpeg_external(filename);

     }


     CImgList<T>& load_gzip_external(const char *const filename) {

       if (!filename)

         throw CImgIOException("CImg<%s>::load_gzip_external() : Cannot load (null) filename.",

                               pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       const char

         *ext = cimg::split_filename(filename,body),

         *ext2 = cimg::split_filename(body,0);

       std::FILE *file = 0;

       do {

         if (!cimg::strcasecmp(ext,"gz")) {

           if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);

           else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         } else {

           if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);

           else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         }

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       std::sprintf(command,"%s -c \"%s\" > %s",cimg::gunzip_path(),filename,filetmp);

       cimg::system(command);

       if (!(file = std::fopen(filetmp,"rb"))) {

         cimg::fclose(cimg::fopen(filename,"r"));

         throw CImgIOException("CImg<%s>::load_gzip_external() : File '%s' cannot be opened.",

                               pixel_type(),filename);

       } else cimg::fclose(file);

       load(filetmp);

       std::remove(filetmp);

       return *this;

     }


     static CImgList<T> get_load_gzip_external(const char *const filename) {

       return CImgList<T>().load_gzip_external(filename);

     }


     template<typename tf, typename tc>

     CImgList<T>& load_off(const char *const filename,

                           CImgList<tf>& primitives, CImgList<tc>& colors) {

       return get_load_off(filename,primitives,colors).transfer_to(*this);

     }


     template<typename tf, typename tc>

       static CImgList<T> get_load_off(const char *const filename,

                                       CImgList<tf>& primitives, CImgList<tc>& colors) {

       return CImg<T>().load_off(filename,primitives,colors)<'x';

     }


     CImgList<T>& load_tiff(const char *const filename,

                            const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                            const unsigned int step_frame=1) {

       const unsigned int

         nfirst_frame = first_frame<last_frame?first_frame:last_frame,

         nstep_frame = step_frame?step_frame:1;

       unsigned int nlast_frame = first_frame<last_frame?last_frame:first_frame;

 #ifndef cimg_use_tiff

       if (nfirst_frame || nlast_frame!=~0U || nstep_frame!=1)

         throw CImgArgumentException("CImgList<%s>::load_tiff() : File '%s', reading sub-images from a tiff file requires the use of libtiff.\n"

                                     "('cimg_use_tiff' must be defined).",

                                     pixel_type(),filename);

       return assign(CImg<T>::get_load_tiff(filename));

 #else

       TIFF *tif = TIFFOpen(filename,"r");

       if (tif) {

         unsigned int nb_images = 0;

         do ++nb_images; while (TIFFReadDirectory(tif));

         if (nfirst_frame>=nb_images || (nlast_frame!=~0U && nlast_frame>=nb_images))

           cimg::warn("CImgList<%s>::load_tiff() : File '%s' contains %u image(s), specified frame range is [%u,%u] (step %u).",

                      pixel_type(),filename,nb_images,nfirst_frame,nlast_frame,nstep_frame);

         if (nfirst_frame>=nb_images) return assign();

         if (nlast_frame>=nb_images) nlast_frame = nb_images-1;

         assign(1+(nlast_frame-nfirst_frame)/nstep_frame);

         TIFFSetDirectory(tif,0);

 #if cimg_debug>=3

         TIFFSetWarningHandler(0);

         TIFFSetErrorHandler(0);

 #endif

         cimglist_for(*this,l) data[l]._load_tiff(tif,nfirst_frame + l*nstep_frame);

         TIFFClose(tif);

       } else throw CImgException("CImgList<%s>::load_tiff() : File '%s' cannot be opened.",

                                  pixel_type(),filename);

       return *this;

 #endif

     }


     static CImgList<T> get_load_tiff(const char *const filename,

                                      const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                      const unsigned int step_frame=1) {

       return CImgList<T>().load_tiff(filename,first_frame,last_frame,step_frame);

     }


     //----------------------------------

     //


     //----------------------------------


     const CImgList<T>& print(const char* title=0, const bool display_stats=true) const {

       unsigned int msiz = 0;

       cimglist_for(*this,l) msiz += data[l].size();

       msiz*=sizeof(T);

       const unsigned int mdisp = msiz<8*1024?0:(msiz<8*1024*1024?1:2);

       char ntitle[64] = { 0 };

       if (!title) std::sprintf(ntitle,"CImgList<%s>",pixel_type());

       std::fprintf(cimg_stdout,"%s: this = %p, size = %u [%u %s], data = (CImg<%s>*)%p..%p.\n",

                    title?title:ntitle,(void*)this,width,

                    mdisp==0?msiz:(mdisp==1?(msiz>>10):(msiz>>20)),

                    mdisp==0?"b":(mdisp==1?"Kb":"Mb"),

                    pixel_type(),(void*)begin(),(void*)((char*)end()-1));

       char tmp[16] = { 0 };

       cimglist_for(*this,ll) {

         std::sprintf(tmp,"[%d]",ll);

         std::fprintf(cimg_stdout,"  ");

         data[ll].print(tmp,display_stats);

         if (ll==3 && width>8) { ll = width-5; std::fprintf(cimg_stdout,"  ...\n"); }

       }

       return *this;

     }


     const CImgList<T>& display(CImgDisplay& disp, const char axis='x', const char align='p') const {

       get_append(axis,align).display(disp);

       return *this;

     }


     const CImgList<T>& display(CImgDisplay &disp,

                                const bool display_info, const char axis='x', const char align='p') const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::display() : Instance list (%u,%u) is empty.",

                                     pixel_type(),width,data);

       const CImg<T> visu = get_append(axis,align);

       if (display_info) print(disp.title);

       visu.display(disp,false);

       return *this;

     }


     const CImgList<T>& display(const char *const title=0,

                                const bool display_info=true, const char axis='x', const char align='p') const {

       const CImg<T> visu = get_append(axis,align);

       char ntitle[64] = { 0 };

       if (!title) std::sprintf(ntitle,"CImgList<%s>",pixel_type());

       if (display_info) print(title?title:ntitle);

       visu.display(title?title:ntitle,false);

       return *this;

     }


     const CImgList<T>& save(const char *const filename, const int number=-1) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save() : File '%s, instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,data);

       if (!filename)

         throw CImgArgumentException("CImg<%s>::save() : Instance list (%u,%p), specified filename is (null).",

                                     pixel_type(),width,data);

       const char *ext = cimg::split_filename(filename);

       char nfilename[1024] = { 0 };

       const char *const fn = (number>=0)?cimg::number_filename(filename,number,6,nfilename):filename;

 #ifdef cimglist_save_plugin

       cimglist_save_plugin(fn);

 #endif

 #ifdef cimglist_save_plugin1

       cimglist_save_plugin1(fn);

 #endif

 #ifdef cimglist_save_plugin2

       cimglist_save_plugin2(fn);

 #endif

 #ifdef cimglist_save_plugin3

       cimglist_save_plugin3(fn);

 #endif

 #ifdef cimglist_save_plugin4

       cimglist_save_plugin4(fn);

 #endif

 #ifdef cimglist_save_plugin5

       cimglist_save_plugin5(fn);

 #endif

 #ifdef cimglist_save_plugin6

       cimglist_save_plugin6(fn);

 #endif

 #ifdef cimglist_save_plugin7

       cimglist_save_plugin7(fn);

 #endif

 #ifdef cimglist_save_plugin8

       cimglist_save_plugin8(fn);

 #endif

 #ifdef cimg_use_tiff

       if (!cimg::strcasecmp(ext,"tif") ||

           !cimg::strcasecmp(ext,"tiff")) return save_tiff(fn);

 #endif

       if (!cimg::strcasecmp(ext,"cimgz")) return save_cimg(fn,true);

       if (!cimg::strcasecmp(ext,"cimg") || !ext[0]) return save_cimg(fn,false);

       if (!cimg::strcasecmp(ext,"yuv")) return save_yuv(fn,true);

       if (!cimg::strcasecmp(ext,"avi") ||

           !cimg::strcasecmp(ext,"mov") ||

           !cimg::strcasecmp(ext,"asf") ||

           !cimg::strcasecmp(ext,"divx") ||

           !cimg::strcasecmp(ext,"flv") ||

           !cimg::strcasecmp(ext,"mpg") ||

           !cimg::strcasecmp(ext,"m1v") ||

           !cimg::strcasecmp(ext,"m2v") ||

           !cimg::strcasecmp(ext,"m4v") ||

           !cimg::strcasecmp(ext,"mjp") ||

           !cimg::strcasecmp(ext,"mkv") ||

           !cimg::strcasecmp(ext,"mpe") ||

           !cimg::strcasecmp(ext,"movie") ||

           !cimg::strcasecmp(ext,"ogm") ||

           !cimg::strcasecmp(ext,"qt") ||

           !cimg::strcasecmp(ext,"rm") ||

           !cimg::strcasecmp(ext,"vob") ||

           !cimg::strcasecmp(ext,"wmv") ||

           !cimg::strcasecmp(ext,"xvid") ||

           !cimg::strcasecmp(ext,"mpeg")) return save_ffmpeg(fn);

       if (!cimg::strcasecmp(ext,"gz")) return save_gzip_external(fn);

       if (width==1) data[0].save(fn,-1); else cimglist_for(*this,l) data[l].save(fn,l);

       return *this;

     }


     // This piece of code has been originally written by David. G. Starkweather.

     const CImgList<T>& save_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                    const unsigned int fps=25) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,data);

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : Instance list (%u,%p), specified filename is (null).",

                                     pixel_type(),width,data);

       if (!fps)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', specified framerate is 0.",

                                     pixel_type(),filename);

       const unsigned int nlast_frame = last_frame==~0U?width-1:last_frame;

       if (first_frame>=width || nlast_frame>=width)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', specified frames [%u,%u] are out of list range (%u elements).",

                                     pixel_type(),filename,first_frame,last_frame,width);

       for (unsigned int ll = first_frame; ll<=nlast_frame; ++ll) if (!data[ll].is_sameXYZ(data[0]))

         throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', images of the sequence have different dimensions.",

                                     pixel_type(),filename);


 #ifndef cimg_use_ffmpeg

       return save_ffmpeg_external(filename,first_frame,last_frame);

 #else

       avcodec_register_all();

       av_register_all();

       const int

         frame_dimx = data[first_frame].dimx(),

         frame_dimy = data[first_frame].dimy(),

         frame_dimv = data[first_frame].dimv();

       if (frame_dimv!=1 && frame_dimv!=3)

         throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', image[0] (%u,%u,%u,%u,%p) has not 1 or 3 channels.",

                                     pixel_type(),filename,data[0].width,data[0].height,data[0].depth,data[0].dim,data);


       PixelFormat dest_pxl_fmt = PIX_FMT_YUV420P;

       PixelFormat src_pxl_fmt  = (frame_dimv == 3)?PIX_FMT_RGB24:PIX_FMT_GRAY8;


       int sws_flags = SWS_FAST_BILINEAR; // Interpolation method (keeping same size images for now).

       AVOutputFormat *fmt = 0;

       fmt = guess_format(0,filename,0);

       if (!fmt) fmt = guess_format("mpeg",0,0); // Default format "mpeg".

       if (!fmt)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', could not determine file format from filename.",

                                     pixel_type(),filename);


       AVFormatContext *oc = 0;

       oc = av_alloc_format_context();

       if (!oc) // Failed to allocate format context.

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate structure for format context.",

                               pixel_type(),filename);


       AVCodec *codec = 0;

       AVFrame *picture = 0;

       AVFrame *tmp_pict = 0;

       oc->oformat = fmt;

       std::sprintf(oc->filename,"%s",filename);


       // Add video stream.

       int stream_index = 0;

       AVStream *video_str = 0;

       if (fmt->video_codec!=CODEC_ID_NONE) {

         video_str = av_new_stream(oc,stream_index);

         if (!video_str) { // Failed to allocate stream.

           av_free(oc);

           throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate video stream structure.",

                                 pixel_type(),filename);

         }

       } else { // No codec identified.

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', no proper codec identified.",

                               pixel_type(),filename);

       }


       AVCodecContext *c = video_str->codec;

       c->codec_id = fmt->video_codec;

       c->codec_type = CODEC_TYPE_VIDEO;

       c->bit_rate = 400000;

       c->width = frame_dimx;

       c->height = frame_dimy;

       c->time_base.num = 1;

       c->time_base.den = fps;

       c->gop_size = 12;

       c->pix_fmt = dest_pxl_fmt;

       if (c->codec_id == CODEC_ID_MPEG2VIDEO) c->max_b_frames = 2;

       if (c->codec_id == CODEC_ID_MPEG1VIDEO) c->mb_decision = 2;


       if (av_set_parameters(oc,0)<0) { // Parameters not properly set.

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', parameters for avcodec not properly set.",

                               pixel_type(),filename);

       }


       // Open codecs and alloc buffers.

       codec = avcodec_find_encoder(c->codec_id);

       if (!codec) { // Failed to find codec.

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', no codec found.",

                               pixel_type(),filename);

       }

       if (avcodec_open(c,codec)<0) // Failed to open codec.

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to open codec.",

                               pixel_type(),filename);

       tmp_pict = avcodec_alloc_frame();

       if (!tmp_pict) { // Failed to allocate memory for tmp_pict frame.

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for data buffer.",

                               pixel_type(),filename);

       }

       tmp_pict->linesize[0] = (src_pxl_fmt==PIX_FMT_RGB24)?3*frame_dimx:frame_dimx;

       tmp_pict->type = FF_BUFFER_TYPE_USER;

       int tmp_size = avpicture_get_size(src_pxl_fmt,frame_dimx,frame_dimy);

       uint8_t *tmp_buffer = (uint8_t*)av_malloc(tmp_size);

       if (!tmp_buffer) { // Failed to allocate memory for tmp buffer.

         av_free(tmp_pict);

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for data buffer.",

                               pixel_type(),filename);

       }


       // Associate buffer with tmp_pict.

       avpicture_fill((AVPicture*)tmp_pict,tmp_buffer,src_pxl_fmt,frame_dimx,frame_dimy);

       picture = avcodec_alloc_frame();

       if (!picture) { // Failed to allocate picture frame.

         av_free(tmp_pict->data[0]);

         av_free(tmp_pict);

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for picture frame.",

                               pixel_type(),filename);

       }


       int size = avpicture_get_size(c->pix_fmt,frame_dimx,frame_dimy);

       uint8_t *buffer = (uint8_t*)av_malloc(size);

       if (!buffer) { // Failed to allocate picture frame buffer.

         av_free(picture);

         av_free(tmp_pict->data[0]);

         av_free(tmp_pict);

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for picture frame buffer.",

                               pixel_type(),filename);

       }


       // Associate the buffer with picture.

       avpicture_fill((AVPicture*)picture,buffer,c->pix_fmt,frame_dimx,frame_dimy);


       // Open file.

       if (!(fmt->flags&AVFMT_NOFILE)) {

         if (url_fopen(&oc->pb,filename,URL_WRONLY)<0)

           throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s' cannot be opened.",

                                 pixel_type(),filename);

       }


       if (av_write_header(oc)<0)

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', could not write header.",

                               pixel_type(),filename);

       double video_pts;

       SwsContext *img_convert_context = 0;

       img_convert_context = sws_getContext(frame_dimx,frame_dimy,src_pxl_fmt,

                                            c->width,c->height,c->pix_fmt,sws_flags,0,0,0);

       if (!img_convert_context) { // Failed to get swscale context.

         // if (!(fmt->flags & AVFMT_NOFILE)) url_fclose(&oc->pb);

         av_free(picture->data);

         av_free(picture);

         av_free(tmp_pict->data[0]);

         av_free(tmp_pict);

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%', failed to get conversion context.",

                               pixel_type(),filename);

       }

       int ret = 0, out_size;

       uint8_t *video_outbuf = 0;

       int video_outbuf_size = 1000000;

       video_outbuf = (uint8_t*)av_malloc(video_outbuf_size);

       if (!video_outbuf) {

         // if (!(fmt->flags & AVFMT_NOFILE)) url_fclose(&oc->pb);

         av_free(picture->data);

         av_free(picture);

         av_free(tmp_pict->data[0]);

         av_free(tmp_pict);

         avcodec_close(video_str->codec);

         av_free(oc);

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', memory allocation error.",

                               pixel_type(),filename);

       }


       // Loop through each desired image in list.

       for (unsigned int i = first_frame; i<=nlast_frame; ++i) {

         CImg<uint8_t> currentIm = data[i], red, green, blue, gray;

         if (src_pxl_fmt == PIX_FMT_RGB24) {

           red = currentIm.get_shared_channel(0);

           green = currentIm.get_shared_channel(1);

           blue = currentIm.get_shared_channel(2);

           cimg_forXY(currentIm,X,Y) { // Assign pizel values to data buffer in interlaced RGBRGB ... format.

             tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X]     = red(X,Y);

             tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X + 1] = green(X,Y);

             tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X + 2] = blue(X,Y);

           }

         } else {

           gray = currentIm.get_shared_channel(0);

           cimg_forXY(currentIm,X,Y) tmp_pict->data[0][Y*tmp_pict->linesize[0] + X] = gray(X,Y);

         }


         if (video_str) video_pts = (video_str->pts.val * video_str->time_base.num)/(video_str->time_base.den);

         else video_pts = 0.0;

         if (!video_str) break;

         if (sws_scale(img_convert_context,tmp_pict->data,tmp_pict->linesize,0,c->height,picture->data,picture->linesize)<0) break;

         out_size = avcodec_encode_video(c,video_outbuf,video_outbuf_size,picture);

         if (out_size>0) {

           AVPacket pkt;

           av_init_packet(&pkt);

           pkt.pts = av_rescale_q(c->coded_frame->pts,c->time_base,video_str->time_base);

           if (c->coded_frame->key_frame) pkt.flags|=PKT_FLAG_KEY;

           pkt.stream_index = video_str->index;

           pkt.data = video_outbuf;

           pkt.size = out_size;

           ret = av_write_frame(oc,&pkt);

         } else if (out_size<0) break;

         if (ret) break; // Error occured in writing frame.

       }


       // Close codec.

       if (video_str) {

         avcodec_close(video_str->codec);

         av_free(picture->data[0]);

         av_free(picture);

         av_free(tmp_pict->data[0]);

         av_free(tmp_pict);

       }

       if (av_write_trailer(oc)<0)

         throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to write trailer.",

                               pixel_type(),filename);

       av_freep(&oc->streams[stream_index]->codec);

       av_freep(&oc->streams[stream_index]);

       if (!(fmt->flags&AVFMT_NOFILE)) {

         /*if (url_fclose(oc->pb)<0)

           throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to close file.",

           pixel_type(),filename);

         */

       }

       av_free(oc);

       av_free(video_outbuf);

 #endif

       return *this;

     }


     // Save an image sequence into a YUV file (internal).

     const CImgList<T>& _save_yuv(std::FILE *const file, const char *const filename, const bool rgb2yuv) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_yuv() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_yuv() : Instance list (%u,%p), specified file is (null).",

                                     pixel_type(),width,data);

       if ((*this)[0].dimx()%2 || (*this)[0].dimy()%2)

         throw CImgInstanceException("CImgList<%s>::save_yuv() : File '%s', image dimensions must be even numbers (current are %ux%u).",

                                     pixel_type(),filename?filename:"(FILE*)",(*this)[0].dimx(),(*this)[0].dimy());


       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       cimglist_for(*this,l) {

         CImg<ucharT> YCbCr((*this)[l]);

         if (rgb2yuv) YCbCr.RGBtoYCbCr();

         cimg::fwrite(YCbCr.data,YCbCr.width*YCbCr.height,nfile);

         cimg::fwrite(YCbCr.get_resize(YCbCr.width/2, YCbCr.height/2,1,3,3).ptr(0,0,0,1),

                      YCbCr.width*YCbCr.height/2,nfile);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImgList<T>& save_yuv(const char *const filename=0, const bool rgb2yuv=true) const {

       return _save_yuv(0,filename,rgb2yuv);

     }


     const CImgList<T>& save_yuv(std::FILE *const file, const bool rgb2yuv=true) const {

       return _save_yuv(file,0,rgb2yuv);

     }


     const CImgList<T>& _save_cimg(std::FILE *const file, const char *const filename, const bool compression) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_cimg() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_cimg() : Instance list (%u,%p), specified file is (null).",

                                     pixel_type(),width,data);

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       const char *const ptype = pixel_type(), *const etype = cimg::endianness()?"big":"little";

       if (std::strstr(ptype,"unsigned")==ptype) std::fprintf(nfile,"%u unsigned_%s %s_endian\n",width,ptype+9,etype);

       else std::fprintf(nfile,"%u %s %s_endian\n",width,ptype,etype);

       cimglist_for(*this,l) {

         const CImg<T>& img = data[l];

         std::fprintf(nfile,"%u %u %u %u",img.width,img.height,img.depth,img.dim);

         if (img.data) {

           CImg<T> tmp;

           if (cimg::endianness()) { tmp = img; cimg::invert_endianness(tmp.data,tmp.size()); }

           const CImg<T>& ref = cimg::endianness()?tmp:img;

           bool compressed = false;

           if (compression) {

 #ifdef cimg_use_zlib

             const unsigned long siz = sizeof(T)*ref.size();

             unsigned long csiz = siz + siz/100 + 16;

             Bytef *const cbuf = new Bytef[csiz];

             if (compress(cbuf,&csiz,(Bytef*)ref.data,siz)) {

               cimg::warn("CImgList<%s>::save_cimg() : File '%s', failed to save compressed data.\n Data will be saved uncompressed.",

                        pixel_type(),filename?filename:"(FILE*)");

               compressed = false;

             } else {

               std::fprintf(nfile," #%lu\n",csiz);

               cimg::fwrite(cbuf,csiz,nfile);

               delete[] cbuf;

               compressed = true;

             }

 #else

             cimg::warn("CImgList<%s>::save_cimg() : File '%s', cannot save compressed data unless zlib is used "

                        "('cimg_use_zlib' must be defined).\n Data will be saved uncompressed.",

                        pixel_type(),filename?filename:"(FILE*)");

             compressed = false;

 #endif

           }

           if (!compressed) {

             std::fputc('\n',nfile);

             cimg::fwrite(ref.data,ref.size(),nfile);

           }

         } else std::fputc('\n',nfile);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImgList<T>& save_cimg(std::FILE *file, const bool compress=false) const {

       return _save_cimg(file,0,compress);

     }


     const CImgList<T>& save_cimg(const char *const filename, const bool compress=false) const {

       return _save_cimg(0,filename,compress);

     }


     // Insert the instance image into into an existing .cimg file, at specified coordinates.

     const CImgList<T>& _save_cimg(std::FILE *const file, const char *const filename,

                                  const unsigned int n0,

                                  const unsigned int x0, const unsigned int y0,

                                  const unsigned int z0, const unsigned int v0) const {

 #define _cimg_save_cimg_case(Ts,Tss) \

       if (!saved && !cimg::strcasecmp(Ts,str_pixeltype)) { \

         for (unsigned int l = 0; l<lmax; ++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>::save_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) { \

             if (l<n0 || x0>=W || y0>=H || z0>=D || v0>=D) std::fseek(nfile,W*H*D*V*sizeof(Tss),SEEK_CUR); \

             else { \

               const CImg<T>& img = (*this)[l - n0]; \

               const T *ptrs = img.data; \

               const unsigned int \

                 x1 = x0 + img.width - 1, \

                 y1 = y0 + img.height - 1, \

                 z1 = z0 + img.depth - 1, \

                 v1 = v0 + img.dim - 1, \

                 nx1 = x1>=W?W-1:x1, \

                 ny1 = y1>=H?H-1:y1, \

                 nz1 = z1>=D?D-1:z1, \

                 nv1 = v1>=V?V-1:v1; \

               CImg<Tss> raw(1+nx1-x0); \

               const unsigned int skipvb = v0*W*H*D*sizeof(Tss); \

               if (skipvb) std::fseek(nfile,skipvb,SEEK_CUR); \

               for (unsigned int v = 1 + nv1 - v0; v; --v) { \

                 const unsigned int skipzb = z0*W*H*sizeof(Tss); \

                 if (skipzb) std::fseek(nfile,skipzb,SEEK_CUR); \

                 for (unsigned int z = 1 + nz1 - z0; z; --z) { \

                   const unsigned int skipyb = y0*W*sizeof(Tss); \

                   if (skipyb) std::fseek(nfile,skipyb,SEEK_CUR); \

                   for (unsigned int y = 1 + ny1 - y0; y; --y) { \

                     const unsigned int skipxb = x0*sizeof(Tss); \

                     if (skipxb) std::fseek(nfile,skipxb,SEEK_CUR); \

                     raw.assign(ptrs, raw.width); \

                     ptrs+=img.width; \

                     if (endian) cimg::invert_endianness(raw.data,raw.width); \

                     cimg::fwrite(raw.data,raw.width,nfile); \

                     const unsigned int skipxe = (W - 1 - nx1)*sizeof(Tss); \

                     if (skipxe) std::fseek(nfile,skipxe,SEEK_CUR); \

                   } \

                   const unsigned int skipye = (H - 1 - ny1)*W*sizeof(Tss); \

                   if (skipye) std::fseek(nfile,skipye,SEEK_CUR); \

                 } \

                 const unsigned int skipze = (D - 1 - nz1)*W*H*sizeof(Tss); \

                 if (skipze) std::fseek(nfile,skipze,SEEK_CUR); \

               } \

               const unsigned int skipve = (V - 1 - nv1)*W*H*D*sizeof(Tss); \

               if (skipve) std::fseek(nfile,skipve,SEEK_CUR); \

             } \

           } \

         } \

         saved = true; \

       }

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_cimg() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(FILE*)",width,data);

       if (!file && !filename)

         throw CImgArgumentException("CImg<%s>::save_cimg() : Instance list (%u,%p), specified file is (null).",

                                     pixel_type(),width,data);

       typedef unsigned char uchar;

       typedef unsigned short ushort;

       typedef unsigned int uint;

       typedef unsigned long ulong;

       std::FILE *const nfile = file?file:cimg::fopen(filename,"rb+");

       bool saved = false, endian = cimg::endianness();

       char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };

       unsigned int j, err, N, W, H, D, V;

       int i;

       j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;

       err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);

       if (err<2) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::save_cimg() : File '%s', Unknow CImg RAW header.",

                               pixel_type(),filename?filename:"(FILE*)");

       }

       if (!cimg::strncasecmp("little",str_endian,6)) endian = false;

       else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;

       const unsigned int lmax = cimg::min(N,n0+width);

       _cimg_save_cimg_case("bool",bool);

       _cimg_save_cimg_case("unsigned_char",uchar);

       _cimg_save_cimg_case("uchar",uchar);

       _cimg_save_cimg_case("char",char);

       _cimg_save_cimg_case("unsigned_short",ushort);

       _cimg_save_cimg_case("ushort",ushort);

       _cimg_save_cimg_case("short",short);

       _cimg_save_cimg_case("unsigned_int",uint);

       _cimg_save_cimg_case("uint",uint);

       _cimg_save_cimg_case("int",int);

       _cimg_save_cimg_case("unsigned_long",ulong);

       _cimg_save_cimg_case("ulong",ulong);

       _cimg_save_cimg_case("long",long);

       _cimg_save_cimg_case("float",float);

       _cimg_save_cimg_case("double",double);

       if (!saved) {

         if (!file) cimg::fclose(nfile);

         throw CImgIOException("CImgList<%s>::save_cimg() : File '%s', cannot save images of pixels coded as '%s'.",

                               pixel_type(),filename?filename:"(FILE*)",str_pixeltype);

       }

       if (!file) cimg::fclose(nfile);

       return *this;

     }


     const CImgList<T>& save_cimg(const char *const filename,

                                  const unsigned int n0,

                                  const unsigned int x0, const unsigned int y0,

                                  const unsigned int z0, const unsigned int v0) const {

       return _save_cimg(0,filename,n0,x0,y0,z0,v0);

     }


     const CImgList<T>& save_cimg(std::FILE *const file,

                                  const unsigned int n0,

                                  const unsigned int x0, const unsigned int y0,

                                  const unsigned int z0, const unsigned int v0) const {

       return _save_cimg(file,0,n0,x0,y0,z0,v0);

     }


     // Create an empty .cimg file with specified dimensions (internal)

     static void _save_empty_cimg(std::FILE *const file, const char *const filename,

                                 const unsigned int nb,

                                 const unsigned int dx, const unsigned int dy,

                                 const unsigned int dz, const unsigned int dv) {

       std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");

       const unsigned int siz = dx*dy*dz*dv*sizeof(T);

       std::fprintf(nfile,"%u %s\n",nb,pixel_type());

       for (unsigned int i=nb; i; --i) {

         std::fprintf(nfile,"%u %u %u %u\n",dx,dy,dz,dv);

         for (unsigned int off=siz; off; --off) std::fputc(0,nfile);

       }

       if (!file) cimg::fclose(nfile);

     }


     static void save_empty_cimg(const char *const filename,

                                 const unsigned int nb,

                                 const unsigned int dx, const unsigned int dy=1,

                                 const unsigned int dz=1, const unsigned int dv=1) {

       return _save_empty_cimg(0,filename,nb,dx,dy,dz,dv);

     }


     static void save_empty_cimg(std::FILE *const file,

                                 const unsigned int nb,

                                 const unsigned int dx, const unsigned int dy=1,

                                 const unsigned int dz=1, const unsigned int dv=1) {

       return _save_empty_cimg(file,0,nb,dx,dy,dz,dv);

     }


 #ifdef cimg_use_tiff

     const CImgList<T>& save_tiff(const char *const filename) const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_tiff() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,data);

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::save_tiff() : Specified filename is (null) for instance list (%u,%p).",

                                     pixel_type(),width,data);

       TIFF *tif = TIFFOpen(filename,"w");

       if (tif) {

         for (unsigned int dir = 0, l = 0; l<width; ++l) {

           const CImg<T>& img = (*this)[l];

           if (img) {

             if (img.depth==1) img._save_tiff(tif,dir++);

             else cimg_forZ(img,z) img.get_slice(z)._save_tiff(tif,dir++);

           }

         }

         TIFFClose(tif);

       } else

         throw CImgException("CImgList<%s>::save_tiff() : File '%s', error while opening stream for tiff file.",

                             pixel_type(),filename);

       return *this;

     }

 #endif


     const CImgList<T>& save_gzip_external(const char *const filename) const {

       if (!filename)

         throw CImgIOException("CImg<%s>::save_gzip_external() : Cannot save (null) filename.",

                               pixel_type());

       char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };

       const char

         *ext = cimg::split_filename(filename,body),

         *ext2 = cimg::split_filename(body,0);

       std::FILE *file;

       do {

         if (!cimg::strcasecmp(ext,"gz")) {

           if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);

           else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         } else {

           if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);

           else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         }

         if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);

       } while (file);

       save(filetmp);

       std::sprintf(command,"%s -c %s > \"%s\"",cimg::gzip_path(),filetmp,filename);

       cimg::system(command);

       file = std::fopen(filename,"rb");

       if (!file)

         throw CImgIOException("CImgList<%s>::save_gzip_external() : File '%s' cannot be saved.",

                               pixel_type(),filename);

       else cimg::fclose(file);

       std::remove(filetmp);

       return *this;

     }


     const CImgList<T>& save_ffmpeg_external(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U,

                                             const char *const codec="mpeg2video") const {

       if (is_empty())

         throw CImgInstanceException("CImgList<%s>::save_ffmpeg_external() : File '%s', instance list (%u,%p) is empty.",

                                     pixel_type(),filename?filename:"(null)",width,data);

       if (!filename)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg_external() : Instance list (%u,%p), specified filename is (null).",

                                     pixel_type(),width,data);

       char command[1024] = { 0 }, filetmp[512] = { 0 }, filetmp2[512] = { 0 };

       std::FILE *file = 0;

       const unsigned int nlast_frame = last_frame==~0U?width-1:last_frame;

       if (first_frame>=width || nlast_frame>=width)

         throw CImgArgumentException("CImgList<%s>::save_ffmpeg_external() : File '%s', specified frames [%u,%u] are out of list range (%u elements).",

                                     pixel_type(),filename,first_frame,last_frame,width);

       for (unsigned int ll = first_frame; ll<=nlast_frame; ++ll) if (!data[ll].is_sameXYZ(data[0]))

         throw CImgInstanceException("CImgList<%s>::save_ffmpeg_external() : File '%s', all images of the sequence must be of the same dimension.",

                                     pixel_type(),filename);

       do {

         std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());

         std::sprintf(filetmp2,"%s_000001.ppm",filetmp);

         if ((file=std::fopen(filetmp2,"rb"))!=0) std::fclose(file);

       } while (file);

       for (unsigned int l = first_frame; l<=nlast_frame; ++l) {

         std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,l+1);

         if (data[l].depth>1 || data[l].dim!=3) data[l].get_resize(-100,-100,1,3).save_pnm(filetmp2);

         else data[l].save_pnm(filetmp2);

       }

 #if cimg_OS!=2

       std::sprintf(command,"ffmpeg -i %s_%%6d.ppm -vcodec %s -sameq -y \"%s\" >/dev/null 2>&1",filetmp,codec,filename);

 #else

       std::sprintf(command,"\"ffmpeg -i %s_%%6d.ppm -vcodec %s -sameq -y \"%s\"\" >NUL 2>&1",filetmp,codec,filename);

 #endif

       cimg::system(command);

       file = std::fopen(filename,"rb");

       if (!file)

         throw CImgIOException("CImg<%s>::save_ffmpeg_external() : Failed to save image sequence '%s'.\n\n",

                               pixel_type(),filename);

       else cimg::fclose(file);

       cimglist_for(*this,lll) { std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,lll+1); std::remove(filetmp2); }

       return *this;

     }


     //----------------------------------

     //


     //----------------------------------


     CImgList<T>& crop_font() {

       return get_crop_font().transfer_to(*this);

     }


     CImgList<T> get_crop_font() const {

       CImgList<T> res;

       cimglist_for(*this,l) {

         const CImg<T>& letter = (*this)[l];

         int xmin = letter.width, xmax = 0;

         cimg_forXY(letter,x,y) if (letter(x,y)) { if (x<xmin) xmin=x; if (x>xmax) xmax=x; }

         if (xmin>xmax) CImg<T>(letter.width,letter.height,1,letter.dim,0).transfer_to(res);

         else letter.get_crop(xmin,0,xmax,letter.height-1).transfer_to(res);

       }

       res[' '].resize(res['f'].width);

       res[' '+256].resize(res['f'].width);

       return res;

     }


     static CImgList<T> font(const unsigned int font_width, const bool variable_size=true) {

       if (font_width<=11) {

         static CImgList<T> font7x11, nfont7x11;

         if (!variable_size && !font7x11)  font7x11 = _font(cimg::font7x11,7,11,1,0,false);

         if (variable_size  && !nfont7x11) nfont7x11 = _font(cimg::font7x11,7,11,1,0,true);

         return variable_size?nfont7x11:font7x11;

       }

       if (font_width<=13) {

         static CImgList<T> font10x13, nfont10x13;

         if (!variable_size && !font10x13)  font10x13 = _font(cimg::font10x13,10,13,1,0,false);

         if (variable_size  && !nfont10x13) nfont10x13 = _font(cimg::font10x13,10,13,1,0,true);

         return variable_size?nfont10x13:font10x13;

       }

       if (font_width<=17) {

         static CImgList<T> font8x17, nfont8x17;

         if (!variable_size && !font8x17)  font8x17 = _font(cimg::font8x17,8,17,1,0,false);

         if (variable_size  && !nfont8x17) nfont8x17 = _font(cimg::font8x17,8,17,1,0,true);

         return variable_size?nfont8x17:font8x17;

       }

       if (font_width<=19) {

         static CImgList<T> font10x19, nfont10x19;

         if (!variable_size && !font10x19)  font10x19 = _font(cimg::font10x19,10,19,2,0,false);

         if (variable_size  && !nfont10x19) nfont10x19 = _font(cimg::font10x19,10,19,2,0,true);

         return variable_size?nfont10x19:font10x19;

       }

       if (font_width<=24) {

         static CImgList<T> font12x24, nfont12x24;

         if (!variable_size && !font12x24)  font12x24 = _font(cimg::font12x24,12,24,2,0,false);

         if (variable_size  && !nfont12x24) nfont12x24 = _font(cimg::font12x24,12,24,2,0,true);

         return variable_size?nfont12x24:font12x24;

       }

       if (font_width<=32) {

         static CImgList<T> font16x32, nfont16x32;

         if (!variable_size && !font16x32)  font16x32 = _font(cimg::font16x32,16,32,2,0,false);

         if (variable_size  && !nfont16x32) nfont16x32 = _font(cimg::font16x32,16,32,2,0,true);

         return variable_size?nfont16x32:font16x32;

       }

       if (font_width<=38) {

         static CImgList<T> font19x38, nfont19x38;

         if (!variable_size && !font19x38)  font19x38 = _font(cimg::font19x38,19,38,3,0,false);

         if (variable_size  && !nfont19x38) nfont19x38 = _font(cimg::font19x38,19,38,3,0,true);

         return variable_size?nfont19x38:font19x38;

       }

       static CImgList<T> font29x57, nfont29x57;

       if (!variable_size && !font29x57)  font29x57 = _font(cimg::font29x57,29,57,5,0,false);

       if (variable_size  && !nfont29x57) nfont29x57 = _font(cimg::font29x57,29,57,5,0,true);

       return variable_size?nfont29x57:font29x57;

     }


     static CImgList<T> _font(const unsigned int *const font, const unsigned int w, const unsigned int h,

                              const unsigned int paddingx, const unsigned int paddingy, const bool variable_size=true) {

       CImgList<T> res = CImgList<T>(256,w,h,1,3);

       res.insert(256); cimglist_for_in(res,256,511,l) res[l].assign(w,h,1,1);

       const unsigned int *ptr = font;

       unsigned int m = 0, val = 0;

       for (unsigned int y = 0; y<h; ++y)

         for (unsigned int x = 0; x<256*w; ++x) {

           m>>=1; if (!m) { m = 0x80000000; val = *(ptr++); }

           CImg<T>& img = res[x/w], &mask = res[x/w+256];

           unsigned int xm = x%w;

           img(xm,y,0) = img(xm,y,1) = img(xm,y,2) = mask(xm,y,0) = (T)((val&m)?1:0);

         }

       if (variable_size) res.crop_font();

       if (paddingx || paddingy) cimglist_for(res,l) res[l].resize(res[l].dimx() + paddingx,res[l].dimy() + paddingy,1,-100,0);

       return res;

     }


     CImgList<T>& FFT(const char axis, const bool invert=false) {

       if (is_empty()) return *this;

       if (width==1) insert(1);

       if (width>2) cimg::warn("CImgList<%s>::FFT() : Instance list (%u,%p) have more than 2 images",

                              pixel_type(),width,data);

       CImg<T>::FFT(data[0],data[1],axis,invert);

       return *this;

     }


     CImgList<Tfloat> get_FFT(const char axis, const bool invert=false) const {

       return CImgList<Tfloat>(*this,false).FFT(axis,invert);

     }


     CImgList<T>& FFT(const bool invert=false) {

       if (is_empty()) return *this;

       if (width==1) insert(1);

       if (width>2) cimg::warn("CImgList<%s>::FFT() : Instance list (%u,%p) have more than 2 images",

                              pixel_type(),width,data);

       CImg<T>::FFT(data[0],data[1],invert);

       return *this;

     }


     CImgList<Tfloat> get_FFT(const bool invert=false) const {

       return CImgList<Tfloat>(*this,false).FFT(invert);

     }


     CImgList<T>& reverse_object3d() {

       cimglist_for(*this,l) {

         CImg<T>& p = data[l];

         const unsigned int siz = p.size();

         if (siz==2 || siz==3 || siz==6 || siz==9) cimg::swap(p[0],p[1]);

         else if (siz==4 || siz==12) cimg::swap(p[0],p[3],p[1],p[2]);

       }

       return *this;

     }


     CImgList<T> get_reverse_object3d() const {

       return (+*this).reverse_object3d();

     }


    };


   /*

    #---------------------------------------------

    #

    # Completion of previously declared functions

    #

    #----------------------------------------------

   */


 namespace cimg {


   template<typename t>

   inline int dialog(const char *title, const char *msg,

                     const char *button1_txt, const char *button2_txt,

                     const char *button3_txt, const char *button4_txt,

                     const char *button5_txt, const char *button6_txt,

                     const CImg<t>& logo, const bool centering = false) {

 #if cimg_display!=0

     const unsigned char

       black[] = { 0,0,0 }, white[] = { 255,255,255 }, gray[] = { 200,200,200 }, gray2[] = { 150,150,150 };


     // Create buttons and canvas graphics

     CImgList<unsigned char> buttons, cbuttons, sbuttons;

     if (button1_txt) { CImg<unsigned char>().draw_text(0,0,button1_txt,black,gray,1,13).transfer_to(buttons);

       if (button2_txt) { CImg<unsigned char>().draw_text(0,0,button2_txt,black,gray,1,13).transfer_to(buttons);

         if (button3_txt) { CImg<unsigned char>().draw_text(0,0,button3_txt,black,gray,1,13).transfer_to(buttons);

           if (button4_txt) { CImg<unsigned char>().draw_text(0,0,button4_txt,black,gray,1,13).transfer_to(buttons);

             if (button5_txt) { CImg<unsigned char>().draw_text(0,0,button5_txt,black,gray,1,13).transfer_to(buttons);

               if (button6_txt) { CImg<unsigned char>().draw_text(0,0,button6_txt,black,gray,1,13).transfer_to(buttons);

               }}}}}}

     if (!buttons.width)

       throw CImgArgumentException("cimg::dialog() : No buttons have been defined. At least one is necessary");


     unsigned int bw = 0, bh = 0;

     cimglist_for(buttons,l) { bw = cimg::max(bw,buttons[l].width); bh = cimg::max(bh,buttons[l].height); }

     bw+=8; bh+=8;

     if (bw<64) bw=64;

     if (bw>128) bw=128;

     if (bh<24) bh=24;

     if (bh>48) bh=48;


     CImg<unsigned char> button(bw,bh,1,3);

     button.draw_rectangle(0,0,bw-1,bh-1,gray);

     button.draw_line(0,0,bw-1,0,white).draw_line(0,bh-1,0,0,white);

     button.draw_line(bw-1,0,bw-1,bh-1,black).draw_line(bw-1,bh-1,0,bh-1,black);

     button.draw_line(1,bh-2,bw-2,bh-2,gray2).draw_line(bw-2,bh-2,bw-2,1,gray2);

     CImg<unsigned char> sbutton(bw,bh,1,3);

     sbutton.draw_rectangle(0,0,bw-1,bh-1,gray);

     sbutton.draw_line(0,0,bw-1,0,black).draw_line(bw-1,0,bw-1,bh-1,black);

     sbutton.draw_line(bw-1,bh-1,0,bh-1,black).draw_line(0,bh-1,0,0,black);

     sbutton.draw_line(1,1,bw-2,1,white).draw_line(1,bh-2,1,1,white);

     sbutton.draw_line(bw-2,1,bw-2,bh-2,black).draw_line(bw-2,bh-2,1,bh-2,black);

     sbutton.draw_line(2,bh-3,bw-3,bh-3,gray2).draw_line(bw-3,bh-3,bw-3,2,gray2);

     sbutton.draw_line(4,4,bw-5,4,black,1,0xAAAAAAAA,true).draw_line(bw-5,4,bw-5,bh-5,black,1,0xAAAAAAAA,false);

     sbutton.draw_line(bw-5,bh-5,4,bh-5,black,1,0xAAAAAAAA,false).draw_line(4,bh-5,4,4,black,1,0xAAAAAAAA,false);

     CImg<unsigned char> cbutton(bw,bh,1,3);

     cbutton.draw_rectangle(0,0,bw-1,bh-1,black).draw_rectangle(1,1,bw-2,bh-2,gray2).draw_rectangle(2,2,bw-3,bh-3,gray);

     cbutton.draw_line(4,4,bw-5,4,black,1,0xAAAAAAAA,true).draw_line(bw-5,4,bw-5,bh-5,black,1,0xAAAAAAAA,false);

     cbutton.draw_line(bw-5,bh-5,4,bh-5,black,1,0xAAAAAAAA,false).draw_line(4,bh-5,4,4,black,1,0xAAAAAAAA,false);


     cimglist_for(buttons,ll) {

       CImg<unsigned char>(cbutton).draw_image(1+(bw-buttons[ll].dimx())/2,1+(bh-buttons[ll].dimy())/2,buttons[ll]).

         transfer_to(cbuttons);

       CImg<unsigned char>(sbutton).draw_image((bw-buttons[ll].dimx())/2,(bh-buttons[ll].dimy())/2,buttons[ll]).

         transfer_to(sbuttons);

       CImg<unsigned char>(button).draw_image((bw-buttons[ll].dimx())/2,(bh-buttons[ll].dimy())/2,buttons[ll]).

         transfer_to(buttons[ll]);

     }


     CImg<unsigned char> canvas;

     if (msg) CImg<unsigned char>().draw_text(0,0,"%s",black,gray,1,13,msg).transfer_to(canvas);

     const unsigned int

       bwall = (buttons.width-1)*(12+bw) + bw,

       w = cimg::max(196U,36+logo.width+canvas.width, 24+bwall),

       h = cimg::max(96U,36+canvas.height+bh,36+logo.height+bh),

       lx = 12 + (canvas.data?0:((w-24-logo.width)/2)),

       ly = (h-12-bh-logo.height)/2,

       tx = lx+logo.width+12,

       ty = (h-12-bh-canvas.height)/2,

       bx = (w-bwall)/2,

       by = h-12-bh;


     if (canvas.data)

       canvas = CImg<unsigned char>(w,h,1,3).

         draw_rectangle(0,0,w-1,h-1,gray).

         draw_line(0,0,w-1,0,white).draw_line(0,h-1,0,0,white).

         draw_line(w-1,0,w-1,h-1,black).draw_line(w-1,h-1,0,h-1,black).

         draw_image(tx,ty,canvas);

     else

       canvas = CImg<unsigned char>(w,h,1,3).

         draw_rectangle(0,0,w-1,h-1,gray).

         draw_line(0,0,w-1,0,white).draw_line(0,h-1,0,0,white).

         draw_line(w-1,0,w-1,h-1,black).draw_line(w-1,h-1,0,h-1,black);

     if (logo.data) canvas.draw_image(lx,ly,logo);


     unsigned int xbuttons[6] = { 0 };

     cimglist_for(buttons,lll) { xbuttons[lll] = bx+(bw+12)*lll; canvas.draw_image(xbuttons[lll],by,buttons[lll]); }


     // Open window and enter events loop

     CImgDisplay disp(canvas,title?title:" ",0,false,centering?true:false);

     if (centering) disp.move((CImgDisplay::screen_dimx()-disp.dimx())/2,

                              (CImgDisplay::screen_dimy()-disp.dimy())/2);

     bool stopflag = false, refresh = false;

     int oselected = -1, oclicked = -1, selected = -1, clicked = -1;

     while (!disp.is_closed && !stopflag) {

       if (refresh) {

         if (clicked>=0) CImg<unsigned char>(canvas).draw_image(xbuttons[clicked],by,cbuttons[clicked]).display(disp);

         else {

           if (selected>=0) CImg<unsigned char>(canvas).draw_image(xbuttons[selected],by,sbuttons[selected]).display(disp);

           else canvas.display(disp);

         }

         refresh = false;

       }

       disp.wait(15);

       if (disp.is_resized) disp.resize(disp);


       if (disp.button&1)  {

         oclicked = clicked;

         clicked = -1;

         cimglist_for(buttons,l)

           if (disp.mouse_y>=(int)by && disp.mouse_y<(int)(by+bh) &&

               disp.mouse_x>=(int)xbuttons[l] && disp.mouse_x<(int)(xbuttons[l]+bw)) {

             clicked = selected = l;

             refresh = true;

           }

         if (clicked!=oclicked) refresh = true;

       } else if (clicked>=0) stopflag = true;


       if (disp.key) {

         oselected = selected;

         switch (disp.key) {

         case cimg::keyESC : selected=-1; stopflag=true; break;

         case cimg::keyENTER : if (selected<0) selected = 0; stopflag = true; break;

         case cimg::keyTAB :

         case cimg::keyARROWRIGHT :

         case cimg::keyARROWDOWN : selected = (selected+1)%buttons.width; break;

         case cimg::keyARROWLEFT :

         case cimg::keyARROWUP : selected = (selected+buttons.width-1)%buttons.width; break;

         }

         disp.key = 0;

         if (selected!=oselected) refresh = true;

       }

     }

     if (!disp) selected = -1;

     return selected;

 #else

     std::fprintf(cimg_stdout,"<%s>\n\n%s\n\n",title,msg);

     return -1+0*(int)(button1_txt-button2_txt+button3_txt-button4_txt+button5_txt-button6_txt+logo.width+(int)centering);

 #endif

   }


   inline int dialog(const char *title, const char *msg,

                     const char *button1_txt, const char *button2_txt, const char *button3_txt,

                     const char *button4_txt, const char *button5_txt, const char *button6_txt,

                     const bool centering) {

     return dialog(title,msg,button1_txt,button2_txt,button3_txt,button4_txt,button5_txt,button6_txt,

                   CImg<unsigned char>::logo40x38(),centering);

   }


   inline double eval(const char *const expression, const double x, const double y, const double z, const double v) {

     static const CImg<float> empty;

     return empty.eval(expression,x,y,z,v);

   }


   // End of cimg:: namespace

 }


   // End of cimg_library:: namespace

 }


 #ifdef _cimg_redefine_None

 #define None 0

 #endif

 #ifdef _cimg_redefine_min

 #define min(a,b) (((a)<(b))?(a):(b))

 #endif

 #ifdef _cimg_redefine_max

 #define max(a,b) (((a)>(b))?(a):(b))

 #endif


 #endif

 // Local Variables:

 // mode: c++

 // End:

_cimg_freturn
#define _cimg_freturn(x)
Definition: CImg.h:12224

cimg_library::CImgDisplay::dimx
int dimx() const
Return display width.
Definition: CImg.h:6623

cimg_library::CImgDisplay::is_keyPAUSE
volatile bool is_keyPAUSE
Definition: CImg.h:6187

cimg_library::CImg::min
CImg< T > & min(const CImg< t > &img)
Pointwise min operator between two images.
Definition: CImg.h:12790

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded textured triangle, with z-buffering and perspective correction...
Definition: CImg.h:25399

cimg_library::CImgList::save_yuv
const CImgList< T > & save_yuv(std::FILE *const file, const bool rgb2yuv=true) const
Save an image sequence into a YUV file.
Definition: CImg.h:36690

cimg_library::CImg::get_erode
CImg< T > get_erode(const unsigned int n, const unsigned int cond=1) const
Definition: CImg.h:19004

cimg_library::CImgList::max
T & max()
Return a reference to the maximum pixel value of the instance list.
Definition: CImg.h:34928

cimg_library::CImg::torus3d
static CImg< floatT > torus3d(CImgList< tf > &primitives, const float radius1=100, const float radius2=30, const unsigned int subdivisions1=24, const unsigned int subdivisions2=12)
Create and return a 3D torus.
Definition: CImg.h:21922

_CImgList_stdarg
#define _CImgList_stdarg(t)

cimg_file_separator
#define cimg_file_separator
Definition: CImg.h:144

cimg_library::cimg::type< signed char >::max
static signed char max()
Definition: CImg.h:2131

cimg_library::CImgDisplay::is_keyBACKSPACE
volatile bool is_keyBACKSPACE
Definition: CImg.h:6198

cimg_library::CImg::invert_endianness
CImg< T > & invert_endianness()
Invert endianness of the image buffer.
Definition: CImg.h:14951

FALSE
#define FALSE
Definition: vinci.h:133

cimg_library::CImg::_draw_polygon
CImg< T > & _draw_polygon(const t &points, const unsigned int W, const unsigned int H, const tc *const color, const float opacity, const unsigned int pattern)
Definition: CImg.h:25790

cimg_library::cimg::type< unsigned char >::format
static unsigned int format(const unsigned char val)
Definition: CImg.h:2115

_cimg_fopcode1
#define _cimg_fopcode1(op, i1)
Definition: CImg.h:12226

cimg_library::CImg::tensor
CImg< T > & tensor()
Realign pixel values of the instance image as a symmetric tensor.
Definition: CImg.h:13372

cimg_for5x5
#define cimg_for5x5(img, x, y, z, v, I)
Definition: CImg.h:1176

cimg_library::cimg::logo40x38
const unsigned char logo40x38[4576]
Definition: CImg.h:4440

cimg_library::CImg::isocurve3d
static CImg< floatT > isocurve3d(CImgList< tf > &primitives, const tfunc &func, const float isovalue, const float x0, const float y0, const float x1, const float y1, const int sizex=256, const int sizey=256)
Get isocurve as a 3D object.
Definition: CImg.h:21328

_cimg_fill1
#define _cimg_fill1(x, y, z, v, off, siz, t)

cimg_library::cimg::key4
const unsigned int key4
Definition: CImg.h:2688

if
if(dy > dx)
Definition: rational_rotation.h:90

cimg_library::cimg::keyPAD3
const unsigned int keyPAD3
Definition: CImg.h:2748

cimg_library::CImg::max
CImg< T > & max(const CImg< t > &img)
Pointwise max operator between two images.
Definition: CImg.h:12841

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &color, const float opacity=1)
Draw a 2D filled colored triangle.
Definition: CImg.h:23810

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const tc1 *const foreground_color, const tc2 *const background_color, const float opacity, const CImgList< t > &font,...)
Draw a text.
Definition: CImg.h:26338

cimg_library::CImg::mirror
CImg< T > & mirror(const char axis)
Mirror an image along the specified axis.
Definition: CImg.h:17147

cimg_library::CImg::get_shared_channels
CImg< T > get_shared_channels(const unsigned int v0, const unsigned int v1)
Return a shared-memory image referencing a set of channels (v0-&gt;v1) of the instance image...
Definition: CImg.h:18554

cimg_library::cimg::gzip_path
const char * gzip_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to the &#39;gzip&#39; command.
Definition: CImg.h:5377

cimg_library::CImg::Tuchar
cimg::superset< T, unsigned char >::type Tuchar
Definition: CImg.h:9773

cimg_library::CImg::get_load_cimg
static CImg< T > get_load_cimg(const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1, const char axis='z', const char align='p')
Definition: CImg.h:30566

cimg_library::cimg::keyP
const unsigned int keyP
Definition: CImg.h:2709

cimg_library::CImg::_cimg_math_parser::_cimg_math_parser
_cimg_math_parser(const char *const expression, const char *const funcname=0)
Definition: CImg.h:12232

cimg_library::CImg::load_off
CImg< T > & load_off(std::FILE *const file, CImgList< tf > &primitives, CImgList< tc > &colors)
Load a 3D object from a .OFF file.
Definition: CImg.h:31040

cimg_forXZV
#define cimg_forXZV(img, x, z, v)
Definition: CImg.h:605

cimg_library::CImg::get_load_raw
static CImg< T > get_load_raw(const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int sizez=1, const unsigned int sizev=1, const bool multiplexed=false, const bool invert_endianness=false)
Definition: CImg.h:30935

cimg_library::CImg::_marching2d_func_expr
Definition: CImg.h:21445

cimg_library::CImg::_save_ascii
const CImg< T > & _save_ascii(std::FILE *const file, const char *const filename) const
Definition: CImg.h:32357

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc1 > &color1, const CImg< tc2 > &color2, const CImg< tc3 > &color3, const float opacity=1)
Definition: CImg.h:24161

cimg_library::CImg::get_load_pnm
static CImg< T > get_load_pnm(const char *const filename)
Definition: CImg.h:29816

cimg_library::CImgList::Tfloat
cimg::superset< T, float >::type Tfloat
Definition: CImg.h:33910

cimg_library::CImgDisplay::is_keyF7
volatile bool is_keyF7
Definition: CImg.h:6181

cimg_library::CImg::equalize
CImg< T > & equalize(const unsigned int nb_levels, const T value_min=(T) 0, const T value_max=(T) 0)
Compute the histogram-equalized version of the instance image.
Definition: CImg.h:15305

cimg_library::cimg::keyF5
const unsigned int keyF5
Definition: CImg.h:2676

cimg_library::CImg::save_tiff
const CImg< T > & save_tiff(const char *const filename) const
Save a file in TIFF format.
Definition: CImg.h:33198

by
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed by
Definition: roccomf90.h:7

cimg_library::CImg::at
T & at(const int off, const T out_val)
Read a pixel value with Dirichlet boundary conditions.
Definition: CImg.h:11188

cimg_library::CImg::save_dlm
const CImg< T > & save_dlm(const char *const filename) const
Save the image as a DLM file.
Definition: CImg.h:32448

cimg_library::cimg::prand
unsigned int prand(const double z)
Return a random variable following a Poisson distribution of parameter z.
Definition: CImg.h:4856

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(CImgDisplay &disp, const CImg< tp > &vertices, const CImgList< tf > &primitives, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31731

cimg_library::CImgList::CImgList
CImgList(const unsigned int n, const unsigned int width, const unsigned int height=1, const unsigned int depth=1, const unsigned int dim=1)
Construct an image list containing n images with specified size.
Definition: CImg.h:33980

cimg_library::CImg::get_shared_line
const CImg< T > get_shared_line(const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0) const
Definition: CImg.h:18521

cimg_library::CImg::get_crop
CImg< T > get_crop(const int x0, const int y0, const int x1, const int y1, const bool border_condition=false) const
Definition: CImg.h:18245

cimg_library::CImgList::operator+
CImgList< T > operator+() const
Operator+() (unary).
Definition: CImg.h:34423

cimg_library::CImg::get_load_inr
static CImg< T > get_load_inr(std::FILE *const file, float *voxsize=0)
Definition: CImg.h:30608

cimg_library::CImg::get_load_gzip_external
static CImg< T > get_load_gzip_external(const char *const filename)
Definition: CImg.h:31286

cimg_library::CImgList::get_load_ffmpeg
static CImgList< T > get_load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true)
Definition: CImg.h:36121

cimg_library::CImgList::atNXY
T atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) const
Definition: CImg.h:34632

cimg_library::CImg::get_CMYKtoCMY
CImg< Tfloat > get_CMYKtoCMY() const
Definition: CImg.h:16215

cimg_library::cimg::superset< int, float >::type
float type
Definition: CImg.h:2277

cimg_library::cimg::superset< unsigned short, signed char >::type
int type
Definition: CImg.h:2251

cimg_library::CImgDisplay::is_keyF11
volatile bool is_keyF11
Definition: CImg.h:6185

cimg_library::CImg::append
CImg< T > & append(const CImg< T > &img, const char axis='x', const char align='p')
Definition: CImg.h:18648

_cimg_for_triangle2
#define _cimg_for_triangle2(img, xl, cl, xr, cr, y, x0, y0, c0, x1, y1, c1, x2, y2, c2)
Definition: CImg.h:23509

cimg_library::CImg::draw_grid
CImg< T > & draw_grid(const float deltax, const float deltay, const float offsetx, const float offsety, const bool invertx, const bool inverty, const CImg< tc > &color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw grid.
Definition: CImg.h:26752

cimg_library::CImgDisplay::is_keyQ
volatile bool is_keyQ
Definition: CImg.h:6203

cimg_library::cimg::keyQ
const unsigned int keyQ
Definition: CImg.h:2700

cimg_library::CImg::diagonal
static CImg< T > diagonal(const T &a0, const T &a1, const T &a2, const T &a3)
Return a 4x4 diagonal matrix with specified coefficients.
Definition: CImg.h:14372

cimg_library::CImg::assign
CImg< T > & assign(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
In-place version of the previous constructor.
Definition: CImg.h:10125

cimg_library::CImg::_draw_polygon
CImg< T > & _draw_polygon(const t &points, const unsigned int N, const tc *const color, const float opacity)
Definition: CImg.h:25699

_cimg_blur_patch3d_fast
#define _cimg_blur_patch3d_fast(N)

cimg_library::CImg::log10
CImg< T > & log10()
Compute the log10 of each each pixel value.
Definition: CImg.h:12560

cimg_library::CImg::shortT
cimg::last< T, short >::type shortT
Definition: CImg.h:9787

cimg_library::CImgDisplay::_fitscreen
static unsigned int _fitscreen(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const int dmin=128, const int dmax=-85, const bool return_last=false)
Definition: CImg.h:6437

cimg_library::CImg::operator*=
CImg< T > & operator*=(const CImg< t > &img)
Operator*=().
Definition: CImg.h:10695

cimg_library::cimg::superset< signed char, double >::type
double type
Definition: CImg.h:2239

cimg_library::CImg::get_label_regions
CImg< uintT > get_label_regions() const
Definition: CImg.h:15638

cimg_library::CImg::operator^=
CImg< T > & operator^=(const CImg< t > &img)
Operator^=().
Definition: CImg.h:10946

cimg_library::CImg::is_sameV
bool is_sameV(const unsigned int dv) const
Return true if image (*this) has the specified number of channels.
Definition: CImg.h:11912

cimg_library::CImgDisplay::CImgDisplay
CImgDisplay(const CImg< T > &img, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
Create a display window from an image.
Definition: CImg.h:6349

cimg_library::cimg::type< unsigned int >::min
static unsigned int min()
Definition: CImg.h:2157

cimg_library::cimg::fread
int fread(T *const ptr, const unsigned int nmemb, std::FILE *stream)
Read file data, and check for possible errors.
Definition: CImg.h:5569

cimg_library::CImgDisplay::mouse_x
volatile int mouse_x
X-coordinate of the mouse pointer on the display.
Definition: CImg.h:6135

cimg_library::exp
CImg< _cimg_Tfloat > exp(const CImg< T > &instance)
Definition: CImg.h:6016

cimg_library::cimg::_sleep
unsigned int _sleep(const unsigned int milliseconds, unsigned long &timer)
Definition: CImg.h:4635

cimg_library::CImg::begin
iterator begin()
Return an iterator to the first image pixel.
Definition: CImg.h:11152

cimg_library::CImgDisplay::is_keyAPPRIGHT
volatile bool is_keyAPPRIGHT
Definition: CImg.h:6242

cimg_library::cimg::superset< unsigned char, long >::type
long type
Definition: CImg.h:2227

cimg_library::CImgDisplay::is_keyARROWRIGHT
volatile bool is_keyARROWRIGHT
Definition: CImg.h:6247

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImgList< t > &points, const CImg< tc > &color, const float opacity=1)
Draw a filled polygon in the instance image.
Definition: CImg.h:25766

cimg_library::CImgDisplay
This class represents a window which can display CImg images and handles mouse and keyboard events...
Definition: CImg.h:6114

cimg_library::CImgList::CImgList
CImgList(const CImgList< t > &list, const bool shared)
Advanced copy constructor.
Definition: CImg.h:34112

cimg_library::cimg::gunzip_path
const char * gunzip_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to the &#39;gunzip&#39; command.
Definition: CImg.h:5408

cimg_library::CImgDisplay::CImgDisplay
CImgDisplay()
Create an empty display window.
Definition: CImg.h:6318

cimg_library::CImg::get_histogram
CImg< floatT > get_histogram(const unsigned int nb_levels, const T value_min=(T) 0, const T value_max=(T) 0) const
Definition: CImg.h:15273

cimg_library::cimg::min
cimg::superset< t1, t2 >::type min(const t1 &a, const t2 &b)
Return the minimum value between two numbers.
Definition: CImg.h:4728

cimg_library::CImgList::atNX
T & atNX(const int pos, const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the two first coordinates (pos...
Definition: CImg.h:34648

cimg_library::cimg::keyF12
const unsigned int keyF12
Definition: CImg.h:2683

cimg_library::CImg::draw_line
CImg< T > & draw_line(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D colored line, with z-buffering.
Definition: CImg.h:22514

cimg_library::cimg::strescape
void strescape(char *const s)
Replace explicit escape sequences &#39;&#39; in C-strings.
Definition: CImg.h:4962

cimg_library::CImgList::containsN
bool containsN(const int n) const
Return true if the list contains the image (n).
Definition: CImg.h:34831

cimg_library::CImg::save_cimg
const CImg< T > & save_cimg(std::FILE *const file, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
Insert the image into an existing .cimg file, at specified coordinates.
Definition: CImg.h:33305

cimg_library::CImg::_cimg_math_parser::mempos
unsigned int mempos
Definition: CImg.h:12221

cimg_library::CImg::sum
Tfloat sum() const
Return the sum of all the pixel values in an image.
Definition: CImg.h:13022

cimg_library::CImgList::contains
bool contains(const T &pixel, t &n, t &x, t &y, t &z) const
Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z).
Definition: CImg.h:34846

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw a 2D outlined colored rectangle.
Definition: CImg.h:25690

cimg_library::CImg::atXYZV
T atXYZV(const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:11227

cimg_library::cimg::grand
double grand()
Return a random variable following a gaussian distribution and a standard deviation of 1...
Definition: CImg.h:4845

cimg_library::CImg::operator&=
CImg< T > & operator&=(const t val)
Operator&amp;=().
Definition: CImg.h:10831

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14703

cimg_library::CImg::operator>>=
CImg< T > & operator>>=(const int n)
Operator&gt;&gt;=().
Definition: CImg.h:10984

cimg_library::CImgDisplay::is_key9
volatile bool is_key9
Definition: CImg.h:6196

cimg_library::CImgDisplay::is_keyPAD3
volatile bool is_keyPAD3
Definition: CImg.h:6251

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const CImg< t > &tensor, const tc *const color, const float opacity, const unsigned int pattern)
Draw an outlined ellipse.
Definition: CImg.h:26088

cimg_library::cimg::type< float >::is_float
static bool is_float()
Definition: CImg.h:2192

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImg< t > &points, const CImg< tc > &color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23472

cimg_library::CImgDisplay::is_keyPAD6
volatile bool is_keyPAD6
Definition: CImg.h:6254

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &color, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded triangle, with z-buffering.
Definition: CImg.h:24808

cimg_library::CImg::_draw_scanline
CImg< T > & _draw_scanline(const tc *const color, const float opacity=1)
Definition: CImg.h:22171

cimg_library::cimg::warn
void warn(const char *format,...)
Display a warning message.
Definition: CImg.h:4470

cimg_library::CImg::get_blur_bilateral
CImg< T > get_blur_bilateral(const float sigma_s, const float sigma_r, const int bgrid_s=-33, const int bgrid_r=32, const bool interpolation_type=true) const
Definition: CImg.h:19627

cimg_library::CImgList::atN
T & atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0)
Read a pixel value with Neumann boundary conditions for the first coordinates (pos).
Definition: CImg.h:34689

cimg_library::CImgDisplay::is_key5
volatile bool is_key5
Definition: CImg.h:6192

cimg_library::CImgDisplay::is_keySPACE
volatile bool is_keySPACE
Definition: CImg.h:6240

cimg_library::CImgList::back
CImg< T > & back()
Definition: CImg.h:34539

cimg_library::CImg::get_resize
CImg< T > get_resize(const CImgDisplay &disp, const int interpolation_type=1, const int border_condition=-1, const bool center=false) const
Definition: CImg.h:17005

cimg_library::CImg::resize_object3d
CImg< T > resize_object3d() const
Resize a 3D object so that its max dimension if one.
Definition: CImg.h:21125

cimg_library::CImg::draw_circle
CImg< T > & draw_circle(const int x0, const int y0, int radius, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw an outlined circle.
Definition: CImg.h:25943

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D textured line, with perspective correction.
Definition: CImg.h:22706

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12, const T &a13)
Return a vector with specified coefficients.
Definition: CImg.h:14250

cimg_library::CImg::get_channels
CImg< T > get_channels(const unsigned int v0, const unsigned int v1) const
Definition: CImg.h:18470

cimg_library::CImgDisplay::set_title
CImgDisplay & set_title(const char *format,...)
Set the window title.
Definition: CImg.h:6820

cimg_library::CImg::sinh
CImg< T > & sinh()
Compute the hyperbolic sine of each pixel value.
Definition: CImg.h:12620

cimg_library::cimg::type< signed char >::min
static signed char min()
Definition: CImg.h:2130

cimg_library::CImg::solve
CImg< T > & solve(const CImg< t > &A)
Solve a linear system AX=B where B=*this.
Definition: CImg.h:13559

cimg_library::CImg::ptr
const T * ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const
Definition: CImg.h:11126

_cimg_for_triangle4
#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: CImg.h:23612

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const tc *const foreground_color, const int, const float opacity, const CImgList< t > &font,...)
Draw a text.
Definition: CImg.h:26358

cimg_library::CImg::operator*
CImg< _cimg_Tt > operator*(const t val) const
Operator*().
Definition: CImg.h:10701

cimg_library::CImg::_autocrop
CImg< intT > _autocrop(const T value, const char axis) const
Definition: CImg.h:18355

cimg_library::CImg::get_vector
CImg< T > get_vector() const
Definition: CImg.h:13338

cimg_library::CImg::_load_rgb
CImg< T > & _load_rgb(std::FILE *const file, const char *const filename, const unsigned int dimw, const unsigned int dimh)
Definition: CImg.h:29966

cimg_library::cimg::type< bool >::format
static const char * format()
Definition: CImg.h:2105

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImgList< t > &points, const tc *const color, const float opacity=1)
Draw a filled polygon in the instance image.
Definition: CImg.h:25756

_cimg_fopcode5
#define _cimg_fopcode5(op, i1, i2, i3, i4, i5)
Definition: CImg.h:12229

cimg_library::CImg::operator%
CImg< Tfloat > operator%(const char *const expression) const
Operator%().
Definition: CImg.h:10819

cimg_forX
#define cimg_forX(img, x)
Definition: CImg.h:593

cimg_library::cimg::swap
void swap(T &a, T &b)
Exchange values of variables a and b.
Definition: CImg.h:4522

cimg_library::CImgDisplay::is_keyPADMUL
volatile bool is_keyPADMUL
Definition: CImg.h:6260

cimg_library::CImgList::insert
CImgList< T > & insert(const unsigned int n, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
Insert n copies of the image img into the current image list, at position pos.
Definition: CImg.h:35131

cimg_library::CImg::draw_line
CImg< T > & draw_line(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D textured line, with z-buffering and perspective correction.
Definition: CImg.h:22818

cimg_library::CImgDisplay::window_x
volatile int window_x
X-pos of the display on the screen.
Definition: CImg.h:6129

cimg_library::CImgDisplay::wait
CImgDisplay & wait()
Wait for an event occuring on the current display.
Definition: CImg.h:6876

cimg_library::cimg::keyCAPSLOCK
const unsigned int keyCAPSLOCK
Definition: CImg.h:2713

cimg_library::CImg::get_RGBtoHSV
CImg< Tfloat > get_RGBtoHSV() const
Definition: CImg.h:15821

cimg_library::CImg::pow
CImg< T > & pow(const double p)
Compute the power by p of each pixel value.
Definition: CImg.h:12722

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10)
Return a vector with specified coefficients.
Definition: CImg.h:14215

cimg_library::CImg::_save_rgb
const CImg< T > & _save_rgb(std::FILE *const file, const char *const filename) const
Definition: CImg.h:33002

cimg_library::CImgDisplay::frames_per_second
float frames_per_second()
Return the frame per second rate.
Definition: CImg.h:6667

cimg_library::CImg::linear_atXYZ
Tfloat linear_atXYZ(const float fx, const float fy=0, const float fz=0, const int v=0) const
Read a pixel value using linear interpolation and Neumann boundary conditions (first three coordinate...
Definition: CImg.h:11476

cimg_library::CImg::get_load_off
static CImg< T > get_load_off(const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
Definition: CImg.h:31034

cimg_library::CImg::is_sameYZV
bool is_sameYZV(const unsigned int dy, const unsigned int dz, const unsigned int dv) const
Return true if image (*this) has the specified height, depth and number of channels.
Definition: CImg.h:12027

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const CImg< t > &tensor, const tc *const color, const float opacity=1)
Draw an anisotropic 2D gaussian function.
Definition: CImg.h:27363

cimg_library::CImg::CImg
CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const T val)
Construct an image with given size (dx,dy,dz,dv) and with pixel having a default value val...
Definition: CImg.h:9893

_cimglist_def_is_same
#define _cimglist_def_is_same(axis)
Definition: CImg.h:34775

rs
subroutine rs(nm, n, a, w, matz, z, fv1, fv2, ierr)
Definition: arruda_boyce.f90:259

cimg_library::CImgList::begin
iterator begin()
Returns an iterator to the beginning of the vector (STL-compliant name).
Definition: CImg.h:34508

cimg_library::CImg::is_sameXY
bool is_sameXY(const CImgDisplay &disp) const
Return true if image (*this) and the display disp have same width and same height.
Definition: CImg.h:11934

cimg_library::CImg::fill
CImg< T > & fill(const char *const expression, const bool repeat_flag)
Fill image values according to the given expression, which can be a formula or a list of values...
Definition: CImg.h:14850

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const bool shared=false)
Construct an image list from five images.
Definition: CImg.h:34060

cimg_library::CImg::save_other
const CImg< T > & save_other(const char *const filename, const unsigned int quality=100) const
Definition: CImg.h:33819

cimg_library::CImg::slices
CImg< T > & slices(const unsigned int z0, const unsigned int z1)
Get a set of slices.
Definition: CImg.h:18448

cimg_library::CImg::is_sameXV
bool is_sameXV(const unsigned int dx, const unsigned int dv) const
Return true if image (*this) has the specified width and number of channels.
Definition: CImg.h:11950

cimg_library::CImg::get_blur_anisotropic
CImg< T > get_blur_anisotropic(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, const float gauss_prec=2, const unsigned int interpolation_type=0, const unsigned int fast_approx=1) const
Definition: CImg.h:19516

cimg_library::CImg::is_sameX
bool is_sameX(const CImgDisplay &disp) const
Return true if images (*this) and the display disp have same width.
Definition: CImg.h:11880

cimg_library::CImg::_load_ascii
CImg< T > & _load_ascii(std::FILE *const file, const char *const filename)
Definition: CImg.h:29283

cimg_library::CImgDisplay::fps_frames
unsigned long fps_frames
Definition: CImg.h:6268

cimg_library::CImg::save_cimg
const CImg< T > & save_cimg(const char *const filename, const bool compress=false) const
Save the image as a .cimg file.
Definition: CImg.h:33284

cimg_library::CImg::cosh
CImg< T > & cosh()
Compute the hyperbolic cosine of each pixel value.
Definition: CImg.h:12610

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const int z0, const CImg< t > &sprite, const float opacity=1)
Draw an image.
Definition: CImg.h:26202

cimg_library::CImgList::get_shared_images
const CImgList< T > get_shared_images(const unsigned int i0, const unsigned int i1) const
Definition: CImg.h:35265

_cimg_iskey_case
#define _cimg_iskey_case(k)

cimg_library::CImgDisplay::is_keyJ
volatile bool is_keyJ
Definition: CImg.h:6223

cimg_library::cimg::keyV
const unsigned int keyV
Definition: CImg.h:2728

cimg_library::CImgDisplay::is_key
bool is_key(const bool remove=false)
Test if any key has been pressed.
Definition: CImg.h:6498

cimg_library::CImgList::atNXYZV
T & atNXYZV(const int pos, const int x, const int y, const int z, const int v)
Read a pixel value with Neumann boundary conditions.
Definition: CImg.h:34561

cimg_library::CImgDisplay::is_keyF6
volatile bool is_keyF6
Definition: CImg.h:6180

cimg_library::CImg::_load_pandore
CImg< T > & _load_pandore(std::FILE *const file, const char *const filename)
Definition: CImg.h:30718

cimg_library::cimg::type< unsigned char >::string
static const char * string()
Definition: CImg.h:2110

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val) const
Definition: CImg.h:14439

cimg_library::CImg::CImg
CImg(const CImgDisplay &disp)
Construct an image from the content of a CImgDisplay instance.
Definition: CImg.h:10072

cimg_library::cimg::keyF8
const unsigned int keyF8
Definition: CImg.h:2679

cimg_library::cimg::superset3
Definition: CImg.h:2294

cimg_library::CImg::save_cpp
const CImg< T > & save_cpp(std::FILE *const file) const
Save the image as a CPP source file.
Definition: CImg.h:32417

cimg_library::CImgDisplay::is_keyU
volatile bool is_keyU
Definition: CImg.h:6209

cimg_library::CImg::linear_atXY
Tfloat linear_atXY(const float fx, const float fy, const int z=0, const int v=0) const
Read a pixel value using linear interpolation and Neumann boundary conditions (first two coordinates)...
Definition: CImg.h:11530

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const int z0, const int v0, const CImg< t > &sprite, const float opacity=1)
Draw an image.
Definition: CImg.h:26116

cimg_library::CImg::get_load_rgb
static CImg< T > get_load_rgb(const char *const filename, const unsigned int dimw, const unsigned int dimh=1)
Definition: CImg.h:29953

cimg_library::cimg::superset< unsigned int, signed char >::type
long type
Definition: CImg.h:2267

cimg_library::CImg::index
CImg< T > & index(const CImg< t > &palette, const bool dithering=false, const bool map_indexes=false)
Index multi-valued pixels of the instance image, regarding to a predefined palette.
Definition: CImg.h:15343

cimg_library::CImg::save_rgb
const CImg< T > & save_rgb(std::FILE *const file) const
Save the image as a RGB file.
Definition: CImg.h:33053

cimg_library::cimg::superset< unsigned short, float >::type
float type
Definition: CImg.h:2257

cimg_library::CImg::_marching3d_func_expr::mp
_cimg_math_parser * mp
Definition: CImg.h:21790

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const tc *const color, const float opacity=1)
Draw a 3D filled colored rectangle in the instance image, at coordinates (x0,y0,z0)-(x1,y1,z1).
Definition: CImg.h:25594

cimg_library::CImg::maxmin
const T & maxmin(t &min_val) const
Definition: CImg.h:12966

_cimg_for_triangle3
#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: CImg.h:23553

cimg_library::CImg::operator<<=
CImg< T > & operator<<=(const int n)
Operator&lt;&lt;=().
Definition: CImg.h:10973

cimg_library::sqrt
CImg< _cimg_Tfloat > sqrt(const CImg< T > &instance)
Definition: CImg.h:6011

cimg_library::cimg::superset< unsigned long, float >::type
float type
Definition: CImg.h:2284

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const T val)
In-place version of the corresponding constructor.
Definition: CImg.h:34179

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImgList< t > &points, const tc *const color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23443

cimg_library::CImg::get_blur_median
CImg< T > get_blur_median(const unsigned int n) const
Definition: CImg.h:19815

cimg_library::CImg::get_sqr
CImg< Tfloat > get_sqr() const
Definition: CImg.h:12525

cimg_library::CImg::get_columns
CImg< T > get_columns(const unsigned int x0, const unsigned int x1) const
Definition: CImg.h:18416

cimg_library::CImg::crop
CImg< T > & crop(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)
Get a square region of the image.
Definition: CImg.h:18184

cimg_library::cimg::superset< signed char, float >::type
float type
Definition: CImg.h:2238

cimg_library::CImg::uintT
cimg::last< T, unsigned int >::type uintT
Definition: CImg.h:9788

cimg_library::CImg::CMYtoRGB
CImg< T > & CMYtoRGB()
Convert (C,M,Y) pixels of a color image into the (R,G,B) color space.
Definition: CImg.h:16154

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const bool shared=false)
Construct an image list from three images.
Definition: CImg.h:34044

cimg_library::CImg::draw_point
CImg< T > & draw_point(const int x0, const int y0, const tc *const color, const float opacity=1)
Draw a 2D colored point (pixel).
Definition: CImg.h:22192

cimg_library::CImg::_marching3d_func_float::_marching3d_func_float
_marching3d_func_float(const CImg< T > &pref)
Definition: CImg.h:21783

cimg_library::cimg::superset< bool, unsigned int >::type
unsigned int type
Definition: CImg.h:2214

cimg_library::CImg::get_load_rgba
static CImg< T > get_load_rgba(const char *const filename, const unsigned int dimw, const unsigned int dimh=1)
Definition: CImg.h:29999

cimg_library::cimg::keyPAGEUP
const unsigned int keyPAGEUP
Definition: CImg.h:2698

cimg_library::CImg::ellipsoid3d
static CImg< floatT > ellipsoid3d(CImgList< tf > &primitives, const CImg< t > &tensor, const unsigned int subdivisions=3)
Create and return a 3D ellipsoid.
Definition: CImg.h:22071

cimg_library::CImg::get_blur
CImg< Tfloat > get_blur(const float sigma, const bool cond=true) const
Definition: CImg.h:19230

cimg_library::CImg::ulongT
cimg::last< T, unsigned long >::type ulongT
Definition: CImg.h:9790

cimg_library::CImgDisplay::toggle_fullscreen
CImgDisplay & toggle_fullscreen(const bool redraw=true)
Toggle fullscreen mode.
Definition: CImg.h:6779

cimg_library::CImgDisplay::is_keyCTRLLEFT
volatile bool is_keyCTRLLEFT
Definition: CImg.h:6237

cimg_library::CImg::tan
CImg< T > & tan()
Compute the tangent of each pixel.
Definition: CImg.h:12600

cimg_library::CImg::load_off
CImg< T > & load_off(const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
Load a 3D object from a .OFF file.
Definition: CImg.h:31029

cimg_library::CImg::normalize
CImg< T > & normalize(const T value_min, const T value_max)
Linearly normalize values of the instance image between value_min and value_max.
Definition: CImg.h:15073

cimg_library::CImg::pow
CImg< T > & pow(const char *const expression)
Compute the power of each pixel value.
Definition: CImg.h:12753

cimg_library::CImgDisplay::window_y
volatile int window_y
Y-pos of the display on the screen.
Definition: CImg.h:6132

cimg_library::cimg::key5
const unsigned int key5
Definition: CImg.h:2689

cimg_display
#define cimg_display
Definition: CImg.h:172

_cimg_load_cimg_case
#define _cimg_load_cimg_case(Ts, Tss)

cimg_library::CImg::save_raw
const CImg< T > & save_raw(std::FILE *const file, const bool multiplexed=false) const
Save the image as a RAW file.
Definition: CImg.h:33569

d
const NT & d
Definition: rational_rotation.h:73

cimg_library::cimg::srand
void srand()
Definition: CImg.h:4658

cimg_library::CImg::load_dcraw_external
CImg< T > & load_dcraw_external(const char *const filename)
Load a RAW Color Camera image file, using external tool &#39;dcraw&#39;.
Definition: CImg.h:31359

cimg_library::CImgDisplay::set_mouse
CImgDisplay & set_mouse(const int posx, const int posy)
Move mouse pointer to a specific location.
Definition: CImg.h:6813

cimg_library::CImgDisplay::is_keyM
volatile bool is_keyM
Definition: CImg.h:6234

cimg_library::cimg::ror
const T ror(const T a, const unsigned int n=1)
Return a right bitwise-rotated number.
Definition: CImg.h:4677

cimg_library::CImgList::Tint
cimg::superset< T, int >::type Tint
Definition: CImg.h:33907

cimg_library::CImgList::load_yuv
CImgList< T > & load_yuv(const char *const filename, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
Load an image sequence from a YUV file.
Definition: CImg.h:35875

cimg_library::CImg::_draw_ellipse
CImg< T > & _draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle, const tc *const color, const float opacity, const unsigned int pattern)
Definition: CImg.h:25951

cimg_library::CImg::sin
CImg< T > & sin()
Compute the sinus of each pixel value.
Definition: CImg.h:12590

cimg_library::CImgList::reverse
CImgList< T > & reverse()
Reverse list order.
Definition: CImg.h:35232

cimg_library::CImg::is_shared
bool is_shared
Variable telling if pixel buffer of the instance image is shared with another one.
Definition: CImg.h:9747

cimg_library::CImg::min
T & min()
Return a reference to the minimum pixel value of the instance image.
Definition: CImg.h:12881

cimg_library::CImg::CImg
CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const char *const values, const bool repeat_values)
Construct an image with given size and with specified values given in a string.
Definition: CImg.h:9928

cimg_library::CImg::label_regions
CImg< T > & label_regions()
Create a map of indexed labels counting disconnected regions with same intensities.
Definition: CImg.h:15634

cimg_library::CImg::end
const_iterator end() const
Definition: CImg.h:11165

cimg_library::CImgList::front
CImg< T > & front()
Returns a reference to the first element (STL-compliant name).
Definition: CImg.h:34526

cimg_library::cimg::option
const char * option(const char *const name, const int argc, const char *const *const argv, const char *defaut, const char *const usage=0)
Definition: CImg.h:5604

cimg_library::CImgList::operator,
CImgList< T > & operator,(const CImg< t > &img)
Operator,().
Definition: CImg.h:34429

cimg_library::cimg::type< int >::min
static int min()
Definition: CImg.h:2166

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc *const color, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded triangle.
Definition: CImg.h:24608

cimg_library::CImgDisplay::is_keyPAD4
volatile bool is_keyPAD4
Definition: CImg.h:6252

cimg_library::CImg::diagonal
static CImg< T > diagonal(const T &a0, const T &a1)
Return a 2x2 diagonal matrix with specified coefficients.
Definition: CImg.h:14362

cimg_library::CImg::is_sameV
bool is_sameV(const CImg< t > &img) const
Return true if images (*this) and img have same dim.
Definition: CImg.h:11918

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &color, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded colored triangle.
Definition: CImg.h:24033

cimg_library::cimg::keyG
const unsigned int keyG
Definition: CImg.h:2718

cimg_library::cimg::keyK
const unsigned int keyK
Definition: CImg.h:2721

cimg_library::CImg::is_sameXV
bool is_sameXV(const CImg< t > &img) const
Return true if images have same width and same number of channels.
Definition: CImg.h:11956

cimg_library::cimg::superset< signed char, int >::type
int type
Definition: CImg.h:2235

cimg_library::CImg::fill
CImg< T > & fill(const CImg< t > &values, const bool repeat_values=true)
Fill image values according to the values found in the specified image.
Definition: CImg.h:14885

cimg_library::CImgDisplay::fullscreen
CImgDisplay & fullscreen(const bool redraw=true)
Set fullscreen mode.
Definition: CImg.h:6765

cimg_library::cimg::mod
T mod(const T &x, const T &m)
Return the modulo of a number.
Definition: CImg.h:4788

cimg_library::CImgList::shortT
cimg::last< T, short >::type shortT
Definition: CImg.h:33916

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(const char *const title, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31715

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImgList< t > &points, CImg< tc > &color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23454

cimg_library::cimg::filenamerand
const char * filenamerand()
Definition: CImg.h:4996

cimg_library::CImgList::ptr
CImg< T > * ptr()
Return a pointer to the image buffer.
Definition: CImg.h:34475

cimg_library::CImg::get_matrix_at
CImg< T > get_matrix_at(const unsigned int x=0, const unsigned int y=0, const unsigned int z=0) const
Return a new image corresponding to the square matrix located at (x,y,z) of the current vector-valued...
Definition: CImg.h:13281

cimg_library::CImg::get_LabtoXYZ
CImg< Tfloat > get_LabtoXYZ() const
Definition: CImg.h:16354

cimg_library::CImgList::load_parrec
CImgList< T > & load_parrec(const char *const filename)
Load an image list from a PAR/REC (Philips) file.
Definition: CImg.h:35781

cimg_library::cimg::type
Definition: CImg.h:2084

cimg_library::cimg::superset< unsigned short, unsigned long >::type
unsigned long type
Definition: CImg.h:2255

k
j indices k indices k
Definition: Indexing.h:6

cimg_library::CImg::CImg
CImg(const CImg< T > &img)
Definition: CImg.h:10006

y
void int int REAL REAL * y
Definition: read.cpp:74

cimg_library::cimg::type< unsigned short >::format
static unsigned int format(const unsigned short val)
Definition: CImg.h:2142

cimg_library::CImg::get_stats
CImg< Tfloat > get_stats(const unsigned int variance_method=1) const
Definition: CImg.h:13152

cimg_library::CImgList::display
const CImgList< T > & display(const char *const title=0, const bool display_info=true, const char axis='x', const char align='p') const
Display the current CImgList instance in a new display window.
Definition: CImg.h:36328

cimg_library::cimg::keyCTRLLEFT
const unsigned int keyCTRLLEFT
Definition: CImg.h:2734

cimg_library::CImgDisplay::show
CImgDisplay & show()
Show a closed display.
Definition: CImg.h:6786

cimg_library::cimg::keyF11
const unsigned int keyF11
Definition: CImg.h:2682

cimg_library::CImgList::atNX
T & atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0)
Read a pixel value with Neumann boundary conditions for the two first coordinates (pos...
Definition: CImg.h:34657

cimg_library::CImgList::Tlong
cimg::superset< T, long >::type Tlong
Definition: CImg.h:33909

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34242

cimg_library::CImgList::_atNXYZ
T _atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) const
Definition: CImg.h:34611

cimg_library::CImg::is_overlapped
bool is_overlapped(const CImg< t > &img) const
Return true if the memory buffers of the two images overlaps.
Definition: CImg.h:12115

cimg_library::CImgList::contains
bool contains(const T &pixel, t &n, t &x, t &y, t &z, t &v) const
Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z,v).
Definition: CImg.h:34838

cimg_library::cimg::keyJ
const unsigned int keyJ
Definition: CImg.h:2720

cimg_library::CImg::assign
CImg< T > & assign(const T *const data_buffer, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Definition: CImg.h:10188

cimg_library::CImg::operator--
CImg< T > operator--(int)
Operator–() (postfix).
Definition: CImg.h:10640

cimg_library::CImg::get_YUVtoRGB
CImg< Tuchar > get_YUVtoRGB() const
Definition: CImg.h:16125

cimg_library::CImgList::assign
CImgList< T > & assign(const char *const filename)
In-place version of the corresponding constructor.
Definition: CImg.h:34291

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11)
Return a vector with specified coefficients.
Definition: CImg.h:14226

cimg_library::CImg::_save_jpeg
const CImg< T > & _save_jpeg(std::FILE *const file, const char *const filename, const unsigned int quality) const
Definition: CImg.h:32554

cimg_library::CImgList::CImgList
CImgList(const CImgDisplay &disp)
Construct an image list from a display.
Definition: CImg.h:34123

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2, const T val3, const T val4)
Fill sequentially all pixel values with values val0 and val1 and val2 and val3 and val4...
Definition: CImg.h:14492

cimg_library::CImg::get_eigen
CImgList< Tfloat > get_eigen() const
Definition: CImg.h:13695

cimg_library::CImg::_draw_object3d
CImg< T > & _draw_object3d(void *const pboard, CImg< floatT > &zbuffer, const float X, const float Y, const float Z, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const to &opacities, const unsigned int nb_opacities, const unsigned int render_type, const bool double_sided, const float focale, const float lightx, const float lighty, const float lightz, const float specular_light, const float specular_shine)
Definition: CImg.h:27625

_cimg_exception_err
#define _cimg_exception_err(etype, disp_flag)
Definition: CImg.h:2021

Rotation
Definition: aff_transformation_tags.h:60

cimg_library::CImg::save_gzip_external
const CImg< T > & save_gzip_external(const char *const filename) const
Save an image as a gzipped file, using external tool &#39;gzip&#39;.
Definition: CImg.h:33718

cimg_library::CImg::plane3d
static CImg< floatT > plane3d(CImgList< tf > &primitives, const float size_x=100, const float size_y=100, const unsigned int subdivisions_x=10, const unsigned int subdivisions_y=10, const bool double_sided=false)
Create and return a 3D XY-plane.
Definition: CImg.h:21972

cimg_library::CImgDisplay::key
volatile unsigned int & key
Key value if pressed.
Definition: CImg.h:6154

cimg_OS
#define cimg_OS
Definition: CImg.h:96

cimg_library::CImgList::get_load_yuv
static CImgList< T > get_load_yuv(const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
Definition: CImg.h:35882

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(const char *const title, const CImg< tp > &vertices, const CImgList< tf > &primitives, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31746

cimg_library::cimg::superset< char, int >::type
int type
Definition: CImg.h:2245

cimg_library::CImg::get_blur_bilateral
CImg< T > get_blur_bilateral(const float sigma_x, const float sigma_y, const float sigma_z, const float sigma_r, const int bgrid_x, const int bgrid_y, const int bgrid_z, const int bgrid_r, const bool interpolation_type=true) const
Definition: CImg.h:19614

cimg_library::CImgList::CImgList
CImgList()
Default constructor.
Definition: CImg.h:33971

real
float real
Definition: gridutil.h:70

cimg_library::CImg::display
const CImg< T > & display(CImgDisplay &disp, const bool display_info) const
Display an image in a window with a title title, and wait a &#39;is_closed&#39; or &#39;keyboard&#39; event...
Definition: CImg.h:31469

cimg_library::CImgList::CImgList
CImgList(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const T val)
Construct an image list containing n images with specified size, filled with specified value...
Definition: CImg.h:33988

cimg_library::cimg::type< signed char >::string
static const char * string()
Definition: CImg.h:2128

dx
NT dx
Definition: rational_rotation.h:81

cimg_library::CImgList::get_load_parrec
static CImgList< T > get_load_parrec(const char *const filename)
Definition: CImg.h:35870

cimg_library::pseudoinvert
CImg< _cimg_Tfloat > pseudoinvert(const CImg< T > &instance)
Definition: CImg.h:6091

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14803

cimg_library::CImg::get_diagonal
CImg< T > get_diagonal() const
Definition: CImg.h:13408

cimg_library::CImg::Tdouble
cimg::superset< T, double >::type Tdouble
Definition: CImg.h:9782

cimg_library::CImg::draw_grid
CImg< T > & draw_grid(const CImg< tx > &xvalues, const CImg< ty > &yvalues, const tc *const color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw grid.
Definition: CImg.h:26700

cimg_library::CImg::get_hessian
CImgList< Tfloat > get_hessian(const char *const axes=0) const
Get components of the Hessian matrix of an image.
Definition: CImg.h:20120

cimg_library::cimg::temporary
T & temporary(const T &)
Return a reference to a temporary variable of type T.
Definition: CImg.h:4515

cimg_library::CImg::get_load_cimg
static CImg< T > get_load_cimg(const char *const filename, const char axis='z', const char align='p')
Definition: CImg.h:30538

cimg_library::cimg::superset< char, unsigned short >::type
int type
Definition: CImg.h:2242

_cimg_blur_patch2d
#define _cimg_blur_patch2d(N)

cimg_library::CImgList::operator()
const T & operator()(const unsigned int pos, const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const
Definition: CImg.h:34382

cimg_library::CImg::line
CImg< T > & line(const unsigned int y0)
Get a line.
Definition: CImg.h:18421

cimg_library::CImg::get_select_graph
CImg< intT > get_select_graph(CImgDisplay &disp, const unsigned int plot_type=1, const unsigned int vertex_type=1, const char *const labelx=0, const double xmin=0, const double xmax=0, const char *const labely=0, const double ymin=0, const double ymax=0) const
Select sub-graph in a graph.
Definition: CImg.h:28923

cimg_library::CImg::get_XYZtoxyY
CImg< Tfloat > get_XYZtoxyY() const
Definition: CImg.h:16380

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D textured line.
Definition: CImg.h:22603

cimg_library::CImg::is_sameZV
bool is_sameZV(const CImg< t > &img) const
Return true if images have same depth and same number of channels.
Definition: CImg.h:11989

cimg_library::CImg::LabtoRGB
CImg< T > & LabtoRGB()
Convert a (L,a,b) image to a (R,G,B) one.
Definition: CImg.h:16419

s
double s
Definition: blastest.C:80

cimg_library::CImg::atXYZ
T atXYZ(const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:11262

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(const char *const title, const CImg< tp > &vertices, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31775

cimg_library::CImgList::_atNXY
T & _atNXY(const int pos, const int x, const int y, const int z=0, const int v=0)
Definition: CImg.h:34639

cimg_library::CImg::HSLtoRGB
CImg< T > & HSLtoRGB()
Convert color pixels from (H,S,L) to (R,G,B).
Definition: CImg.h:15911

cimg_library::CImgDisplay::normalscreen
CImgDisplay & normalscreen(const bool redraw=true)
Set normal screen mode.
Definition: CImg.h:6771

cimg_library::CImg::get_load_off
static CImg< T > get_load_off(std::FILE *const file, CImgList< tf > &primitives, CImgList< tc > &colors)
Definition: CImg.h:31045

cimg_library::CImg::erode
CImg< T > & erode(const unsigned int n, const unsigned int cond=1)
Erode the image by a square structuring element of size n.
Definition: CImg.h:18999

cimg_fitscreen
#define cimg_fitscreen(dx, dy, dz)
Definition: CImg.h:6436

cimg_library::CImg::_marching3d_indice
static int _marching3d_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)
Definition: CImg.h:21754

cimg_library::CImg::operator/
CImg< Tfloat > operator/(const char *const expression) const
Operator/().
Definition: CImg.h:10763

cimg_library::CImg::at
T & at(const int off)
Read a pixel value with Neumann boundary conditions.
Definition: CImg.h:11197

cimg_library::CImg::translate_object3d
CImg< T > & translate_object3d(const float tx, const float ty=0, const float tz=0)
Translate a 3D object.
Definition: CImg.h:21077

cimg_library::CImg::load_pandore
CImg< T > & load_pandore(std::FILE *const file)
Load an image from a PANDORE file.
Definition: CImg.h:30710

cimg_library::cimg::keyF10
const unsigned int keyF10
Definition: CImg.h:2681

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34261

cimg_library::cimg::type< long >::format
static long format(const long val)
Definition: CImg.h:2187

cimg_library::CImg::load_graphicsmagick_external
CImg< T > & load_graphicsmagick_external(const char *const filename)
Load an image using GraphicsMagick&#39;s external tool &#39;gm&#39;.
Definition: CImg.h:31221

precision
Definition: Precision.f90:53

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const CImg< t8 > &img8, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34281

cimg_library::CImg::tensor
static CImg< T > tensor(const T &a1, const T &a2, const T &a3)
Return a 2x2 symmetric matrix tensor with specified coefficients.
Definition: CImg.h:14347

cimg_library::CImgList::save_yuv
const CImgList< T > & save_yuv(const char *const filename=0, const bool rgb2yuv=true) const
Save an image sequence into a YUV file.
Definition: CImg.h:36685

cimg_library::CImg::resize_tripleXY
CImg< T > & resize_tripleXY()
Upscale an image by a factor 3x.
Definition: CImg.h:17088

cimg_library::CImg::get_pow
CImg< Tfloat > get_pow(const CImg< t > &img) const
Definition: CImg.h:12748

cimg_library::CImg::doubleT
cimg::last< T, double >::type doubleT
Definition: CImg.h:9793

cimg_library::CImg::_atXY
T _atXY(const int x, const int y, const int z=0, const int v=0) const
Definition: CImg.h:11319

cimg_library::CImgList::remove
CImgList< T > & remove(const unsigned int pos1, const unsigned int pos2)
Remove the images from positions pos1 to pos2.
Definition: CImg.h:35173

cimg_library::CImg::is_sameYV
bool is_sameYV(const CImg< t > &img) const
Return true if images have same height and same number of channels.
Definition: CImg.h:11978

cimg_library::cimg::strclean
void strclean(char *const s)
Remove useless spaces and symmetric delimiters &#39;, " and ` from a C-string.
Definition: CImg.h:4950

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14730

cimg_library::cimg::endianness
bool endianness()
Return the current endianness of the CPU.
Definition: CImg.h:4572

cimg_library::CImg::RGBtoxyY
CImg< T > & RGBtoxyY()
Convert a (R,G,B) image to a (x,y,Y) one.
Definition: CImg.h:16428

cimg_library::CImgList::begin
const_iterator begin() const
Definition: CImg.h:34512

cimg_library::CImg
Class representing an image (up to 4 dimensions wide), each pixel being of type T.
Definition: CImg.h:1905

cimg_library::CImg::operator%=
CImg< T > & operator%=(const CImg< t > &img)
Operator%=().
Definition: CImg.h:10800

cimg_library::cimg::font19x38
const unsigned int font19x38[19 *38 *256/32]
Definition: CImg.h:3403

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(CImgDisplay &disp, const CImg< tp > &vertices, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31761

cimg_library::CImg::symmetric_eigen
const CImg< T > & symmetric_eigen(CImg< t > &val, CImg< t > &vec) const
Compute the eigenvalues and eigenvectors of a symmetric matrix.
Definition: CImg.h:13703

cimg_library::CImg::_at
T & _at(const int off)
Definition: CImg.h:11211

cimg_library::CImg::_save_pnm
const CImg< T > & _save_pnm(std::FILE *const file, const char *const filename, const unsigned int bytes_per_pixel=0) const
Definition: CImg.h:32900

cimg_library::cimg::round
double round(const double x, const double y, const int rounding_type=0)
Return a rounded number.
Definition: CImg.h:4871

cimg_library::CImg::get_permute_axes
CImg< T > get_permute_axes(const char *order) const
Definition: CImg.h:17604

cimg_library::cimg::eval
double eval(const char *const expression, const double x=0, const double y=0, const double z=0, const double v=0)
Evaluate math expression.
Definition: CImg.h:37338

cimg_library::CImg::load_jpeg
CImg< T > & load_jpeg(const char *const filename)
Load an image from a JPEG file.
Definition: CImg.h:29493

cimg_library::CImg::_marching2d_func::ref
const CImg< T > & ref
Definition: CImg.h:21430

cimg_library::cimg::superset< unsigned short, short >::type
int type
Definition: CImg.h:2252

cimg_library::CImg::width
unsigned int width
Variable representing the width of the instance image (i.e. dimensions along the X-axis).
Definition: CImg.h:9711

cimg_library::CImgList::get_load_tiff
static CImgList< T > get_load_tiff(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)
Definition: CImg.h:36255

cimg_library::CImg::get_shared_planes
const CImg< T > get_shared_planes(const unsigned int z0, const unsigned int z1, const unsigned int v0=0) const
Definition: CImg.h:18535

cimg_library::CImg::set_linear_atXYZ
CImg & set_linear_atXYZ(const T &val, const float fx, const float fy=0, const float fz=0, const int v=0, const bool add=false)
Set a pixel value, with 3D float coordinates, using linear interpolation.
Definition: CImg.h:11744

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImgList< t > &points, const tc *const color, const float opacity, const unsigned int pattern)
Draw a polygon outline.
Definition: CImg.h:25827

cimg_library::CImg::draw_object3d
CImg< T > & draw_object3d(const float x0, const float y0, const float z0, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const unsigned int render_type=4, const bool double_sided=false, const float focale=500, const float lightx=0, const float lighty=0, const float lightz=-5000, const float specular_light=0.2f, const float specular_shine=0.1f, CImg< floatT > &zbuffer=cimg_library::CImg< floatT >::empty())
Draw a 3D object.
Definition: CImg.h:27580

cimg_library::CImgList::get_insert
CImgList< T > get_insert(const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false) const
Definition: CImg.h:35154

max
Vector_n max(const Array_n_const &v1, const Array_n_const &v2)
Definition: Vector_n.h:354

_cimg_draw_fill_test
#define _cimg_draw_fill_test(x, y, z, res)

cimg_library::CImg::_marching2d_indice
static int _marching2d_indice(const unsigned int edge, const CImg< t > &indices1, const CImg< t > &indices2, const unsigned int x, const unsigned int nx)
Definition: CImg.h:21418

cimg_library::cimg::type< int >::format
static const char * format()
Definition: CImg.h:2168

_cimg_test_temporary_path
#define _cimg_test_temporary_path(p)

cimg_library::CImg::save_imagemagick_external
const CImg< T > & save_imagemagick_external(const char *const filename, const unsigned int quality=100) const
Save the image using ImageMagick&#39;s convert.
Definition: CImg.h:33756

cimg_library::cimg::superset< bool, short >::type
short type
Definition: CImg.h:2213

cimg_library::CImg::CImg
CImg(const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Constructs a new image with given size (dx,dy,dz,dv).
Definition: CImg.h:9874

p1
NT p1
Definition: rational_rotation.h:108

cimg_library::CImgDisplay::title
char * title
Display title.
Definition: CImg.h:6144

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float sigma, const CImg< tc > &color, const float opacity=1)
Draw an isotropic 2D gaussian function.
Definition: CImg.h:27436

cimg_library::CImg::get_distance
CImg< floatT > get_distance(const T isovalue, const float sizex=1, const float sizey=1, const float sizez=1, const bool compute_sqrt=true) const
Definition: CImg.h:20447

Window
A Window object contains multiple panes and multiple data attributes.
Definition: Window.h:42

cimg_library::CImg::_load_off
CImg< T > & _load_off(std::FILE *const file, const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
Definition: CImg.h:31050

cimg_library::CImgDisplay::height
unsigned int height
Height of the display.
Definition: CImg.h:6120

cimg_library::CImg::charT
cimg::last< T, char >::type charT
Definition: CImg.h:9785

cimg_library::CImgList::Tshort
cimg::superset< T, short >::type Tshort
Definition: CImg.h:33905

cimg_library::CImg::_get_permute_axes
CImg< t > _get_permute_axes(const char *permut, const t &) const
Definition: CImg.h:17431

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const bool shared=false)
Construct an image list from six images.
Definition: CImg.h:34070

cimg_library::cimg::superset< unsigned char, double >::type
double type
Definition: CImg.h:2229

cimg_library::CImg::longT
cimg::last< T, long >::type longT
Definition: CImg.h:9791

cimg_library::CImg::mean
Tfloat mean() const
Return the mean pixel value of the instance image.
Definition: CImg.h:13032

cimg_library::CImg::get_mirror
CImg< T > get_mirror(const char axis) const
Definition: CImg.h:17212

cimg_library::CImg::isocurve3d
static CImg< floatT > isocurve3d(CImgList< tf > &primitives, const char *const expression, const float isovalue, const float x0, const float y0, const float x1, const float y1, const int sizex=256, const int sizey=256)
Definition: CImg.h:21410

cimg_library::CImg::load_inr
CImg< T > & load_inr(std::FILE *const file, float *const voxsize=0)
Load an image from an INRIMAGE-4 file.
Definition: CImg.h:30604

cimg_library::CImg::get_shared_planes
CImg< T > get_shared_planes(const unsigned int z0, const unsigned int z1, const unsigned int v0=0)
Return a shared memory image referencing a set of planes (z0-&gt;z1,v0) of the instance image...
Definition: CImg.h:18526

_cimg_Ttfloat
#define _cimg_Ttfloat
Definition: CImg.h:2302

cimg_library::CImg::load_ffmpeg_external
CImg< T > & load_ffmpeg_external(const char *const filename, const char axis='z', const char align='p')
Load a video sequence using FFMPEG&#39;s external tool &#39;ffmpeg&#39;.
Definition: CImg.h:31212

cimg_library::cimg::t_bold
const char *const *const t_bold
Definition: CImg.h:1924

cimg_library::CImg::operator-
CImg< T > operator-() const
Operator-() (unary).
Definition: CImg.h:10647

cimg_library::CImg::get_append
CImg< _cimg_Tt > get_append(const CImg< T > &img, const char axis='x', const char align='p') const
Definition: CImg.h:18655

cimg_library::CImg::operator|=
CImg< T > & operator|=(const CImg< t > &img)
Operator|=().
Definition: CImg.h:10901

cimg_library::CImgDisplay::is_keyARROWUP
volatile bool is_keyARROWUP
Definition: CImg.h:6236

cimg_library::CImgList::operator()
CImg< T > & operator()(const unsigned int pos)
Equivalent to CImgList&lt;T&gt;::operator[].
Definition: CImg.h:34369

cimg_library::CImgIOException::CImgIOException
CImgIOException(const char *format,...)
Definition: CImg.h:2052

cimg_library::CImg::select
CImg< T > & select(const char *const title, const int select_type=2, unsigned int *const XYZ=0, const unsigned char *const color=0)
Simple interface to select a shape from an image.
Definition: CImg.h:28595

cimg_library::CImg::get_max
CImg< _cimg_Tt > get_max(const CImg< t > &img) const
Definition: CImg.h:12850

cimg_library::cimg::keySHIFTRIGHT
const unsigned int keySHIFTRIGHT
Definition: CImg.h:2732

cimg_library::CImgList::get_load_cimg
static CImgList< T > get_load_cimg(std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
Definition: CImg.h:35665

cimg_library::CImgDisplay::is_keyPADDIV
volatile bool is_keyPADDIV
Definition: CImg.h:6261

cimg_library::CImg::Tbool
cimg::superset< T, bool >::type Tbool
Definition: CImg.h:9772

_cimg_save_cimg_case
#define _cimg_save_cimg_case(Ts, Tss)

cimg_library::cimg::type< unsigned int >::max
static unsigned int max()
Definition: CImg.h:2158

cimg_library::CImg::get_cut
CImg< T > get_cut(const T value_min, const T value_max) const
Definition: CImg.h:15179

cimg_library::CImgList::atNXY
T & atNXY(const int pos, const int x, const int y, const int z=0, const int v=0)
Read a pixel value with Neumann boundary conditions for the three first coordinates (pos...
Definition: CImg.h:34625

cimg_library::CImg::operator++
CImg< T > operator++(int)
Operator++() (postfix).
Definition: CImg.h:10562

_cimg_draw_fill_set
#define _cimg_draw_fill_set(x, y, z)

cimg_library::cimg::superset< unsigned short, unsigned int >::type
unsigned int type
Definition: CImg.h:2253

cimg_library::CImgList::_load_cimg
CImgList< T > & _load_cimg(std::FILE *const file, const char *const filename)
Definition: CImg.h:35550

cimg_library::CImgList::assign
CImgList< T > & assign(const CImgDisplay &disp)
In-place version of the corresponding constructor.
Definition: CImg.h:34296

cimg_library::CImg::eigen
const CImg< T > & eigen(CImg< t > &val, CImg< t > &vec) const
Compute the eigenvalues and eigenvectors of a matrix.
Definition: CImg.h:13660

cimg_library::CImg::get_atan
CImg< Tfloat > get_atan() const
Definition: CImg.h:12665

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14672

cimg_library::CImg::Tlong
cimg::superset< T, long >::type Tlong
Definition: CImg.h:9780

cimg_library::CImg::blur_bilateral
CImg< T > & blur_bilateral(const float sigma_s, const float sigma_r, const int bgrid_s=-33, const int bgrid_r=32, const bool interpolation_type=true)
Blur an image using the bilateral filter.
Definition: CImg.h:19621

cimg_library::CImg::correlate
CImg< T > & correlate(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_correl=false)
Compute the correlation of the instance image by a mask.
Definition: CImg.h:18685

cimg_library::CImgDisplay::is_keyPAD1
volatile bool is_keyPAD1
Definition: CImg.h:6249

cimg_library::CImg::_marching3d_func_float
Definition: CImg.h:21781

cimg_library::cimg::keyPADADD
const unsigned int keyPADADD
Definition: CImg.h:2755

cimg_library::CImg::_marching2d_func_float
Definition: CImg.h:21437

cimg_library::CImg::save_ffmpeg
const CImg< T > & save_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int fps=25) const
Save the image as a video sequence file, using FFMPEG library.
Definition: CImg.h:33574

cimg_library::CImg::dilate
CImg< T > & dilate(const unsigned int n, const unsigned int cond=1)
Dilate the image by a square structuring element of size n.
Definition: CImg.h:19099

cimg_library::CImg::assign
CImg< T > & assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const double val0, const double val1,...)
In-place version of the previous constructor.
Definition: CImg.h:10164

cimg_library::CImg::load_other
CImg< T > & load_other(const char *const filename)
Load an image using ImageMagick&#39;s or GraphicsMagick&#39;s executables.
Definition: CImg.h:31393

cimg_forYZ
#define cimg_forYZ(img, y, z)
Definition: CImg.h:599

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw a 2D outlined colored triangle.
Definition: CImg.h:23836

cimg_library::CImgList::_atN
T _atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:34707

cimg_library::cimg::superset< short, unsigned long >::type
long type
Definition: CImg.h:2262

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc *const color, const float opacity, const unsigned int pattern)
Draw a 2D outlined colored triangle.
Definition: CImg.h:23819

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6) const
Definition: CImg.h:14551

cimg_library::CImg::get_pow
CImg< Tfloat > get_pow(const char *const expression) const
Definition: CImg.h:12774

cimg_library::CImgList::get_remove
CImgList< T > get_remove() const
Definition: CImg.h:35227

cimg_library::CImg::floatT
cimg::last< T, float >::type floatT
Definition: CImg.h:9792

cimg_library::CImg::autocrop
CImg< T > & autocrop(const T *const color, const char *const axes="zyx")
Autocrop an image, regarding of the specified backround color.
Definition: CImg.h:18302

cimg_library::CImgList::ptr
CImg< T > * ptr(const unsigned int l)
Return a pointer to the image buffer.
Definition: CImg.h:34498

cimg_library::CImgDisplay::_update_iskey
void _update_iskey(const unsigned int key, const bool pressed=true)
Definition: CImg.h:6586

cimg_library::CImgDisplay::min
float min
Definition: CImg.h:6267

cimg_library::CImgList::print
const CImgList< T > & print(const char *title=0, const bool display_stats=true) const
Print informations about the list on the standard output.
Definition: CImg.h:36269

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw a 3D outlined colored rectangle in the instance image.
Definition: CImg.h:25634

cimg_library::cimg::superset< signed char, char >::type
short type
Definition: CImg.h:2231

cimg_library::CImgDisplay::assign
CImgDisplay & assign(const CImgDisplay &disp)
In-place version of the previous constructor.
Definition: CImg.h:6425

cimg_library::cimg::type< signed char >::format
static const char * format()
Definition: CImg.h:2132

cimg_library::CImgList::save_cimg
const CImgList< T > & save_cimg(const char *const filename, const bool compress=false) const
Save an image list into a CImg file (RAW binary file + simple header)
Definition: CImg.h:36757

cimg_library::CImgDisplay::is_keyB
volatile bool is_keyB
Definition: CImg.h:6232

cimg_library::CImg::get_mul
CImg< _cimg_Tt > get_mul(const CImg< t > &img) const
Definition: CImg.h:12698

cimg_library::CImg::load_cimg
CImg< T > & load_cimg(const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1, const char axis='z', const char align='p')
Load a sub-image (list) from a .cimg file.
Definition: CImg.h:30555

cimg_library::CImgDisplay::is_keyCAPSLOCK
volatile bool is_keyCAPSLOCK
Definition: CImg.h:6216

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const int, const tc *const background_color, const float opacity=1, const unsigned int font_size=11,...)
Draw a text.
Definition: CImg.h:26424

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw an outlined ellipse.
Definition: CImg.h:26073

cimg_library::CImg::get_RGBtoCMYK
CImg< Tfloat > get_RGBtoCMYK() const
Definition: CImg.h:16450

cimg_library::CImg::is_sameXZV
bool is_sameXZV(const unsigned int dx, const unsigned int dz, const unsigned int dv) const
Return true if image (*this) has the specified width, height and number of channels.
Definition: CImg.h:12016

cimg_library::CImg::get_quantize
CImg< T > get_quantize(const unsigned int n, const bool keep_range=true) const
Definition: CImg.h:15215

cimg_library::CImgDisplay::resize
CImgDisplay & resize(const bool redraw=true)
Resize a display window in its current size.
Definition: CImg.h:6725

cimg_library::CImg::display_graph
const CImg< T > & display_graph(const char *const title=0, const unsigned int plot_type=1, const unsigned int vertex_type=1, const char *const labelx=0, const double xmin=0, const double xmax=0, const char *const labely=0, const double ymin=0, const double ymax=0) const
High-level interface for displaying a graph.
Definition: CImg.h:32239

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const CImg< t8 > &img8, const bool shared=false)
Construct an image list from eight images.
Definition: CImg.h:34090

cimg_library::CImgList::assign
CImgList< T > & assign(const CImgList< t > &list, const bool shared=false)
In-place version of the copy constructor.
Definition: CImg.h:34202

cimg_library::CImg::RGBtoLab
CImg< T > & RGBtoLab()
Convert a (R,G,B) image to a (L,a,b) one.
Definition: CImg.h:16410

cimg_library::CImg::sphere3d
static CImg< floatT > sphere3d(CImgList< tf > &primitives, const float radius=50, const unsigned int subdivisions=3)
Create and return a 3D sphere.
Definition: CImg.h:22007

points
Definition: points.h:30

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded textured triangle, with z-buffering and perspective correction.
Definition: CImg.h:25037

_cimg_load_pandore_case
#define _cimg_load_pandore_case(nbdim, nwidth, nheight, ndepth, dim, stype1, stype2, stype3, ltype)

cimg_library::CImg::load_dlm
CImg< T > & load_dlm(std::FILE *const file)
Load an image from a DLM file.
Definition: CImg.h:29323

cimg_library::cimg::superset< unsigned long, double >::type
double type
Definition: CImg.h:2285

cimg_library::cimg::superset< unsigned short, char >::type
int type
Definition: CImg.h:2250

cimg_library::CImgList::CImgList
CImgList(const char *const filename)
Construct an image list from a filename.
Definition: CImg.h:34118

cimg_library::CImg::save_png
const CImg< T > & save_png(std::FILE *const file, const unsigned int bytes_per_pixel=0) const
Save a file in PNG format.
Definition: CImg.h:32895

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5)
Return a vector with specified coefficients.
Definition: CImg.h:14168

cimg_library::CImgList::assign
CImgList< T > & assign()
In-place version of the default constructor and default destructor.
Definition: CImg.h:34151

cimg_library::CImgDisplay::is_keyTAB
volatile bool is_keyTAB
Definition: CImg.h:6202

cimg_library::cimg::keyC
const unsigned int keyC
Definition: CImg.h:2727

cimg_library::CImg::is_sameX
bool is_sameX(const CImg< t > &img) const
Return true if images (*this) and img have same width.
Definition: CImg.h:11875

cimg_library::cimg::graphicsmagick_path
const char * graphicsmagick_path(const char *const user_path=0, const bool reinit_path=false)
Return path of the GraphicsMagick&#39;s gm tool.
Definition: CImg.h:5198

cimg_library::CImgList::atN
T atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:34696

cimg_library::CImgDisplay::move
CImgDisplay & move(const int posx, const int posy)
Move window.
Definition: CImg.h:6796

cimg_library::cimg::keyF9
const unsigned int keyF9
Definition: CImg.h:2680

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

cimg_library::cimg::type::max
static T max()
Definition: CImg.h:2095

cimg_library::CImg::_cimg_math_parser::opcode
unsigned int opcode(const char op, const unsigned int arg1=0, const unsigned int arg2=0, const unsigned int arg3=0, const unsigned int arg4=0, const unsigned int arg5=0)
Definition: CImg.h:12257

cimg_library::CImg::unroll
CImg< T > & unroll(const char axis)
Unroll all images values into specified axis.
Definition: CImg.h:17610

cimg_library::CImgDisplay::is_keyPADSUB
volatile bool is_keyPADSUB
Definition: CImg.h:6259

cimg_library::CImg::rotate
CImg< T > & rotate(const float angle, const float cx, const float cy, const float zoom, const unsigned int border_conditions=3, const unsigned int interpolation=1)
Rotate an image around a center point (cx,cy).
Definition: CImg.h:17745

cimg_library::CImg::get_append
CImg< T > get_append(const CImg< T > &img, const char axis='x', const char align='p') const
Definition: CImg.h:18661

cimg_library::CImg::get_correlate
CImg< _cimg_Ttfloat > get_correlate(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_correl=false) const
Definition: CImg.h:18690

cimg_library::CImgList::atNXYZ
T atNXYZ(const int pos, const int x, const int y, const int z, const int v=0) const
Definition: CImg.h:34600

cimg_library::CImg::save_pnm
const CImg< T > & save_pnm(const char *const filename, const unsigned int bytes_per_pixel=0) const
Save the image as a PNM file.
Definition: CImg.h:32992

cimg_library::cimg::keyARROWLEFT
const unsigned int keyARROWLEFT
Definition: CImg.h:2742

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const CImg< t > &xvalues, const int y, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U)
Draw a labeled horizontal axis on the instance image.
Definition: CImg.h:26589

cimg_library::CImg::get_blur_anisotropic
CImg< T > get_blur_anisotropic(const CImg< t > &G, const float amplitude=60, const float dl=0.8f, const float da=30, const float gauss_prec=2, const unsigned int interpolation_type=0, const unsigned int fast_approx=1) const
Definition: CImg.h:19500

cimg_library::CImg::const_iterator
const T * const_iterator
Const iterator type for CImg&lt;T&gt;.
Definition: CImg.h:9766

cimg_library::cimg::valuePI
const double valuePI
Definition of the mathematical constant PI.
Definition: CImg.h:2761

cimg_library::CImgDisplay::window_width
volatile unsigned int window_width
Width of the underlying window.
Definition: CImg.h:6123

cimg_library::CImg::_cimg_math_parser::code
CImgList< uintT > code
Definition: CImg.h:12219

cimg_library::CImg::magnitude
Tfloat magnitude(const int magnitude_type=2) const
Return the norm of the current vector/matrix. ntype = norm type (0=L2, 1=L1, -1=Linf).
Definition: CImg.h:13191

cimg_library::CImg::CImg
CImg(const char *const filename)
Construct an image from an image file.
Definition: CImg.h:9975

cimg_library::operator*
CImg< _cimg_Tfloat > operator*(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5981

cimg_library::cimg::key2
const unsigned int key2
Definition: CImg.h:2686

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const int z, const tc *const color, const float opacity, CImg< t > &region, const float sigma=0, const bool high_connexity=false)
Draw a 3D filled region starting from a point (x,y,\ z) in the instance image.
Definition: CImg.h:26929

cimg_library::CImgDisplayException
Definition: CImg.h:2057

cimg_library::CImg::_load_inr
CImg< T > & _load_inr(std::FILE *const file, const char *const filename, float *const voxsize)
Definition: CImg.h:30659

cimg_library::CImgList::save_ffmpeg
const CImgList< T > & save_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int fps=25) const
Save an image sequence, using FFMPEG library.
Definition: CImg.h:36413

cimg_library::CImg::draw_quiver
CImg< T > & draw_quiver(const CImg< t1 > &flow, const CImg< t2 > &color, const float opacity=1, const unsigned int sampling=25, const float factor=-20, const bool arrows=true, const unsigned int pattern=~0U)
Draw a vector field in the instance image, using a colormap.
Definition: CImg.h:26516

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2)
Return a vector with specified coefficients.
Definition: CImg.h:14147

cimg_library::CImgDisplay::wheel
volatile int wheel
Wheel state of the mouse.
Definition: CImg.h:6151

CImg_3x3x3
#define CImg_3x3x3(I, T)
Definition: CImg.h:461

cimg_library::CImgList::CImgList
CImgList(const unsigned int n, const CImg< t > &img, const bool shared=false)
Construct a list containing n copies of the image img.
Definition: CImg.h:34023

cimg_library::CImg::load_dlm
CImg< T > & load_dlm(const char *const filename)
Load an image from a DLM file.
Definition: CImg.h:29314

cimg_library::CImg::acos
CImg< T > & acos()
Compute the arc-cosine of each pixel value.
Definition: CImg.h:12640

cimg_library::CImg::identity_matrix
CImg< T > & identity_matrix()
Get an identity matrix having same dimension than instance image.
Definition: CImg.h:13416

cimg_library::cimg::type< double >::format
static double format(const double val)
Definition: CImg.h:2205

cimg_library::CImg::load_pandore
CImg< T > & load_pandore(const char *const filename)
Load an image from a PANDORE file.
Definition: CImg.h:30701

cimg_library::CImg::diagonal
static CImg< T > diagonal(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4)
Return a 5x5 diagonal matrix with specified coefficients.
Definition: CImg.h:14377

CImg_5x5
#define CImg_5x5(I, T)
Definition: CImg.h:439

cimg_library::CImgList::Tbool
cimg::superset< T, bool >::type Tbool
Definition: CImg.h:33901

cimg_library::CImg::xyYtoXYZ
CImg< T > & xyYtoXYZ()
Convert (x,y,Y) pixels of a color image into the (X,Y,Z)_709 color space.
Definition: CImg.h:16385

cimg_library::CImgList::operator=
CImgList< T > & operator=(const CImgDisplay &disp)
Operator=().
Definition: CImg.h:34399

cimg_library::CImg::linear_atX
Tfloat linear_atX(const float fx, const int y, const int z, const int v, const T out_val) const
Read a pixel value using linear interpolation and Dirichlet boundary conditions (first coordinate)...
Definition: CImg.h:11557

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImgList< t > &points, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw a polygon outline.
Definition: CImg.h:25836

cimg_library::CImg::fill
CImg< T > & fill(const T val)
Fill an image by a value val.
Definition: CImg.h:14432

cimg_library::CImg::get_erode
CImg< _cimg_Tt > get_erode(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_erosion=false) const
Definition: CImg.h:18920

_cimg_valign3d
#define _cimg_valign3d(i, j, k)

sqrt
double sqrt(double d)
Definition: double.h:73

cimg_library::cimg::superset< bool, int >::type
int type
Definition: CImg.h:2215

cimg_library::CImg::draw_point
CImg< T > & draw_point(const CImgList< t > &points, const tc *const color, const float opacity=1)
Draw a cloud of colored points.
Definition: CImg.h:22276

cimg_library::CImgList::back
const CImg< T > & back() const
Return a reference to the last image (STL-compliant name).
Definition: CImg.h:34535

cimg_library::CImg::max
CImg< T > & max(const char *const expression)
Pointwise max operator between an image and a string.
Definition: CImg.h:12855

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const int z0, const int v0, const CImg< ti > &sprite, const CImg< tm > &mask, const float opacity=1, const float mask_valmax=1)
Draw a sprite image in the instance image (masked version).
Definition: CImg.h:26243

cimg_library::CImg::operator--
CImg< T > & operator--()
Operator–() (prefix).
Definition: CImg.h:10634

cimg_library::cimg::keyESC
const unsigned int keyESC
Definition: CImg.h:2671

cimg_library::CImg::operator-
CImg< _cimg_Tt > operator-(const CImg< t > &img) const
Operator-().
Definition: CImg.h:10664

cimg_library::CImg::get_crop
CImg< T > get_crop(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) const
Definition: CImg.h:18190

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float zc, const float sigma, const tc *const color, const float opacity=1)
Draw an isotropic 3D gaussian function.
Definition: CImg.h:27492

cimg_library::CImgDisplay::is_keyPAGEDOWN
volatile bool is_keyPAGEDOWN
Definition: CImg.h:6215

cimg_library::CImg::is_sameYZV
bool is_sameYZV(const CImg< t > &img) const
Return true if images have same heigth, same depth and same number of channels.
Definition: CImg.h:12033

cimg_library::CImg::get_load_inr
static CImg< T > get_load_inr(const char *const filename, float *const voxsize=0)
Definition: CImg.h:30599

cimg_library::CImgList::FFT
CImgList< T > & FFT(const char axis, const bool invert=false)
Compute a 1-D Fast Fourier Transform, along specified axis.
Definition: CImg.h:37116

cimg_library::CImg::tensor
static CImg< T > tensor(const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6)
Return a 3x3 symmetric matrix with specified coefficients.
Definition: CImg.h:14352

cimg_library::CImg::get_shared_lines
CImg< T > get_shared_lines(const unsigned int y0, const unsigned int y1, const unsigned int z0=0, const unsigned int v0=0)
Return a shared-memory image referencing a set of lines of the instance image.
Definition: CImg.h:18496

cimg_library::CImg::norm
CImg< T > & norm(const int norm_type=2)
Compute L2-norm of each multi-valued pixel of the instance image.
Definition: CImg.h:15127

cimg_library::CImg::get_max
CImg< Tfloat > get_max(const char *const expression) const
Definition: CImg.h:12876

cimg_library::CImg::deriche
CImg< T > & deriche(const float sigma, const int order=0, const char axis='x', const bool cond=true)
Compute the result of the Deriche filter.
Definition: CImg.h:19118

cimg_library::CImg::_cimg_math_parser::result
unsigned int result
Definition: CImg.h:12221

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded textured triangle.
Definition: CImg.h:25180

cimg_library::CImgDisplay::~CImgDisplay
~CImgDisplay()
Destructor.
Definition: CImg.h:6313

cimg_library::CImg::column
CImg< T > & column(const unsigned int x0)
Get one column.
Definition: CImg.h:18403

cimg_library::CImg::_marching2d_func::_marching2d_func
_marching2d_func(const CImg< T > &pref)
Definition: CImg.h:21431

cimg_library::CImg::get_dijkstra
CImg< Tfloat > get_dijkstra(const unsigned int starting_node, const unsigned int ending_node=~0U) const
Definition: CImg.h:14128

cimg_library::CImgList::contains
bool contains(const T &pixel, t &n) const
Return true if one of the image list contains the specified referenced value. If true, set coordinates (n).
Definition: CImg.h:34867

cimg_library::CImgList::minmax
T & minmax(t &max_val)
Return a reference to the minimum pixel value of the instance list.
Definition: CImg.h:34956

else
else
Definition: rational_rotation.h:103

cimg_library::CImgList::_atNX
T & _atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0)
Definition: CImg.h:34671

cimg_library::CImg::max
T & max()
Return a reference to the maximum pixel value of the instance image.
Definition: CImg.h:12900

cimg_library::CImg::operator+
CImg< _cimg_Tt > operator+(const t val) const
Operator+().
Definition: CImg.h:10579

cimg_forXYV
#define cimg_forXYV(img, x, y, v)
Definition: CImg.h:604

cimg_library::CImg::empty
static CImg< T > & empty()
Return a reference to an empty image.
Definition: CImg.h:10351

cimg_library::cimg::fclose
int fclose(std::FILE *file)
Close a file, and check for possible errors.
Definition: CImg.h:5507

_cimg_draw_fill_test_neighbor
#define _cimg_draw_fill_test_neighbor(x, y, z, cond)

cimg_library::CImg::save_inr
const CImg< T > & save_inr(std::FILE *const file, const float *const voxsize=0) const
Save the image as an INRIMAGE-4 file.
Definition: CImg.h:33367

cimg_library::CImg::ptr
const T * ptr() const
Definition: CImg.h:11084

cimg_library::CImg::Tchar
cimg::superset< T, char >::type Tchar
Definition: CImg.h:9774

cimg_library::CImg::_marching3d_func_expr::~_marching3d_func_expr
~_marching3d_func_expr()
Definition: CImg.h:21797

cimg_library::CImg::is_empty
bool is_empty() const
Return true if current image is empty.
Definition: CImg.h:11864

cimg_library::CImgList::ptr
const CImg< T > * ptr() const
Definition: CImg.h:34479

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const tc *const color, const float opacity, const unsigned int pattern)
Draw a 3D outlined colored rectangle in the instance image.
Definition: CImg.h:25614

cimg_library::CImg::_save_pandore
const CImg< T > & _save_pandore(std::FILE *const file, const char *const filename, const unsigned int colorspace) const
Definition: CImg.h:33385

cimg_library::CImgList::insert
CImgList< T > & insert(const CImg< T > &img, const unsigned int pos=~0U, const bool shared=false)
Definition: CImg.h:35069

cimg_library::cimg::superset< char, unsigned int >::type
long type
Definition: CImg.h:2244

cimg_library::CImg::cut
CImg< T > & cut(const T value_min, const T value_max)
Cut values of the instance image between value_min and value_max.
Definition: CImg.h:15172

cimg_library::CImgDisplay::is_keyF2
volatile bool is_keyF2
Definition: CImg.h:6176

cimg_library::CImg::get_sinh
CImg< Tfloat > get_sinh() const
Definition: CImg.h:12625

cimg_library::CImg::div
CImg< T > & div(const CImg< t > &img)
Pointwise division between two images.
Definition: CImg.h:12704

cimg_library::CImg::xyYtoRGB
CImg< T > & xyYtoRGB()
Convert a (x,y,Y) image to a (R,G,B) one.
Definition: CImg.h:16437

cimg_library::CImg::assign
CImg< T > & assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const int val0, const int val1,...)
In-place version of the previous constructor.
Definition: CImg.h:10156

cimg_library::CImgList::_save_yuv
const CImgList< T > & _save_yuv(std::FILE *const file, const char *const filename, const bool rgb2yuv) const
Definition: CImg.h:36661

den
NT & den
Definition: rational_rotation.h:80

cimg_library::CImgList::transfer_to
CImgList< T > & transfer_to(CImgList< T > &list)
Definition: CImg.h:34309

cimg_library::CImg::fillX
CImg< T > & fillX(const unsigned int y, const unsigned int z, const unsigned int v, const double a0,...)
Definition: CImg.h:14908

cimg_library::CImg::is_sameYZ
bool is_sameYZ(const unsigned int dy, const unsigned int dz) const
Return true if image (*this) has the specified height and depth.
Definition: CImg.h:11961

cimg_library::cimg::type< float >::string
static const char * string()
Definition: CImg.h:2191

cimg_library::CImgList::_save_cimg
const CImgList< T > & _save_cimg(std::FILE *const file, const char *const filename, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
Definition: CImg.h:36762

cimg_library::CImg::dijkstra
CImg< T > & dijkstra(const unsigned int starting_node, const unsigned int ending_node, CImg< t > &previous)
Return minimal path in a graph, using the Dijkstra algorithm.
Definition: CImg.h:14111

cimg_library::CImg::get_shared
CImg< T > get_shared()
Return a shared version of the instance image.
Definition: CImg.h:10077

cimg_library::CImg::data
T * data
Pointer to the first pixel of the pixel buffer.
Definition: CImg.h:9750

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14583

cimg_library::CImg::load_png
CImg< T > & load_png(std::FILE *const file)
Load an image from a PNG file.
Definition: CImg.h:29660

cimg_library::CImg::set_vector_at
CImg< T > & set_vector_at(const CImg< t > &vec, const unsigned int x, const unsigned int y=0, const unsigned int z=0)
Set the image vec as the vector valued pixel located at (x,y,z) of the current vector-valued image...
Definition: CImg.h:13298

cimg_library::CImgDisplay::is_keyPAD2
volatile bool is_keyPAD2
Definition: CImg.h:6250

cimg_library::CImg::get_resize_object3d
CImg< Tfloat > get_resize_object3d(const float sx, const float sy=-100, const float sz=-100) const
Definition: CImg.h:21120

cimg_library::cimg::keyY
const unsigned int keyY
Definition: CImg.h:2705

cimg_version
#define cimg_version
Definition: CImg.h:56

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6522

cimg_library::CImg::dimy
int dimy() const
Return the number of rows of the instance image (size along the Y-axis, i.e image height)...
Definition: CImg.h:11051

cimg_library::cimg::keyPADMUL
const unsigned int keyPADMUL
Definition: CImg.h:2757

cimg_library::CImg::_marching3d_func::operator()
float operator()(const float x, const float y, const float z) const
Definition: CImg.h:21776

cimg_library::CImgDisplay::is_keyINSERT
volatile bool is_keyINSERT
Definition: CImg.h:6199

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1) const
Definition: CImg.h:14452

cimg_library::CImgDisplay::window_dimy
int window_dimy() const
Return display window height.
Definition: CImg.h:6638

cimg_library::CImg::contains
bool contains(const T &pixel, t &x, t &y, t &z) const
Return true if specified referenced value is inside image boundaries. If true, returns pixel coordina...
Definition: CImg.h:12071

cimg_library::CImg::operator^=
CImg< T > & operator^=(const char *const expression)
Operator^=().
Definition: CImg.h:10927

cimg_library::CImg::fillY
CImg< T > & fillY(const unsigned int x, const unsigned int z, const unsigned int v, const int a0,...)
Fill image values along the Y-axis at the specified pixel position (x,z,v).
Definition: CImg.h:14914

cimg_library::CImg::atXY
T atXY(const int x, const int y, const int z=0, const int v=0) const
Definition: CImg.h:11308

cimg_library::CImgDisplay::is_keyF9
volatile bool is_keyF9
Definition: CImg.h:6183

cimg_library::CImgList::get_load
static CImgList< T > get_load(const char *const filename)
Definition: CImg.h:35528

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const int z0, const int v0, const CImg< T > &sprite, const float opacity=1)
Definition: CImg.h:26158

cimg_library::CImg::load_analyze
CImg< T > & load_analyze(const char *const filename, float *const voxsize=0)
Load an image from an ANALYZE7.5/NIFTI file.
Definition: CImg.h:30408

cimg_library::CImg::height
unsigned int height
Variable representing the height of the instance image (i.e. dimensions along the Y-axis)...
Definition: CImg.h:9722

cimg_library::cimg::type< long >::is_float
static bool is_float()
Definition: CImg.h:2183

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14577

cimg_library::CImgList::is_sameN
bool is_sameN(const unsigned int n) const
Return true if list if of specified size.
Definition: CImg.h:34739

cimg_library::CImg::Tint
cimg::superset< T, int >::type Tint
Definition: CImg.h:9778

cimg_library::CImg::_cimg_math_parser::~_cimg_math_parser
~_cimg_math_parser()
Definition: CImg.h:12254

cimg_library::CImg::draw_line
CImg< T > & draw_line(const CImgList< t > &points, const tc *const color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23006

cimg_library::cimg::last::type
t2 type
Definition: CImg.h:2298

cimg_library::CImg::get_load_bmp
static CImg< T > get_load_bmp(const char *const filename)
Definition: CImg.h:29366

cimg_library::CImg::load_png
CImg< T > & load_png(const char *const filename)
Load an image from a PNG file.
Definition: CImg.h:29651

cimg_for_outXYZV
#define cimg_for_outXYZV(img, x0, y0, z0, v0, x1, y1, z1, v1, x, y, z, v)
Definition: CImg.h:665

cimg_library::CImg::get_tensor_at
CImg< T > get_tensor_at(const unsigned int x, const unsigned int y=0, const unsigned int z=0) const
Return a new image corresponding to the diffusion tensor located at (x,y,z) of the current vector-val...
Definition: CImg.h:13289

cimg_library::CImgDisplay::is_keyA
volatile bool is_keyA
Definition: CImg.h:6217

cimg_library::CImg::dot
Tfloat dot(const CImg< t > &img) const
Return the dot product of the current vector/matrix with the vector/matrix img.
Definition: CImg.h:13256

cimg_library::CImg::draw_object3d
CImg< T > & draw_object3d(const float x0, const float y0, const float z0, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const CImg< to > &opacities, const unsigned int render_type=4, const bool double_sided=false, const float focale=500, const float lightx=0, const float lighty=0, const float lightz=-5000, const float specular_light=0.2f, const float specular_shine=0.1f, CImg< floatT > &zbuffer=cimg_library::CImg< floatT >::empty())
Definition: CImg.h:27550

cimg_library::CImgDisplay::is_keyX
volatile bool is_keyX
Definition: CImg.h:6229

cimg_library::CImg::operator+
CImg< Tfloat > operator+(const char *const expression) const
Operator+().
Definition: CImg.h:10584

cimg_library::CImgIOException
Definition: CImg.h:2051

cimg_library::CImg::rand
CImg< T > & rand(const T val_min, const T val_max)
Fill the instance image with random values between specified range.
Definition: CImg.h:14961

cimg_library::CImgList::_atNXYZV
T & _atNXYZV(const int pos, const int x, const int y, const int z, const int v)
Definition: CImg.h:34575

cimg_library::cimg::t_normal
const char t_normal[]
Definition: CImg.h:1923

cimg_library::CImg::back
const T & back() const
Return a reference to the last image pixel (STL-compliant name).
Definition: CImg.h:11179

cimg_library::CImg::get_normalize
CImg< Tfloat > get_normalize(const T value_min, const T value_max) const
Definition: CImg.h:15083

cimg_library::CImgList::ucharT
cimg::last< T, unsigned char >::type ucharT
Definition: CImg.h:33913

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5)
Fill sequentially all pixel values with values val0 and val1 and val2 and val3 and val4 and val5...
Definition: CImg.h:14511

cimg_library::CImgList::boolT
cimg::last< T, bool >::type boolT
Definition: CImg.h:33912

cimg_library::cimg::keyPAD1
const unsigned int keyPAD1
Definition: CImg.h:2746

cimg_library::CImg::CMYKtoRGB
CImg< T > & CMYKtoRGB()
Convert a (C,M,Y,K) image to a (R,G,B) one.
Definition: CImg.h:16455

cimg_library::CImgList::containsNXYZV
bool containsNXYZV(const int n, const int x=0, const int y=0, const int z=0, const int v=0) const
Return true if the list contains the pixel (n,x,y,z,v).
Definition: CImg.h:34825

cimg_library::CImgList::operator=
CImgList< T > & operator=(const char *const filename)
Operator=().
Definition: CImg.h:34414

cimg_library::CImgDisplay::flush
CImgDisplay & flush()
Clear all events of the current display.
Definition: CImg.h:6848

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14612

cimg_library::cimg::keyI
const unsigned int keyI
Definition: CImg.h:2707

cimg_library::CImg::fillZ
CImg< T > & fillZ(const unsigned int x, const unsigned int y, const unsigned int v, const int a0,...)
Fill image values along the Z-axis at the specified pixel position (x,y,v).
Definition: CImg.h:14925

cimg_library::CImg::get_sin
CImg< Tfloat > get_sin() const
Definition: CImg.h:12595

cimg_library::CImg::fillV
CImg< T > & fillV(const unsigned int x, const unsigned int y, const unsigned int z, const int a0,...)
Fill image values along the V-axis at the specified pixel position (x,y,z).
Definition: CImg.h:14938

cimg_library::CImg::det
Tfloat det() const
Return the determinant of the image, viewed as a matrix.
Definition: CImg.h:13227

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &color, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a Gouraud triangle with z-buffer consideration.
Definition: CImg.h:24134

cimg_library::CImg::_load_analyze
CImg< T > & _load_analyze(std::FILE *const file, const char *const filename, float *const voxsize=0)
Definition: CImg.h:30425

cimg_library::CImgDisplay::is_resized
volatile bool is_resized
Resized state of the window.
Definition: CImg.h:6165

cimg_library::CImgList::minmax
const T & minmax(t &max_val) const
Definition: CImg.h:34975

cimg_library::cimg::superset< bool, long >::type
long type
Definition: CImg.h:2217

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1)
Return a vector with specified coefficients.
Definition: CImg.h:14140

cimg_library::CImg::get_isocurve3d
CImg< floatT > get_isocurve3d(CImgList< tf > &primitives, const float isovalue, const int size_x=-100, const int size_y=-100) const
Create and return a isocurve of the instance image as a 3D object.
Definition: CImg.h:21228

cimg_library::CImg::get_resize
CImg< T > get_resize(const CImg< t > &src, const int interpolation_type=1, const int border_condition=-1, const bool center=false) const
Definition: CImg.h:16981

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const bool shared=false)
Construct an image list from seven images.
Definition: CImg.h:34080

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const int x0, const int y0, const float u0, const float v0, const int x1, const int y1, const float u1, const float v1, const CImg< tc > &color, const float opacity=1, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a cubic spline curve in the instance image.
Definition: CImg.h:23159

cimg_library::CImg::get_rotate
CImg< T > get_rotate(const float angle, const float cx, const float cy, const float zoom, const unsigned int border_conditions=3, const unsigned int interpolation=1) const
Definition: CImg.h:17750

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const int val0, const int val1,...)
In-place version of the corresponding constructor.
Definition: CImg.h:34187

cimg_library::CImg::~CImg
~CImg()
Destructor.
Definition: CImg.h:9845

cimg_library::tan
CImg< _cimg_Tfloat > tan(const CImg< T > &instance)
Definition: CImg.h:6046

cimg_library::CImgDisplay::is_keyK
volatile bool is_keyK
Definition: CImg.h:6224

cimg_library::CImg::get_solve_tridiagonal
CImg< _cimg_Ttfloat > get_solve_tridiagonal(const CImg< t > &a, const CImg< t > &b, const CImg< t > &c) const
Definition: CImg.h:13654

cimg_library::CImg::end
iterator end()
Return an iterator pointing after the last image pixel (STL-compliant name).
Definition: CImg.h:11161

cimg_library::CImg::operator[]
const T & operator[](const unsigned int off) const
Definition: CImg.h:10409

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded textured triangle, with perspective correction.
Definition: CImg.h:24931

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const unsigned int key5, const unsigned int key6, const unsigned int key7, const unsigned int key8, const unsigned int key9, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6559

cimg_library::CImg::get_load_pandore
static CImg< T > get_load_pandore(const char *const filename)
Definition: CImg.h:30705

cimg_library::CImg::noise
CImg< T > & noise(const double sigma, const unsigned int noise_type=0)
Add random noise to the values of the instance image.
Definition: CImg.h:15000

cimg_library::CImgList::get_load_ffmpeg_external
static CImgList< T > get_load_ffmpeg_external(const char *const filename)
Definition: CImg.h:36164

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const CImg< t > &sprite, const float opacity=1)
Draw an image.
Definition: CImg.h:26209

cimg_library::cimg::keyA
const unsigned int keyA
Definition: CImg.h:2714

cimg_library::CImg::get_xyYtoXYZ
CImg< Tfloat > get_xyYtoXYZ() const
Definition: CImg.h:16405

cimg_library::CImg::XYZtoLab
CImg< T > & XYZtoLab()
Convert (X,Y,Z)_709 pixels of a color image into the (L*,a*,b*) color space.
Definition: CImg.h:16290

cimg_library::CImgDisplay::is_key8
volatile bool is_key8
Definition: CImg.h:6195

cimg_library::cimg::type< char >::format
static const char * format()
Definition: CImg.h:2123

cimg_library::CImgList::get_insert
CImgList< T > get_insert(const unsigned int n, const unsigned int pos=~0U) const
Definition: CImg.h:35125

cimg_library::CImg::matrix
static CImg< T > matrix(const T &a0, const T &a1, const T &a2, const T &a3)
Return a 2x2 square matrix with specified coefficients.
Definition: CImg.h:14294

cimg_library::CImgDisplay::is_keyF8
volatile bool is_keyF8
Definition: CImg.h:6182

cimg_library::CImgList::load_ffmpeg
CImgList< T > & load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false)
Load an image from a video file, using ffmpeg libraries.
Definition: CImg.h:35980

cimg_library::CImg::contains
bool contains(const T &pixel, t &x) const
Return true if specified referenced value is inside image boundaries. If true, returns pixel coordina...
Definition: CImg.h:12097

cimg_library::cimg::superset< unsigned long, int >::type
long type
Definition: CImg.h:2282

cimg_library::cimg::atof
float atof(const char *const str)
Read a float number from a C-string.
Definition: CImg.h:4905

cimg_library::cimg::keyU
const unsigned int keyU
Definition: CImg.h:2706

cimg_library::CImgList::CImgList
CImgList(const CImgList< t > &list)
Default copy constructor.
Definition: CImg.h:34100

cimg_library::CImgList::doubleT
cimg::last< T, double >::type doubleT
Definition: CImg.h:33922

cimg_library::CImgList::size
unsigned int size() const
Return the size of the list.
Definition: CImg.h:34470

cimg_library::CImg::load_bmp
CImg< T > & load_bmp(const char *const filename)
Load an image from a BMP file.
Definition: CImg.h:29362

cimg_library::CImgDisplay::display
CImgDisplay & display(const CImg< T > &img)
Display an image in a window.
Definition: CImg.h:6689

cimg_library::CImg::_marching2d_func
Definition: CImg.h:21429

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6510

cimg_library::CImg::isosurface3d
static CImg< floatT > isosurface3d(CImgList< tf > &primitives, 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 int size_x=32, const int size_y=32, const int size_z=32)
Get isosurface as a 3D object.
Definition: CImg.h:21460

cimg_library::CImg::atXYZ
T & atXYZ(const int x, const int y, const int z, const int v=0)
Read a pixel value with Neumann boundary conditions for the three first coordinates (x...
Definition: CImg.h:11267

cimg_library::cimg::keyN
const unsigned int keyN
Definition: CImg.h:2730

cimg_library::CImg::convolve
CImg< T > & convolve(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_convol=false)
Compute the convolution of the image by a mask.
Definition: CImg.h:18899

cimg_library::CImgDisplay::assign
CImgDisplay & assign(const CImg< T > &img, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
In-place version of the previous constructor.
Definition: CImg.h:6404

cimg_library::CImg::draw_graph
CImg< T > & draw_graph(const CImg< t > &data, const CImg< tc > &color, const float opacity=1, const unsigned int plot_type=1, const unsigned int vertex_type=1, const double ymin=0, const double ymax=0, const bool expand=false, const unsigned int pattern=~0U)
Draw a 1D graph on the instance image.
Definition: CImg.h:26908

cimg_library::CImg::_linear_atXYZV
Tfloat _linear_atXYZV(const float fx, const float fy=0, const float fz=0, const float fv=0) const
Definition: CImg.h:11402

cimg_library::CImg::operator+=
CImg< T > & operator+=(const char *const expression)
Operator+=().
Definition: CImg.h:10524

cimg_library::CImg::get_solve
CImg< _cimg_Ttfloat > get_solve(const CImg< t > &A) const
Definition: CImg.h:13600

cimg_library::CImg::draw_line
CImg< T > & draw_line(const CImg< t > &points, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23036

cimg_library::CImg::get_autocrop
CImg< T > get_autocrop(const T value, const char *const axes="vzyx") const
Definition: CImg.h:18297

cimg_library::cimg::superset< unsigned char, char >::type
short type
Definition: CImg.h:2220

cimg_library::CImg::get_line
CImg< T > get_line(const unsigned int y0) const
Definition: CImg.h:18425

cimg_library::CImgList::ptr
const CImg< T > * ptr(const unsigned int l) const
Definition: CImg.h:34502

cimg_library::cimg::strncasecmp
int strncasecmp(const char *const s1, const char *const s2, const int l)
Compare the first n characters of two C-strings, ignoring the case.
Definition: CImg.h:4915

cimg_library::cimg::temporary_path
const char * temporary_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to store temporary files.
Definition: CImg.h:5017

cimg_library::CImg::set_linear_atXY
CImg & set_linear_atXY(const T &val, const float fx, const float fy=0, const int z=0, const int v=0, const bool add=false)
Set a pixel value, with 2D float coordinates, using linear interpolation.
Definition: CImg.h:11804

cimg_library::CImg::logo40x38
static CImg< T > logo40x38()
Definition: CImg.h:33848

cimg_library::CImgDisplay::_render_resize
static void _render_resize(const T *ptrs, const unsigned int ws, const unsigned int hs, t *ptrd, const unsigned int wd, const unsigned int hd)
Definition: CImg.h:6742

cimg_library::CImgDisplay::is_keyALTGR
volatile bool is_keyALTGR
Definition: CImg.h:6241

cimg_library::CImg::load_yuv
CImg< T > & load_yuv(const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p')
Load an image sequence from a YUV file.
Definition: CImg.h:30998

cimg_library::CImg::save_ffmpeg_external
const CImg< T > & save_ffmpeg_external(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const char *const codec="mpeg2video") const
Save the image as a video sequence file, using the external tool &#39;ffmpeg&#39;.
Definition: CImg.h:33670

cimg_library::CImg::RGBtoCMYK
CImg< T > & RGBtoCMYK()
Convert a (R,G,B) image to a (C,M,Y,K) one.
Definition: CImg.h:16446

cimg_library::CImg::edge_tensors
CImg< T > & edge_tensors(const float sharpness=0.7f, const float anisotropy=0.3f, const float alpha=0.6f, const float sigma=1.1f, const bool is_sqrt=false)
Get a diffusion tensor for edge-preserving anisotropic smoothing of an image.
Definition: CImg.h:20276

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t > &img, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34218

cimg_library::cimg::keyPAD6
const unsigned int keyPAD6
Definition: CImg.h:2751

cimg_library::CImg::get_noise
CImg< T > get_noise(const double sigma, const unsigned int noise_type=0) const
Definition: CImg.h:15055

Mesquite::length
double length(Vector3D *const v, int n)
Definition: includeLinks/Vector3D.hpp:400

_cimg_fopcode3
#define _cimg_fopcode3(op, i1, i2, i3)
Definition: CImg.h:12228

cimg_library::CImg::assign
CImg< T > & assign(const CImgDisplay &disp)
In-place version of the previous constructor.
Definition: CImg.h:10322

cimg_library::cimg::type< unsigned int >::format
static unsigned int format(const unsigned int val)
Definition: CImg.h:2160

v
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to and or **sell copies of the and to permit persons to whom the **Software is furnished to do subject to the following this list of conditions and the following disclaimers ****Redistributions in binary form must reproduce the above **copyright this list of conditions and the following **disclaimers in the documentation and or other materials **provided with the distribution ****Neither the names of the Center for Simulation of Advanced the University of nor the names of its **contributors may be used to endorse or promote products derived **from this Software without specific prior written permission ****THE SOFTWARE IS PROVIDED AS WITHOUT WARRANTY OF ANY **EXPRESS OR INCLUDING BUT NOT LIMITED TO THE WARRANTIES **OF FITNESS FOR A PARTICULAR PURPOSE AND **NONINFRINGEMENT IN NO EVENT SHALL THE CONTRIBUTORS OR **COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER WHETHER IN AN ACTION OF TORT OR **ARISING OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE **USE OR OTHER DEALINGS WITH THE SOFTWARE v
Definition: roccomf90.h:20

cimg_library::CImg::operator%=
CImg< T > & operator%=(const t val)
Operator%=().
Definition: CImg.h:10775

cimg_library::CImg::erode
CImg< T > & erode(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_erosion=false)
Return the erosion of the image by a structuring element.
Definition: CImg.h:18915

cimg_library::CImgList
Class representing list of images CImg&lt;T&gt;.
Definition: CImg.h:1906

cimg_library::cimg::type< short >::max
static short max()
Definition: CImg.h:2149

cimg_library::CImgList::save_empty_cimg
static void save_empty_cimg(std::FILE *const file, const unsigned int nb, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Create an empty .cimg file with specified dimensions.
Definition: CImg.h:36909

cimg_library::cimg::type< char >::min
static char min()
Definition: CImg.h:2121

cimg_library::cimg::font12x24
const unsigned int font12x24[12 *24 *256/32]
Definition: CImg.h:3030

cimg_library::CImg::offset
int offset(const int x, const int y=0, const int z=0, const int v=0) const
Return the offset of the pixel coordinates (x,y,z,v) with respect to the data pointer data...
Definition: CImg.h:11147

cimg_library::CImgDisplay::wait
static void wait(CImgDisplay &disp1, CImgDisplay &disp2)
Wait for any event occuring either on the display disp1 or disp2.
Definition: CImg.h:6888

cimg_library::CImgList::atNXY
T atNXY(const int pos, const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:34620

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14666

cimg_library::CImg::XYZtoRGB
CImg< T > & XYZtoRGB()
Convert (X,Y,Z)_709 pixels of a color image into the (R,G,B) color space.
Definition: CImg.h:16263

cimg_library::CImg::CMYtoCMYK
CImg< T > & CMYtoCMYK()
Convert color pixels from (C,M,Y) to (C,M,Y,K).
Definition: CImg.h:16181

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const CImg< tc1 > &foreground_color, const CImg< tc2 > &background_color, const float opacity, const CImgList< t > &font,...)
Draw a text.
Definition: CImg.h:26348

cimg_library::CImg::get_CMYKtoRGB
CImg< Tuchar > get_CMYKtoRGB() const
Definition: CImg.h:16459

cimg_library::CImg::sharpen
CImg< T > & sharpen(const float amplitude, const bool sharpen_type=false, const float edge=1, const float alpha=0, const float sigma=0)
Sharpen image using anisotropic shock filters or inverse diffusion.
Definition: CImg.h:19922

cimg_library::cimg::invert_endianness
void invert_endianness(T *const buffer, const unsigned int size)
Invert endianness of a memory buffer.
Definition: CImg.h:4579

cimg_library::CImg::at
T at(const int off) const
Definition: CImg.h:11204

cimg_library::CImg::draw_point
CImg< T > & draw_point(const CImg< t > &points, const CImg< tc > &color, const float opacity=1)
Draw a cloud of colored points.
Definition: CImg.h:22303

cimg_library::CImgArgumentException
Definition: CImg.h:2045

cimg_library::CImg::get_fill
CImg< T > get_fill(const char *const values, const bool repeat_values) const
Definition: CImg.h:14879

cimg_library::CImg::get_sqrt
CImg< Tfloat > get_sqrt() const
Definition: CImg.h:12535

cimg_library::CImg::boolT
cimg::last< T, bool >::type boolT
Definition: CImg.h:9783

cimg_library::CImgList::get_insert
CImgList< T > get_insert(const unsigned int n, const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false) const
Definition: CImg.h:35168

cimg_library::CImgWarningException::CImgWarningException
CImgWarningException(const char *format,...)
Definition: CImg.h:2064

cimg_library::CImgDisplay::is_keyF10
volatile bool is_keyF10
Definition: CImg.h:6184

cimg_library::CImg::__draw_object3d
void __draw_object3d(const unsigned int, const unsigned int, const CImg< to > &, const CImg< tc > &, const int nx0, const int ny0, const CImg< T > &sprite, const float opac)
Definition: CImg.h:27619

cimg_library::cimg::fwrite
int fwrite(const T *ptr, const unsigned int nmemb, std::FILE *stream)
Write data to a file, and check for possible errors.
Definition: CImg.h:5587

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const tc1 *const foreground_color, const tc2 *const background_color, const float opacity=1, const unsigned int font_size=11,...)
Draw a text.
Definition: CImg.h:26388

cimg_library::CImgDisplay::is_key3
volatile bool is_key3
Definition: CImg.h:6190

cimg_library::cimg::type< short >::format
static const char * format()
Definition: CImg.h:2150

cimg_library::CImg::get_shared
const CImg< T > get_shared() const
Definition: CImg.h:10081

cimg_library::cimg::exception_mode
unsigned int & exception_mode()
Get/set the current CImg exception mode.
Definition: CImg.h:1940

cimg_library::cimg::superset< short, int >::type
int type
Definition: CImg.h:2261

cimg_library::CImg::get_translate_object3d
CImg< Tfloat > get_translate_object3d(const float tx, const float ty=0, const float tz=0) const
Definition: CImg.h:21086

cimg_library::CImg::RGBtoYUV
CImg< T > & RGBtoYUV()
Convert color pixels from (R,G,B) to (Y,U,V).
Definition: CImg.h:16078

cimg_library::CImgList::is_sameNXYZV
bool is_sameNXYZV(const unsigned int n, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const
Definition: CImg.h:34820

cimg_library::cimg::type< unsigned char >::is_float
static bool is_float()
Definition: CImg.h:2111

cimg_library::cimg::type< unsigned int >::string
static const char * string()
Definition: CImg.h:2155

cimg_library::CImg::_linear_atXYZ
Tfloat _linear_atXYZ(const float fx, const float fy=0, const float fz=0, const int v=0) const
Definition: CImg.h:11483

cimg_library::CImg::operator/
CImg< _cimg_Tt > operator/(const t val) const
Operator/().
Definition: CImg.h:10758

cimg_library::CImg::begin
const_iterator begin() const
Definition: CImg.h:11156

scheme
static const int scheme
Definition: RFC_Window_overlay.C:46

cimg_library::CImg::diagonal
static CImg< T > diagonal(const T &a0, const T &a1, const T &a2)
Return a 3x3 diagonal matrix with specified coefficients.
Definition: CImg.h:14367

cimg_library::CImg::load_raw
CImg< T > & load_raw(std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int sizez=1, const unsigned int sizev=1, const bool multiplexed=false, const bool invert_endianness=false)
Load an image from a .RAW file.
Definition: CImg.h:30943

cimg_library::CImgDisplay::snapshot
const CImgDisplay & snapshot(CImg< T > &img) const
Take a snapshot of the display in the specified image.
Definition: CImg.h:6841

cimg_library::cimg::type::is_float
static bool is_float()
Definition: CImg.h:2093

cimg_library::CImgList::atNXYZ
T & atNXYZ(const int pos, const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the four first coordinates (pos...
Definition: CImg.h:34584

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImg< t > &points, const tc *const color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23463

cimg_library::CImgList::operator=
CImgList< T > & operator=(const CImgList< t > &list)
Operator=().
Definition: CImg.h:34405

cimg_library::cimg::type< long >::format
static const char * format()
Definition: CImg.h:2186

cimg_library::cimg::keyEND
const unsigned int keyEND
Definition: CImg.h:2711

cimg_library::CImgDisplay::is_keyL
volatile bool is_keyL
Definition: CImg.h:6225

cimg_library::CImg::get_RGBtoXYZ
CImg< Tfloat > get_RGBtoXYZ() const
Definition: CImg.h:16258

cimg_library::CImg::load_inr
CImg< T > & load_inr(const char *const filename, float *const voxsize=0)
Load an image from an INRIMAGE-4 file.
Definition: CImg.h:30595

cimg_library::CImgList::contains
bool contains(const CImg< T > &img) const
Return true if the list contains the image img.
Definition: CImg.h:34888

cimg_library::cimg::key9
const unsigned int key9
Definition: CImg.h:2693

cimg_library::cosh
CImg< _cimg_Tfloat > cosh(const CImg< T > &instance)
Definition: CImg.h:6066

cimg_library::CImg::operator&=
CImg< T > & operator&=(const CImg< t > &img)
Operator&amp;=().
Definition: CImg.h:10856

cimg_library::CImg::get_load_jpeg
static CImg< T > get_load_jpeg(const char *const filename)
Definition: CImg.h:29497

cimg_library::CImg::atXY
T atXY(const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:11296

cimg_library::CImg::load_cimg
CImg< T > & load_cimg(std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1, const char axis='z', const char align='p')
Load a sub-image (list) from a non-compressed .cimg file.
Definition: CImg.h:30575

cimg_library::CImg::get_asin
CImg< Tfloat > get_asin() const
Definition: CImg.h:12655

cimg_library::cimg::superset
Definition: CImg.h:2208

cimg_forXYZ
#define cimg_forXYZ(img, x, y, z)
Definition: CImg.h:603

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float opacity=1, const float brightness=1)
Draw a 2D textured triangle.
Definition: CImg.h:24191

_cimg_median_sort
#define _cimg_median_sort(a, b)

cimg_library::CImg::_atXYZV
T _atXYZV(const int x, const int y, const int z, const int v) const
Definition: CImg.h:11251

cimg_library::CImgList::min
T & min()
Return a reference to the minimum pixel value of the instance list.
Definition: CImg.h:34901

cimg_library::CImg::get_XYZtoLab
CImg< Tfloat > get_XYZtoLab() const
Definition: CImg.h:16318

cimg_library::CImg::matrix
static CImg< T > matrix(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12, const T &a13, const T &a14, const T &a15)
Return a 4x4 square matrix with specified coefficients.
Definition: CImg.h:14314

cimg_library::CImg::get_load_graphicsmagick_external
static CImg< T > get_load_graphicsmagick_external(const char *const filename)
Definition: CImg.h:31250

cimg_library::cimg::keyALTGR
const unsigned int keyALTGR
Definition: CImg.h:2738

cimg_library::CImg::MSE
Tfloat MSE(const CImg< t > &img) const
Compute the MSE (Mean-Squared Error) between two images.
Definition: CImg.h:13113

cimg_library::CImgList::load_cimg
CImgList< T > & load_cimg(const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
Load a sub-image list from a non compressed .cimg file.
Definition: CImg.h:35643

cimg_library::CImg::save_empty_cimg
static void save_empty_cimg(const char *const filename, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Save an empty .cimg file with specified dimensions.
Definition: CImg.h:33314

cimg_library::cimg::keyMENU
const unsigned int keyMENU
Definition: CImg.h:2740

cimg_library::CImg::HSVtoRGB
CImg< T > & HSVtoRGB()
Convert color pixels from (H,S,V) to (R,G,B).
Definition: CImg.h:15826

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n, const unsigned int width, const unsigned int height=1, const unsigned int depth=1, const unsigned int dim=1)
In-place version of the corresponding constructor.
Definition: CImg.h:34171

cimg_library::CImg::save_yuv
const CImg< T > & save_yuv(const char *const filename, const bool rgb2yuv=true) const
Save the image as a YUV video sequence file.
Definition: CImg.h:33594

cimg_library::CImg::operator*=
CImg< T > & operator*=(const t val)
Operator*=().
Definition: CImg.h:10670

cimg_library::CImgDisplay::wait_all
static void wait_all()
Wait for a window event in any CImg window.
Definition: CImg.h:6908

cimg_library::cimg::superset< unsigned char, unsigned long >::type
unsigned long type
Definition: CImg.h:2226

p0
NT p0
Definition: rational_rotation.h:106

cimg_library::cimg::superset< bool, char >::type
char type
Definition: CImg.h:2210

cimg_library::CImgList::get_shared
CImgList< T > get_shared()
Return a shared instance of the list.
Definition: CImg.h:34128

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const CImg< tx > &xvalues, const CImg< ty > &yvalues, const CImg< tc > &color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw a labeled horizontal+vertical axis on the instance image.
Definition: CImg.h:26663

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const CImg< ti > &sprite, const CImg< tm > &mask, const float opacity=1, const float mask_valmax=1)
Draw an image.
Definition: CImg.h:26305

cimg_library::cimg::superset< int, long >::type
long type
Definition: CImg.h:2276

copy
*********************************************************************Illinois Open Source License ****University of Illinois NCSA **Open Source License University of Illinois All rights reserved ****Developed free of to any person **obtaining a copy of this software and associated documentation to deal with the Software without including without limitation the rights to ** copy
Definition: roccomf90.h:20

cimg_library::CImgDisplay::is_keyN
volatile bool is_keyN
Definition: CImg.h:6233

cimg_library::CImgList::CImgList
CImgList(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const double val0, const double val1,...)
Construct an image list containing n images with specified size and specified pixel values (double ve...
Definition: CImg.h:34015

cimg_library::CImg::operator|=
CImg< T > & operator|=(const t val)
Operator|=().
Definition: CImg.h:10876

cimg_library::CImg::pixel_type
static const char * pixel_type()
Return the type of the pixel values.
Definition: CImg.h:11041

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int x1, const int y1, const tc *const color, const float opacity, const unsigned int pattern)
Draw a 2D outlined colored rectangle.
Definition: CImg.h:25669

cimg_library::cimg::t_purple
const char *const *const *const t_purple
Definition: CImg.h:1925

cimg_library::CImgList::atNXYZ
T & atNXYZ(const int pos, const int x, const int y, const int z, const int v=0)
Read a pixel value with Neumann boundary conditions for the four first coordinates (pos...
Definition: CImg.h:34593

cimg_library::CImg::load
CImg< T > & load(const char *const filename)
Load an image from a file.
Definition: CImg.h:29130

cimg_library::CImgDisplay::dimy
int dimy() const
Return display height.
Definition: CImg.h:6628

cimg_library::cimg::type< short >::is_float
static bool is_float()
Definition: CImg.h:2147

cimg_library::CImgDisplay::is_keyHOME
volatile bool is_keyHOME
Definition: CImg.h:6200

cimg_library::CImg::get_cos
CImg< Tfloat > get_cos() const
Definition: CImg.h:12585

cimg_library::CImg::translate_object3d
CImg< T > & translate_object3d()
Translate a 3D object so that it becomes centered.
Definition: CImg.h:21091

cimg_library::CImg::save_cimg
const CImg< T > & save_cimg(std::FILE *const file, const bool compress=false) const
Definition: CImg.h:33290

cimg_library::CImgList::save
const CImgList< T > & save(const char *const filename, const int number=-1) const
Save an image list into a file.
Definition: CImg.h:36342

cimg_library::CImgList::max
const T & max() const
Definition: CImg.h:34941

cimg_library::CImg::_atXYZ
T _atXYZ(const int x, const int y, const int z, const int v=0) const
Definition: CImg.h:11286

cimg_library::CImg::atXY
T & atXY(const int x, const int y, const int z=0, const int v=0)
Read a pixel value with Neumann boundary conditions for the two first coordinates (x...
Definition: CImg.h:11301

cimg_library::CImgList::_load_cimg
CImgList< T > & _load_cimg(std::FILE *const file, const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
Definition: CImg.h:35672

cimg_library::CImgList::~CImgList
~CImgList()
Destructor.
Definition: CImg.h:33966

cimg_library::CImg::blur_anisotropic
CImg< T > & blur_anisotropic(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, const float gauss_prec=2, const unsigned int interpolation_type=0, const unsigned int fast_approx=1)
Blur an image following in an anisotropic way.
Definition: CImg.h:19508

cimg_library::log
CImg< _cimg_Tfloat > log(const CImg< T > &instance)
Definition: CImg.h:6021

cimg_library::CImgDisplay::paint
CImgDisplay & paint()
Re-paint image content in window.
Definition: CImg.h:6835

cimg_library::CImgDisplay::assign
CImgDisplay & assign()
In-place version of the destructor.
Definition: CImg.h:6388

cimg_library::CImg::mul
CImg< T > & mul(const CImg< t > &img)
Pointwise multiplication between two images.
Definition: CImg.h:12685

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const unsigned int key5, const unsigned int key6, const unsigned int key7, const unsigned int key8, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6551

cimg_library::CImg::save_magick
const CImg< T > & save_magick(const char *const filename, const unsigned int bytes_per_pixel=0) const
Save the image using built-in ImageMagick++ library.
Definition: CImg.h:32654

cimg_library::cimg::type< unsigned char >::format
static const char * format()
Definition: CImg.h:2114

cimg_library::CImg::pseudoinvert
CImg< T > & pseudoinvert()
Compute the pseudo-inverse (Moore-Penrose) of the matrix.
Definition: CImg.h:13543

cimg_library::CImg::operator==
bool operator==(const CImg< t > &img) const
Operator==().
Definition: CImg.h:10996

cimg_library::CImgException::CImgException
CImgException()
Definition: CImg.h:2033

cimg_library::cimg::font10x13
const unsigned int font10x13[256 *10 *13/32]
Definition: CImg.h:2805

cimg_library::CImg::_marching3d_func_float::ref
const CImg< T > & ref
Definition: CImg.h:21782

cimg_get3x3
#define cimg_get3x3(img, x, y, z, v, I)
Definition: CImg.h:484

cimg_library::CImg::blur_median
CImg< T > & blur_median(const unsigned int n)
Apply a median filter.
Definition: CImg.h:19811

cimg_library::CImg::is_sameXY
bool is_sameXY(const CImg< t > &img) const
Return true if images have same width and same height.
Definition: CImg.h:11929

cimg_library::CImg::size
unsigned int size() const
Return the number of image buffer elements.
Definition: CImg.h:11075

A
rational * A
Definition: vinci_lass.c:67

cimg_library::CImg::_marching2d_func_float::_marching2d_func_float
_marching2d_func_float(const CImg< T > &pref)
Definition: CImg.h:21439

cimg_library::cimg::type::format
static const char * format(const T val)
Definition: CImg.h:2097

cimg_library::cimg::keyAPPLEFT
const unsigned int keyAPPLEFT
Definition: CImg.h:2735

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14765

cimg_library::operator|
CImg< T > operator|(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5996

cimg_library::cimg::type< unsigned char >::max
static unsigned char max()
Definition: CImg.h:2113

cimg_library::cimg::superset< bool, unsigned long >::type
unsigned long type
Definition: CImg.h:2216

cimg_library::cimg::superset< signed char, unsigned short >::type
int type
Definition: CImg.h:2232

cimg_library::CImg::transfer_to
CImgList< t > & transfer_to(CImgList< t > &list, const unsigned int pos=~0U)
Definition: CImg.h:10344

cimg_library::cimg::medcon_path
const char * medcon_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path of the XMedcon tool.
Definition: CImg.h:5302

cimg_library::CImg::get_sort
CImg< T > get_sort(const bool increasing=true) const
Definition: CImg.h:13789

cimg_library::CImg::CImg
CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const int val0, const int val1,...)
Construct an image with given size (dx,dy,dz,dv) and with specified pixel values (int version)...
Definition: CImg.h:9901

cimg_library::CImg::get_log10
CImg< Tfloat > get_log10() const
Definition: CImg.h:12565

cimg_library::cimg::superset< unsigned char, short >::type
short type
Definition: CImg.h:2223

cimg_library::CImg::save_off
const CImg< T > & save_off(const char *const filename, const CImgList< tf > &primitives, const CImgList< tc > &colors) const
Save OFF files.
Definition: CImg.h:33657

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImg< tp > &points, const CImg< tt > &tangents, const tc *const color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23425

cimg_library::CImg::get_rotate
CImg< T > get_rotate(const float angle, const unsigned int border_conditions=3, const unsigned int interpolation=1) const
Definition: CImg.h:17641

cimg_library::CImg::operator%
CImg< _cimg_Tt > operator%(const t val) const
Operator%().
Definition: CImg.h:10814

cimg_library::CImg::minmax
const T & minmax(t &max_val) const
Definition: CImg.h:12935

cimg_library::CImgList::width
unsigned int width
Size of the list (number of images).
Definition: CImg.h:33883

cimg_library::CImg::operator/=
CImg< T > & operator/=(const CImg< t > &img)
Operator/=().
Definition: CImg.h:10752

cimg_library::CImg::draw_point
CImg< T > & draw_point(const int x0, const int y0, const CImg< tc > &color, const float opacity=1)
Draw a 2D colored point (pixel).
Definition: CImg.h:22199

cimg_library::CImgDisplay::released_key
volatile unsigned int & released_key
Key value if released.
Definition: CImg.h:6158

cimg_library::CImg::min
CImg< T > & min(const char *const expression)
Pointwise min operator between an image and a string.
Definition: CImg.h:12804

cimg_library::cimg::type< unsigned short >::format
static const char * format()
Definition: CImg.h:2141

cimg_library::CImg::_get_select
CImg< intT > _get_select(CImgDisplay &disp, const char *const title, const int coords_type, unsigned int *const XYZ, const unsigned char *const color, const int origX, const int origY, const int origZ) const
Definition: CImg.h:28616

cimg_library::CImg::assign
CImg< T > & assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const T val)
In-place version of the previous constructor.
Definition: CImg.h:10151

cimg_library::CImg::containsXYZV
bool containsXYZV(const int x, const int y=0, const int z=0, const int v=0) const
Return true if pixel (x,y,z,v) is inside image boundaries.
Definition: CImg.h:12049

cimg_library::CImg::draw_point
CImg< T > & draw_point(const int x0, const int y0, const int z0, const tc *const color, const float opacity=1)
Draw a 3D colored point (voxel).
Definition: CImg.h:22206

cimg_library::CImg::get_edge_tensors
CImg< T > get_edge_tensors(const float sharpness=0.7f, const float anisotropy=0.3f, const float alpha=0.6f, const float sigma=1.1f, const bool is_sqrt=false) const
Definition: CImg.h:20322

cimg_library::CImg::stats
CImg< T > & stats(const unsigned int variance_method=1)
Compute a statistics vector (min,max,mean,variance,xmin,ymin,zmin,vmin,xmax,ymax,zmax,vmax).
Definition: CImg.h:13148

_cimg_deriche2_apply
#define _cimg_deriche2_apply

cimg_library::CImgDisplay::is_keyALT
volatile bool is_keyALT
Definition: CImg.h:6239

cimg_library::cimg::keyW
const unsigned int keyW
Definition: CImg.h:2701

cimg_library::CImg::blur
CImg< T > & blur(const float sigma, const bool cond=true)
Return a blurred version of the image, using a Canny-Deriche filter.
Definition: CImg.h:19225

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &color, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded triangle.
Definition: CImg.h:24687

cimg_library::CImg::Tushort
cimg::superset< T, unsigned short >::type Tushort
Definition: CImg.h:9775

cimg_library::cimg::keyF6
const unsigned int keyF6
Definition: CImg.h:2677

cimg_library::CImg::_cimg_math_parser::eval
double eval(const double x, const double y, const double z, const double v)
Definition: CImg.h:12512

cimg_library::CImg::operator/
CImg< _cimg_Tt > operator/(const CImg< t > &img) const
Operator/().
Definition: CImg.h:10769

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const int y0, const int z0, const CImg< ti > &sprite, const CImg< tm > &mask, const float opacity=1, const float mask_valmax=1)
Draw an image.
Definition: CImg.h:26297

cimg_library::cimg::superset< unsigned int, short >::type
long type
Definition: CImg.h:2268

cimg_library::CImgDisplay::timer
unsigned long timer
Definition: CImg.h:6268

cimg_library::transpose
CImg< T > transpose(const CImg< T > &instance)
Definition: CImg.h:6081

cimg_library::cimg::superset< unsigned char, float >::type
float type
Definition: CImg.h:2228

cimg_library::asin
CImg< _cimg_Tfloat > asin(const CImg< T > &instance)
Definition: CImg.h:6056

cimg_library::cimg::type< double >::is_float
static bool is_float()
Definition: CImg.h:2201

cimg_library::cimg::superset< char, unsigned long >::type
long type
Definition: CImg.h:2246

cimg_library::CImg::save_raw
const CImg< T > & save_raw(const char *const filename, const bool multiplexed=false) const
Save the image as a RAW file.
Definition: CImg.h:33564

cimg_library::CImg::CImg
CImg(const CImg< t > &img, const char *const dimensions, const T val)
Construct an image using dimensions of another image, and fill it with given values.
Definition: CImg.h:10059

cimg_library::CImg::transpose
CImg< T > & transpose()
Transpose the current matrix.
Definition: CImg.h:13441

cimg_library::operator^
CImg< T > operator^(const char *const expression, const CImg< T > &img)
Definition: CImg.h:6001

cimg_library::CImg::load_rgba
CImg< T > & load_rgba(const char *const filename, const unsigned int dimw, const unsigned int dimh=1)
Load an image from a RGBA file.
Definition: CImg.h:29995

cimg_library::CImg::ushortT
cimg::last< T, unsigned short >::type ushortT
Definition: CImg.h:9786

cimg_library::CImg::get_load_parrec
static CImg< T > get_load_parrec(const char *const filename, const char axis='v', const char align='p')
Definition: CImg.h:30923

cimg_library::CImg::assign
CImg< T > & assign(const CImg< t > &img, const char *const dimensions, const T val)
In-place version of the previous constructor.
Definition: CImg.h:10311

cimg_library::CImgList::atNXY
T & atNXY(const int pos, const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the three first coordinates (pos...
Definition: CImg.h:34616

cimg_library::CImg::draw_object3d
CImg< T > & draw_object3d(const float x0, const float y0, const float z0, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const CImgList< to > &opacities, const unsigned int render_type=4, const bool double_sided=false, const float focale=500, const float lightx=0, const float lighty=0, const float lightz=-5000, const float specular_light=0.2f, const float specular_shine=0.1f, CImg< floatT > &zbuffer=cimg_library::CImg< floatT >::empty())
Draw a 3D object.
Definition: CImg.h:27522

cimg_library::cimg::type< int >::is_float
static bool is_float()
Definition: CImg.h:2165

cimg_library::CImgList::pixel_type
static const char * pixel_type()
Return a string describing the type of the image pixels in the list (template parameter T)...
Definition: CImg.h:34460

cimg_library::CImgList::contains
bool contains(const T &pixel) const
Return true if one of the image list contains the specified referenced value.
Definition: CImg.h:34873

cimg_library::CImg::_quicksort
CImg< T > & _quicksort(const int min, const int max, CImg< t > &permutations, const bool increasing)
Definition: CImg.h:13794

cimg_library::CImg::operator-
CImg< _cimg_Tt > operator-(const t val) const
Operator-().
Definition: CImg.h:10653

cimg_library::cimg::type< bool >::min
static bool min()
Definition: CImg.h:2103

cimg_library::cimg::type< signed char >::is_float
static bool is_float()
Definition: CImg.h:2129

GridConversion::TestFixture::F1
double F1(double x)
Simple test function fixture returns .
Definition: GridConversionTest.H:34

cimg_library::CImg::dijkstra
CImg< T > & dijkstra(const unsigned int starting_node, const unsigned int ending_node=~0U)
Return minimal path in a graph, using the Dijkstra algorithm.
Definition: CImg.h:14124

cimg_library::CImg::get_load_rgba
static CImg< T > get_load_rgba(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1)
Definition: CImg.h:30008

cimg_library::CImgDisplay::width
unsigned int width
Width of the display.
Definition: CImg.h:6117

cimg_library::CImgList::operator<
CImgList< T > operator<(const char axis) const
Operator&lt;().
Definition: CImg.h:34445

cimg_library::CImg::normalize
CImg< T > & normalize()
Normalize multi-valued pixels of the instance image, with respect to their L2-norm.
Definition: CImg.h:15099

cimg_library::cimg::superset< bool, unsigned char >::type
unsigned char type
Definition: CImg.h:2209

cimg_library::CImg::get_load_raw
static CImg< T > get_load_raw(std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int sizez=1, const unsigned int sizev=1, const bool multiplexed=false, const bool invert_endianness=false)
Definition: CImg.h:30950

cimg_library::CImg::get_RGBtoYCbCr
CImg< Tuchar > get_RGBtoYCbCr() const
Definition: CImg.h:16046

cimg_library::CImg::is_sameYV
bool is_sameYV(const unsigned int dy, const unsigned int dv) const
Return true if image (*this) has the specified height and number of channels.
Definition: CImg.h:11972

cimg_library::CImg::dijkstra
static CImg< T > dijkstra(const tf &distance, const unsigned int nb_nodes, const unsigned int starting_node, const unsigned int ending_node, CImg< t > &previous)
Compute minimal path in a graph, using the Dijkstra algorithm.
Definition: CImg.h:14048

GridConversion::TestFixture::F2
double F2(double x)
Simple test function fixture returns .
Definition: GridConversionTest.H:40

cimg_library::CImg::operator+
CImg< _cimg_Tt > operator+(const CImg< t > &img) const
Operator+().
Definition: CImg.h:10590

cimg_library::CImgList::atNXYZV
T & atNXYZV(const int pos, const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions.
Definition: CImg.h:34552

cimg_library::CImg::vector
CImg< T > & vector()
Unroll all images values into a one-column vector.
Definition: CImg.h:13334

cimg_library::cimg::keyH
const unsigned int keyH
Definition: CImg.h:2719

cimg_library::CImgList::_atNX
T _atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:34675

cimg_for3x3
#define cimg_for3x3(img, x, y, z, v, I)
Definition: CImg.h:1081

cimg_library::cimg::keyX
const unsigned int keyX
Definition: CImg.h:2726

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D colored line.
Definition: CImg.h:22393

cimg_library::CImg::get_xyYtoRGB
CImg< Tuchar > get_xyYtoRGB() const
Definition: CImg.h:16441

cimg_library::CImg::operator,
CImgList< _cimg_Tt > operator,(CImgList< t > &list) const
Operator,().
Definition: CImg.h:11019

cimg_library::CImg::operator-=
CImg< T > & operator-=(const t val)
Operator-=().
Definition: CImg.h:10596

cimg_library::CImgDisplay::is_keyDELETE
volatile bool is_keyDELETE
Definition: CImg.h:6213

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

cimg_library::cimg::keySPACE
const unsigned int keySPACE
Definition: CImg.h:2737

cimg_library::CImgList::maxmin
T & maxmin(t &min_val)
Return a reference to the minimum pixel value of the instance list.
Definition: CImg.h:34995

cimg_library::cimg::type< long >::max
static long max()
Definition: CImg.h:2185

cimg_library::CImg::operator=
CImg< T > & operator=(const CImgDisplay &disp)
Operator=().
Definition: CImg.h:10511

cimg_library::CImg::get_slices
CImg< T > get_slices(const unsigned int z0, const unsigned int z1) const
Definition: CImg.h:18452

cimg_library::sinh
CImg< _cimg_Tfloat > sinh(const CImg< T > &instance)
Definition: CImg.h:6071

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const bool remove)
Test if a key has been pressed.
Definition: CImg.h:6504

cimg_library::CImg::_LU
CImg< T > & _LU(CImg< t > &indx, bool &d)
Definition: CImg.h:13994

cimg_library::CImgList::get_insert
CImgList< T > get_insert(const unsigned int n, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false) const
Definition: CImg.h:35140

cimg_library::CImgList::_load_yuv
CImgList< T > & _load_yuv(std::FILE *const file, const char *const filename, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame, const unsigned int last_frame, const unsigned int step_frame, const bool yuv2rgb)
Definition: CImg.h:35904

cimg_library::CImg::_distance_f
static float _distance_f(const int x, const int i, const float gi2, const float fact)
Definition: CImg.h:20537

cimg_library::CImgList::operator=
CImgList< T > & operator=(const CImgList< T > &list)
Definition: CImg.h:34409

cimg_library::CImg::operator-=
CImg< T > & operator-=(const char *const expression)
Operator-=().
Definition: CImg.h:10602

z
void int int int REAL REAL REAL * z
Definition: write.cpp:76

cimg_library::CImg::operator=
CImg< T > & operator=(const CImg< T > &img)
Definition: CImg.h:10506

cimg_library::CImg::crop
CImg< T > & crop(const int x0, const int x1, const bool border_condition=false)
Get a rectangular part of the instance image.
Definition: CImg.h:18258

cimg_library::CImgList::save_empty_cimg
static void save_empty_cimg(const char *const filename, const unsigned int nb, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Create an empty .cimg file with specified dimensions.
Definition: CImg.h:36901

cimg_library::CImg::operator+=
CImg< T > & operator+=(const t val)
Operator+=().
Definition: CImg.h:10518

cimg_library::CImg::is_sameY
bool is_sameY(const unsigned int dy) const
Return true if image (*this) has the specified height.
Definition: CImg.h:11885

_cimg_Tfloat
#define _cimg_Tfloat
Definition: CImg.h:2301

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const int x0, const int y0, const float u0, const float v0, const int x1, const int y1, const float u1, const float v1, const tc *const color, const float opacity=1, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a cubic spline curve in the instance image.
Definition: CImg.h:23122

cimg_library::CImg::load_yuv
CImg< T > & load_yuv(std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p')
Load an image sequence from a YUV file.
Definition: CImg.h:31013

cimg_library::CImg::crop
CImg< T > & crop(const int x0, const int y0, const int x1, const int y1, const bool border_condition=false)
Get a rectangular part of the instance image.
Definition: CImg.h:18239

cimg_library::CImg::_marching3d_func_expr::operator()
float operator()(const float x, const float y, const float z) const
Definition: CImg.h:21794

cimg_for_inXYZ
#define cimg_for_inXYZ(img, x0, y0, z0, x1, y1, z1, x, y, z)
Definition: CImg.h:621

cimg_library::CImgDisplay::is_keyP
volatile bool is_keyP
Definition: CImg.h:6212

cimglist_apply
#define cimglist_apply(list, fn)
Definition: CImg.h:1881

cimg_library::cimg::superset::type
T type
Definition: CImg.h:2208

cimg_library::CImgDisplay::operator=
CImgDisplay & operator=(const CImg< t > &img)
Definition: CImg.h:6465

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float sigma, const CImg< tc > &color, const float opacity=1)
Draw a 1D gaussian function in the instance image.
Definition: CImg.h:27349

cimg_library::cimg::strcasecmp
int strcasecmp(const char *const s1, const char *const s2)
Compare two C-strings, ignoring the case.
Definition: CImg.h:4928

cimg_library::CImg::iterator
T * iterator
Iterator type for CImg&lt;T&gt;.
Definition: CImg.h:9758

cimg_library::CImgList::get_load_cimg
static CImgList< T > get_load_cimg(const char *const filename)
Definition: CImg.h:35537

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImg< tp > &points, const CImg< tt > &tangents, const CImg< tc > &color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23434

cimg_library::CImg::get_slice
CImg< T > get_slice(const unsigned int z0) const
Definition: CImg.h:18443

cimg_library::cimg::font8x17
const unsigned int font8x17[8 *17 *256/32]
Definition: CImg.h:2868

cimg_library::CImg::save_off
const CImg< T > & save_off(std::FILE *const file, const CImgList< tf > &primitives, const CImgList< tc > &colors) const
Save OFF files.
Definition: CImg.h:33664

cimg_library::CImgList::_atNXYZ
T & _atNXYZ(const int pos, const int x, const int y, const int z, const int v=0)
Definition: CImg.h:34607

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14811

sin
NT & sin
Definition: rational_rotation.h:78

cimg_library::CImg::atXY
T & atXY(const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the two first coordinates (x...
Definition: CImg.h:11292

cimg_library::CImg::save_ascii
const CImg< T > & save_ascii(std::FILE *const file) const
Save the image as an ASCII file (ASCII Raw + simple header).
Definition: CImg.h:32381

cimg_library::CImg::sqrt
CImg< T > & sqrt()
Compute the square root of each pixel value.
Definition: CImg.h:12530

cimg_library::cimg::keyPAD9
const unsigned int keyPAD9
Definition: CImg.h:2754

cimg_library::CImg::is_sameYZ
bool is_sameYZ(const CImg< t > &img) const
Return true if images have same height and same depth.
Definition: CImg.h:11967

cimg_library::cimg::type< unsigned int >::format
static const char * format()
Definition: CImg.h:2159

cimg_library::CImg::assign
CImg< T > & assign()
In-place version of the default constructor/destructor.
Definition: CImg.h:10103

cimg_library::cimg::keyENTER
const unsigned int keyENTER
Definition: CImg.h:2723

cimg_library::cimg::superset< unsigned long, short >::type
long type
Definition: CImg.h:2281

cimg_library::CImgList::get_FFT
CImgList< Tfloat > get_FFT(const bool invert=false) const
Definition: CImg.h:37139

cimg_library::CImg::load_bmp
CImg< T > & load_bmp(std::FILE *const file)
Load an image from a BMP file.
Definition: CImg.h:29371

cimg_library::CImgList::charT
cimg::last< T, char >::type charT
Definition: CImg.h:33914

cimg_library::CImg::permute_axes
CImg< T > & permute_axes(const char *order)
Permute axes order.
Definition: CImg.h:17600

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12)
Return a vector with specified coefficients.
Definition: CImg.h:14237

cimg_library::cimg::keyO
const unsigned int keyO
Definition: CImg.h:2708

cimg_library::CImgList::atNXYZ
T atNXYZ(const int pos, const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:34588

cimg_library::CImgDisplay::is_keySHIFTLEFT
volatile bool is_keySHIFTLEFT
Definition: CImg.h:6227

cimg_for3XYZ
#define cimg_for3XYZ(img, x, y, z)
Definition: CImg.h:745

cimg_library::CImg::_marching2d_func_float::ref
const CImg< T > & ref
Definition: CImg.h:21438

cimg_library::CImg::_marching2d_func_float::operator()
float operator()(const float x, const float y) const
Definition: CImg.h:21440

cimg_library::cos
CImg< _cimg_Tfloat > cos(const CImg< T > &instance)
Definition: CImg.h:6036

cimg_library::CImg::linear_atXYZV
Tfloat linear_atXYZV(const float fx, const float fy=0, const float fz=0, const float fv=0) const
Read a pixel value using linear interpolation and Neumann boundary conditions.
Definition: CImg.h:11395

cimg_library::CImg::transfer_to
CImg< t > & transfer_to(CImg< t > &img)
Transfer the content of the instance image into another one in a way that memory copies are avoided i...
Definition: CImg.h:10332

cimg_library::CImg::dimz
int dimz() const
Return the number of slices of the instance image (size along the Z-axis).
Definition: CImg.h:11056

cimg_library::cimg::keyE
const unsigned int keyE
Definition: CImg.h:2702

cimg_library::cimg::keyM
const unsigned int keyM
Definition: CImg.h:2731

cimg_library::CImg::load_ascii
CImg< T > & load_ascii(const char *const filename)
Load an image from an ASCII file.
Definition: CImg.h:29266

cimg_library::cimg::number_filename
char * number_filename(const char *const filename, const int number, const unsigned int n, char *const string)
Create a numbered version of a filename.
Definition: CImg.h:5483

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle, const tc *const color, const float opacity, const unsigned int pattern)
Draw an outlined ellipse.
Definition: CImg.h:26065

cimg_library::CImgDisplay::operator=
CImgDisplay & operator=(const CImgList< t > &list)
Definition: CImg.h:6471

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const double val0, const double val1,...)
In-place version of the corresponding constructor.
Definition: CImg.h:34194

cimg_library::CImg::get_tan
CImg< Tfloat > get_tan() const
Definition: CImg.h:12605

cimg_library::cimg::winformat_string
void winformat_string(char *const s)
Definition: CImg.h:5007

cimg_library::cimg::keyT
const unsigned int keyT
Definition: CImg.h:2704

cimg_library::cimg::keyPAD2
const unsigned int keyPAD2
Definition: CImg.h:2747

cimg_library::CImg::haar
CImg< T > & haar(const bool invert=false, const unsigned int nb_scales=1)
Compute the Haar multiscale wavelet transform.
Definition: CImg.h:20729

cimg_library::CImg::get_channel
CImg< T > get_channel(const unsigned int v0) const
Definition: CImg.h:18461

cimg_library::CImg::get_load_yuv
static CImg< T > get_load_yuv(std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p')
Definition: CImg.h:31020

cimg_library::CImg::min
const T & min() const
Definition: CImg.h:12890

cimg_library::CImg::get_load_bmp
static CImg< T > get_load_bmp(std::FILE *const file)
Definition: CImg.h:29375

cimg_library::invert
CImg< _cimg_Tfloat > invert(const CImg< T > &instance)
Definition: CImg.h:6086

cimg_library::CImgDisplay::is_key6
volatile bool is_key6
Definition: CImg.h:6193

cimg_library::CImgList::data
CImg< T > * data
Pointer to the first list element.
Definition: CImg.h:33889

cimg_library::cimg::keyL
const unsigned int keyL
Definition: CImg.h:2722

cimg_library::CImgDisplay::screen_dimy
static int screen_dimy()
Return the height of the screen resolution.
Definition: CImg.h:6660

cimg_library::CImg::get_RGBtoYUV
CImg< Tfloat > get_RGBtoYUV() const
Definition: CImg.h:16098

cimg_library::CImg::get_deriche
CImg< Tfloat > get_deriche(const float sigma, const int order=0, const char axis='x', const bool cond=true) const
Definition: CImg.h:19203

cimg_library::CImg::operator>>
CImg< T > operator>>(const int n) const
Operator&gt;&gt;().
Definition: CImg.h:10990

cimg_library::CImg::operator^=
CImg< T > & operator^=(const t val)
Operator^=().
Definition: CImg.h:10921

cimg_library::CImg::get_resize_tripleXY
CImg< T > get_resize_tripleXY() const
Definition: CImg.h:17092

cimg_library::CImgList::get_split
CImgList< T > get_split(const char axis, const int nb=0) const
Definition: CImg.h:35396

cimg_library::CImgWarningException
Definition: CImg.h:2063

cimg_library::CImg::get_tanh
CImg< Tfloat > get_tanh() const
Definition: CImg.h:12635

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12, const T &a13, const T &a14)
Return a vector with specified coefficients.
Definition: CImg.h:14263

cimg_library::CImg::dimx
int dimx() const
Return the number of columns of the instance image (size along the X-axis, i.e image width)...
Definition: CImg.h:11046

cimg_library::CImg::load_analyze
CImg< T > & load_analyze(std::FILE *const file, float *const voxsize=0)
Load an image from an ANALYZE7.5/NIFTI file.
Definition: CImg.h:30417

cimg_library::CImg::tanh
CImg< T > & tanh()
Compute the hyperbolic tangent of each pixel value.
Definition: CImg.h:12630

cimg_library::cimg::keyAPPRIGHT
const unsigned int keyAPPRIGHT
Definition: CImg.h:2739

cimg_library::CImg::get_load_png
static CImg< T > get_load_png(std::FILE *const file)
Definition: CImg.h:29664

cimg_library::CImg::operator%
CImg< _cimg_Tt > operator%(const CImg< t > &img) const
Operator%().
Definition: CImg.h:10825

cimg_library::CImg::draw_circle
CImg< T > & draw_circle(const int x0, const int y0, int radius, const tc *const color, const float opacity, const unsigned int)
Draw an outlined circle.
Definition: CImg.h:25913

cimg_library::cimg::superset< unsigned long, char >::type
long type
Definition: CImg.h:2279

cimg_library::cimg::font29x57
const unsigned int font29x57[29 *57 *256/32]
Definition: CImg.h:3729

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const CImg< t > &xvalues, const int y, const tc *const color, const float opacity=1, const unsigned int pattern=~0U)
Draw a labeled horizontal axis on the instance image.
Definition: CImg.h:26565

cimg_library::cimg::superset< long, double >::type
double type
Definition: CImg.h:2287

cimg_library::CImgList::atN
T & atN(const int pos, const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the first coordinates (pos).
Definition: CImg.h:34680

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const int z, const CImg< tc > &color, const float opacity=1, const float sigma=0, const bool high_connexity=false)
Draw a 3D filled region starting from a point (x,y,\ z) in the instance image.
Definition: CImg.h:27137

cimg_library::CImgList::operator>
CImg< T > operator>(const char axis) const
Operator&gt;().
Definition: CImg.h:34440

cimg_library::CImgDisplay::is_keyAPPLEFT
volatile bool is_keyAPPLEFT
Definition: CImg.h:6238

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const int x, const CImg< t > &yvalues, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U)
Draw a labeled vertical axis on the instance image.
Definition: CImg.h:26625

cimg_library::cimg::keyHOME
const unsigned int keyHOME
Definition: CImg.h:2697

cimg_library::CImg::_cimg_math_parser::calling_function
const char * calling_function
Definition: CImg.h:12222

cimg_library::CImgDisplay::is_keyEND
volatile bool is_keyEND
Definition: CImg.h:6214

cimg_library::CImg::get_load_cimg
static CImg< T > get_load_cimg(std::FILE *const file, const char axis='z', const char align='p')
Definition: CImg.h:30550

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const unsigned int key5, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6529

cimg_library::CImg::_cimg_math_parser::mem
CImg< doubleT > mem
Definition: CImg.h:12220

cimg_library::CImg::get_max
CImg< T > get_max(const T val) const
Definition: CImg.h:12835

cimg_library::CImg::get_shared_channel
const CImg< T > get_shared_channel(const unsigned int v0) const
Definition: CImg.h:18577

cimg_library::CImgList::get_shared_images
CImgList< T > get_shared_images(const unsigned int i0, const unsigned int i1)
Get a shared sub-list.
Definition: CImg.h:35256

cimg_library::CImg::load_jpeg
CImg< T > & load_jpeg(std::FILE *const file)
Load an image from a JPEG file.
Definition: CImg.h:29502

cimg_library::CImg::resize
CImg< T > & resize(const int pdx, const int pdy=-100, const int pdz=-100, const int pdv=-100, const int interpolation_type=1, const int border_condition=-1, const bool center=false)
Resize an image.
Definition: CImg.h:16630

cimg_library::CImgList::is_sameXYZV
bool is_sameXYZV(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const
Definition: CImg.h:34814

cimg_library::cimg::superset< unsigned int, long >::type
long type
Definition: CImg.h:2271

cimg_library::CImg::select
CImg< T > & select(CImgDisplay &disp, const int select_type=2, unsigned int *const XYZ=0, const unsigned char *const color=0)
Simple interface to select a shape from an image.
Definition: CImg.h:28588

cimg_library::cimg::type< unsigned short >::string
static const char * string()
Definition: CImg.h:2137

cimg_library::cimg::type< float >::max
static float max()
Definition: CImg.h:2194

cimg_library::cimg::superset< char, long >::type
long type
Definition: CImg.h:2247

cimg_library::cimg::superset< signed char, unsigned char >::type
short type
Definition: CImg.h:2230

cimg_library::CImgArgumentException::CImgArgumentException
CImgArgumentException(const char *format,...)
Definition: CImg.h:2046

cimg_library::CImg::print
const CImg< T > & print(const char *title=0, const bool display_stats=true) const
Display informations about the image on the standard error output.
Definition: CImg.h:31432

cimg_library::cimg::type< bool >::string
static const char * string()
Definition: CImg.h:2101

cimg_library::CImgList::swap
CImgList< T > & swap(CImgList< T > &list)
Swap all fields of two CImgList instances (use with care !)
Definition: CImg.h:34325

cimg_library::cimg::keyPAGEDOWN
const unsigned int keyPAGEDOWN
Definition: CImg.h:2712

cimg_debug
#define cimg_debug
Definition: CImg.h:160

cimg_library::CImg::get_load_pandore
static CImg< T > get_load_pandore(std::FILE *const file)
Definition: CImg.h:30714

cimg_library::CImg::draw_grid
CImg< T > & draw_grid(const CImg< tx > &xvalues, const CImg< ty > &yvalues, const CImg< tc > &color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw grid.
Definition: CImg.h:26718

cimg_library::CImgDisplay::is_keyF3
volatile bool is_keyF3
Definition: CImg.h:6177

cimg_for2x2
#define cimg_for2x2(img, x, y, z, v, I)
Definition: CImg.h:1053

i
blockLoc i
Definition: read.cpp:79

cimg_library::cimg::max
cimg::superset< t1, t2 >::type max(const t1 &a, const t2 &b)
Return the maximum value between two numbers.
Definition: CImg.h:4749

angle
double angle(Vector_3< double > v1, Vector_3< double > v2)
Compute the angle between two vectors.
Definition: geometry.C:61

cimg_library::CImgList::save_gzip_external
const CImgList< T > & save_gzip_external(const char *const filename) const
Save a file in TIFF format.
Definition: CImg.h:36943

cimg_library::cimg::keyF
const unsigned int keyF
Definition: CImg.h:2717

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1, const T val2) const
Definition: CImg.h:14469

cimg_library::CImg::save_bmp
const CImg< T > & save_bmp(const char *const filename) const
Save the image as a BMP file.
Definition: CImg.h:32544

cimg_library::cimg::superset< int, unsigned long >::type
long type
Definition: CImg.h:2275

cimg_library::CImgList::ushortT
cimg::last< T, unsigned short >::type ushortT
Definition: CImg.h:33915

cimg_library::CImg::save_graphicsmagick_external
const CImg< T > & save_graphicsmagick_external(const char *const filename, const unsigned int quality=100) const
Save the image using GraphicsMagick&#39;s gm.
Definition: CImg.h:33689

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1, const T val2, const T val3, const T val4) const
Definition: CImg.h:14506

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3)
Return a vector with specified coefficients.
Definition: CImg.h:14154

cimg_library::CImg::_atXYZ
T & _atXYZ(const int x, const int y, const int z, const int v=0)
Definition: CImg.h:11281

cimg_library::CImg::get_FFT
CImgList< Tfloat > get_FFT(const char axis, const bool invert=false) const
Compute a 1D Fast Fourier Transform, along a specified axis.
Definition: CImg.h:20818

cimg_library::CImgDisplay::keys
volatile unsigned int keys[512]
Definition: CImg.h:6155

cimg_library::CImgDisplay::is_key2
volatile bool is_key2
Definition: CImg.h:6189

cimg_library::log10
CImg< _cimg_Tfloat > log10(const CImg< T > &instance)
Definition: CImg.h:6026

cimg_library::CImg::get_load_magick
static CImg< T > get_load_magick(const char *const filename)
Definition: CImg.h:29646

cimg_library::CImgList::value_string
CImg< charT > value_string(const char separator=',', const unsigned int max_size=0) const
Return a C-string containing the values of all images in the instance list.
Definition: CImg.h:34712

cimg_library::cimg::crand
double crand()
Return a random variable between [-1,1] with respect to an uniform distribution.
Definition: CImg.h:4840

cimg_library::cimg::t_green
const char *const *const *const *const t_green
Definition: CImg.h:1925

cimg_library::CImg::_atXY
T & _atXY(const int x, const int y, const int z=0, const int v=0)
Definition: CImg.h:11315

_cimg_create_ext_operators
#define _cimg_create_ext_operators(typ)
Definition: CImg.h:5926

cimg_library::CImg::display
const CImg< T > & display(const char *const title=0, const bool display_info=true) const
Display an image in a window with a title title, and wait a &#39;is_closed&#39; or &#39;keyboard&#39; event...
Definition: CImg.h:31474

cimg_library::CImg::minmax
T & minmax(t &max_val)
Return a reference to the minimum pixel value and return also the maximum pixel value.
Definition: CImg.h:12920

cimg_library::cimg::type< char >::string
static const char * string()
Definition: CImg.h:2119

cimg_library::CImg::_marching3d_func_expr
Definition: CImg.h:21789

cimg_library::CImg::_marching2d_func::operator()
float operator()(const float x, const float y) const
Definition: CImg.h:21432

cimg_library::CImg::haar
CImg< T > & haar(const char axis, const bool invert=false, const unsigned int nb_scales=1)
Compute the Haar multiscale wavelet transform (monodimensional version).
Definition: CImg.h:20600

cimg_library::CImgDisplay::is_keyE
volatile bool is_keyE
Definition: CImg.h:6205

cimg_library::CImg::get_shared_plane
CImg< T > get_shared_plane(const unsigned int z0, const unsigned int v0=0)
Return a shared-memory image referencing one plane (z0,v0) of the instance image. ...
Definition: CImg.h:18545

x
void int int REAL * x
Definition: read.cpp:74

cimg_library::CImg::get_load_dcraw_external
static CImg< T > get_load_dcraw_external(const char *const filename)
Definition: CImg.h:31388

cimg_library::cimg::superset< char, double >::type
double type
Definition: CImg.h:2249

cimg_library::CImgDisplay::is_keyPAD9
volatile bool is_keyPAD9
Definition: CImg.h:6257

cimg_library::cimg::type< double >::max
static double max()
Definition: CImg.h:2203

cimg_library::CImg::get_load_analyze
static CImg< T > get_load_analyze(const char *const filename, float *const voxsize=0)
Definition: CImg.h:30412

cimg_library::CImg::save_dlm
const CImg< T > & save_dlm(std::FILE *const file) const
Save the image as a DLM file.
Definition: CImg.h:32453

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(CImgDisplay &disp, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const to &opacities, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31664

cimg_library::CImg::RGBtoHSV
CImg< T > & RGBtoHSV()
Convert color pixels from (R,G,B) to (H,S,V).
Definition: CImg.h:15787

cimg_library::cimg::type< short >::format
static int format(const short val)
Definition: CImg.h:2151

cimg_library::CImg::load_ascii
CImg< T > & load_ascii(std::FILE *const file)
Load an image from an ASCII file.
Definition: CImg.h:29275

cimg_library::CImg::assign
CImg< T > & assign(const t *const data_buffer, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
In-place version of the previous constructor.
Definition: CImg.h:10179

cimg_library::CImg::_draw_point
CImg< T > & _draw_point(const t &points, const unsigned int W, const unsigned int H, const tc *const color, const float opacity)
Definition: CImg.h:22232

cimg_library::cimg::type< unsigned short >::min
static unsigned short min()
Definition: CImg.h:2139

cimg_library::CImgDisplay::is_keyF1
volatile bool is_keyF1
Definition: CImg.h:6175

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float opacity=1, const float brightness=1)
Draw a 2D textured triangle, with perspective correction.
Definition: CImg.h:24307

cimg_library::CImg::_marching3d_func_float::operator()
float operator()(const float x, const float y, const float z) const
Definition: CImg.h:21784

TRUE
#define TRUE
Definition: vinci.h:134

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1)
Fill sequentially all pixel values with values val0 and val1 respectively.
Definition: CImg.h:14444

cimg_library::cimg::type< unsigned long >::max
static unsigned long max()
Definition: CImg.h:2176

cimg_library::CImg::SVD
const CImg< T > & SVD(CImg< t > &U, CImg< t > &S, CImg< t > &V, const bool sorting=true, const unsigned int max_iter=40, const float lambda=0) const
Compute the SVD of a general matrix.
Definition: CImg.h:13843

cimg_library::CImg::elevation3d
static CImg< floatT > elevation3d(CImgList< tf > &primitives, const char *const expression, const float x0, const float y0, const float x1, const float y1, const int sizex=256, const int sizey=256)
Definition: CImg.h:21319

cimg_library::CImg::get_acos
CImg< Tfloat > get_acos() const
Definition: CImg.h:12645

cimg_library::CImgDisplay::wait
static void wait(CImgDisplay &disp1, CImgDisplay &disp2, CImgDisplay &disp3, CImgDisplay &disp4)
Wait for any event occuring either on the display disp1, disp2, disp3 or disp4.
Definition: CImg.h:6900

cimg_library::CImg::get_load_ffmpeg_external
static CImg< T > get_load_ffmpeg_external(const char *const filename, const char axis='z', const char align='p')
Definition: CImg.h:31216

cimg_library::CImgDisplay::is_keyESC
volatile bool is_keyESC
Current state of the corresponding key (exists for all referenced keys).
Definition: CImg.h:6174

cimg_library::CImgDisplay::is_keyF
volatile bool is_keyF
Definition: CImg.h:6220

cimg_library::cimg::superset< unsigned char, signed char >::type
short type
Definition: CImg.h:2221

cimg_library::cimg::type< unsigned long >::min
static unsigned long min()
Definition: CImg.h:2175

cimg_library::cimg::t_red
const char *const t_red
Definition: CImg.h:1924

cimg_library::CImgDisplay::is_moved
volatile bool is_moved
Moved state of the window.
Definition: CImg.h:6168

cimg_library::CImg::fillY
CImg< T > & fillY(const unsigned int x, const unsigned int z, const unsigned int v, const double a0,...)
Definition: CImg.h:14919

cimg_library::CImg::assign
CImg< T > & assign(const CImg< t > &img)
In-place version of the default copy constructor.
Definition: CImg.h:10259

cimg_library::CImgDisplay::display
CImgDisplay & display(const CImgList< T > &list, const char axis='x', const char align='p')
Display an image list CImgList&lt;T&gt; into a display window.
Definition: CImg.h:6705

cimg_library::cimg::type< int >::max
static int max()
Definition: CImg.h:2167

cimg_library::CImg::get_FFT
CImgList< Tfloat > get_FFT(const bool invert=false) const
Compute a N-D Fast-Fourier Transform.
Definition: CImg.h:20825

_cimg_Tt
#define _cimg_Tt
Definition: CImg.h:2300

cimg_library::CImg::exp
CImg< T > & exp()
Compute the exponential of each pixel value.
Definition: CImg.h:12540

cimg_library::CImgDisplay::is_keyF4
volatile bool is_keyF4
Definition: CImg.h:6178

cimg_library::CImgList::insert
CImgList< T > & insert(const unsigned int n, const unsigned int pos=~0U)
Insert n empty images img into the current image list, at position pos.
Definition: CImg.h:35117

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float zc, const CImg< t > &tensor, const tc *const color, const float opacity=1)
Draw an anisotropic 3D gaussian function.
Definition: CImg.h:27451

cimg_library::CImg::save_inr
const CImg< T > & save_inr(const char *const filename, const float *const voxsize=0) const
Save the image as an INRIMAGE-4 file.
Definition: CImg.h:33362

cimg_library::CImg::_marching3d_func_expr::_marching3d_func_expr
_marching3d_func_expr(const char *const expr)
Definition: CImg.h:21791

cimg_library::CImg::CImg
CImg(const CImg< t > &img, const char *const dimensions)
Construct an image using dimensions of another image.
Definition: CImg.h:10053

cimg_library::CImg::back
T & back()
Definition: CImg.h:11183

cimg_library::cimg::keySHIFTLEFT
const unsigned int keySHIFTLEFT
Definition: CImg.h:2724

cimg_library::CImg::assign
CImg< T > & assign(const CImg< t > &img, const bool shared)
In-place version of the advanced constructor.
Definition: CImg.h:10277

cimg_library::CImg::save_cpp
const CImg< T > & save_cpp(const char *const filename) const
Save the image as a CPP source file.
Definition: CImg.h:32412

cimg_library::CImg::abs
CImg< T > & abs()
Compute the absolute value of each pixel value.
Definition: CImg.h:12570

cimg_library::CImgDisplay::max
float max
Definition: CImg.h:6267

cimg_library::CImg::get_load
static CImg< T > get_load(const char *const filename)
Definition: CImg.h:29261

cimg_library::CImg::get_autocrop
CImg< T > get_autocrop(const T *const color, const char *const axes="zyx") const
Definition: CImg.h:18342

cimg_library::CImg::cos
CImg< T > & cos()
Compute the cosinus of each pixel value.
Definition: CImg.h:12580

cimg_library::CImg::get_shared_plane
const CImg< T > get_shared_plane(const unsigned int z0, const unsigned int v0=0) const
Definition: CImg.h:18549

cimg_library::CImg::_load_rgba
CImg< T > & _load_rgba(std::FILE *const file, const char *const filename, const unsigned int dimw, const unsigned int dimh)
Definition: CImg.h:30012

cimg_library::cimg::type< unsigned short >::max
static unsigned short max()
Definition: CImg.h:2140

cimg_library::CImg::matrix
CImg< T > & matrix()
Realign pixel values of the instance image as a square matrix.
Definition: CImg.h:13343

cimg_library::cimg::keyARROWUP
const unsigned int keyARROWUP
Definition: CImg.h:2733

cimg_library::CImg::is_sameXZV
bool is_sameXZV(const CImg< t > &img) const
Return true if images have same width, same depth and same number of channels.
Definition: CImg.h:12022

cimg_library::CImg::get_select
CImg< intT > get_select(CImgDisplay &disp, const int select_type=2, unsigned int *const XYZ=0, const unsigned char *const color=0) const
Simple interface to select a shape from an image.
Definition: CImg.h:28602

_cimg_blur_patch3d
#define _cimg_blur_patch3d(N)

cimg_library::CImg::displacement_field
CImg< T > & displacement_field(const CImg< T > &target, const float smooth=0.1f, const float precision=0.1f, const unsigned int nb_scales=0, const unsigned int itermax=1000, const bool backward=true)
Estimate a displacement field between instance image and given target image.
Definition: CImg.h:20331

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6)
Fill sequentially pixel values.
Definition: CImg.h:14533

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle, const CImg< tc > &color, const float opacity=1)
Draw a filled ellipse.
Definition: CImg.h:26024

cimg_library::CImgList::save_cimg
const CImgList< T > & save_cimg(std::FILE *file, const bool compress=false) const
Save an image list into a CImg file (RAW binary file + simple header)
Definition: CImg.h:36752

cimg_library::cimg::type::min
static T min()
Definition: CImg.h:2094

cimg_library::CImg::get_haar
CImg< Tfloat > get_haar(const char axis, const bool invert=false, const unsigned int nb_scales=1) const
Definition: CImg.h:20604

n
const NT & n
Definition: rational_rotation.h:72

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const tc *const color, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded triangle, with z-buffering.
Definition: CImg.h:24701

cimg_library::CImg::get_load_dlm
static CImg< T > get_load_dlm(std::FILE *const file)
Definition: CImg.h:29327

cimg_foroff
#define cimg_foroff(img, off)
Definition: CImg.h:590

cimg_library::CImgDisplay::show_mouse
CImgDisplay & show_mouse()
Show mouse pointer.
Definition: CImg.h:6803

cimg_library::CImgDisplay::is_keyENTER
volatile bool is_keyENTER
Definition: CImg.h:6226

cimg_library::cimg::key3
const unsigned int key3
Definition: CImg.h:2687

cimg_library::CImgDisplay::is_keyO
volatile bool is_keyO
Definition: CImg.h:6211

cimg_library::CImg::_at
T _at(const int off) const
Definition: CImg.h:11216

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1, const T val2, const T val3) const
Definition: CImg.h:14487

cimg_library::CImg::get_matrix
CImg< T > get_matrix() const
Definition: CImg.h:13367

cimg_library::CImgList::atN
T atN(const int pos, const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:34684

cimg_library::CImgDisplay::is_keyZ
volatile bool is_keyZ
Definition: CImg.h:6228

cimg_library::CImgDisplay::is_keyV
volatile bool is_keyV
Definition: CImg.h:6231

cimg_library::CImgList::get_remove
CImgList< T > get_remove(const unsigned int pos1, const unsigned int pos2) const
Definition: CImg.h:35206

cimg_library::cimg::superset< signed char, unsigned long >::type
long type
Definition: CImg.h:2236

cimg_library::CImgDisplay::is_keyF12
volatile bool is_keyF12
Definition: CImg.h:6186

cimg_library::CImg::default_LUT256
static CImg< Tuchar > default_LUT256()
Return a default indexed color palette with 256 (R,G,B) entries.
Definition: CImg.h:15715

cimg_library::cimg::superset2::type
superset< t1, typename superset< t2, t3 >::type >::type type
Definition: CImg.h:2291

cimg_library::atan
CImg< _cimg_Tfloat > atan(const CImg< T > &instance)
Definition: CImg.h:6061

cimg_library::CImg::draw_point
CImg< T > & draw_point(const int x0, const int y0, const int z0, const CImg< tc > &color, const float opacity=1)
Draw a 3D colored point (voxel).
Definition: CImg.h:22225

cimg_library::CImgList::get_remove
CImgList< T > get_remove(const unsigned int pos) const
Definition: CImg.h:35215

cimg_library::CImgList::FFT
CImgList< T > & FFT(const bool invert=false)
Compute a N-D Fast Fourier Transform.
Definition: CImg.h:37130

cimg_library::CImg::_cimg_math_parser::compile
unsigned int compile(char *const ss, char *const se)
Definition: CImg.h:12266

cimg_library::CImgDisplay::CImgDisplay
CImgDisplay(const CImgDisplay &disp)
Create a display window by copying another one.
Definition: CImg.h:6379

cimg_library::CImg::is_object3d
bool is_object3d(const CImgList< tf > &primitives, const bool check_primitives=true, const bool throw_exception=false, const char *const calling_function=0) const
Return true if the couple (instance,primitives) stands for a valid 3D object.
Definition: CImg.h:12122

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2)
Fill sequentially all pixel values with values val0 and val1 and val2.
Definition: CImg.h:14457

cimg_library::CImg::get_threshold
CImg< T > get_threshold(const T value, const bool soft_threshold=false, const bool strict_threshold=false) const
Definition: CImg.h:15246

cimg_library::CImgList::load_ffmpeg_external
CImgList< T > & load_ffmpeg_external(const char *const filename)
Load an image from a video file (MPEG,AVI) using the external tool &#39;ffmpeg&#39;.
Definition: CImg.h:36127

cimg_library::CImg::get_cross
CImg< _cimg_Tt > get_cross(const CImg< t > &img) const
Definition: CImg.h:13469

cimg_library::CImgList::images
CImgList< T > & images(const unsigned int i0, const unsigned int i1)
Get a sub-list.
Definition: CImg.h:35242

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const tc *const color, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded colored triangle, with z-buffering.
Definition: CImg.h:24046

cimg_library::cimg::keyARROWRIGHT
const unsigned int keyARROWRIGHT
Definition: CImg.h:2744

cimg_library::CImg::_atX
T & _atX(const int x, const int y=0, const int z=0, const int v=0)
Definition: CImg.h:11347

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc *const color, const float opacity=1)
Draw a 2D filled colored triangle.
Definition: CImg.h:23796

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34234

cimg_library::CImg::load_rgb
CImg< T > & load_rgb(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1)
Load an image from a RGB file.
Definition: CImg.h:29958

cimg_library::CImgList::get_crop_font
CImgList< T > get_crop_font() const
Definition: CImg.h:37029

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc1 *const color1, const tc2 *const color2, const tc3 *const color3, const float opacity=1)
Draw a colored triangle with interpolated colors.
Definition: CImg.h:24148

cimg_library::CImg::operator|
CImg< T > operator|(const t val) const
Operator|().
Definition: CImg.h:10915

cimg_library::CImg::get_shared_channels
const CImg< T > get_shared_channels(const unsigned int v0, const unsigned int v1) const
Definition: CImg.h:18563

cimg_library::cimg::sign
T sign(const T x)
Return the sign of a number.
Definition: CImg.h:4770

cimg_library::CImgDisplay::is_keyD
volatile bool is_keyD
Definition: CImg.h:6219

cimg_for3XY
#define cimg_for3XY(img, x, y)
Definition: CImg.h:739

cimg_library::CImg::get_split
CImgList< T > get_split(const T value, const bool keep_values, const bool shared, const char axis='y') const
Definition: CImg.h:18622

cimg_library::CImg::save_rgba
const CImg< T > & save_rgba(const char *const filename) const
Save the image as a RGBA file.
Definition: CImg.h:33115

cimg_library::CImgDisplay::is_keySHIFTRIGHT
volatile bool is_keySHIFTRIGHT
Definition: CImg.h:6235

cimg_library::cimg::keyB
const unsigned int keyB
Definition: CImg.h:2729

cimg_library::CImg::get_RGBtoCMY
CImg< Tfloat > get_RGBtoCMY() const
Definition: CImg.h:16149

cimg_library::cimg::type< unsigned long >::format
static const char * format()
Definition: CImg.h:2177

cimg_library::CImg::save
const CImg< T > & save(const char *const filename, const int number=-1) const
Save the image as a file.
Definition: CImg.h:32256

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4)
Return a vector with specified coefficients.
Definition: CImg.h:14161

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImgList< tp > &points, const CImgList< tt > &tangents, const CImg< tc > &color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23416

cimg_library::CImgDisplay::window_dimx
int window_dimx() const
Return display window width.
Definition: CImg.h:6633

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const int x0, const int y0, const float u0, const float v0, const int x1, const int y1, const float u1, const float v1, const CImg< t > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const float opacity=1, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a cubic spline curve in the instance image.
Definition: CImg.h:23243

cimg_forXY
#define cimg_forXY(img, x, y)
Definition: CImg.h:597

cimg_library::CImg::LabtoXYZ
CImg< T > & LabtoXYZ()
Convert (L,a,b) pixels of a color image into the (X,Y,Z) color space.
Definition: CImg.h:16323

cimg_library::CImg::blur_anisotropic
CImg< T > & blur_anisotropic(const CImg< t > &G, const float amplitude=60, const float dl=0.8f, const float da=30, const float gauss_prec=2, const unsigned int interpolation_type=0, const unsigned int fast_approx=1)
Blur the image anisotropically following a field of diffusion tensors.
Definition: CImg.h:19246

cimg_library::CImg::save_png
const CImg< T > & save_png(const char *const filename, const unsigned int bytes_per_pixel=0) const
Save a file in PNG format.
Definition: CImg.h:32890

cimg_library::CImg::maxmin
T & maxmin(t &min_val)
Return a reference to the maximum pixel value and return also the minimum pixel value.
Definition: CImg.h:12951

cimg_library::CImg::CImg
CImg()
Default constructor.
Definition: CImg.h:9857

cimg_library::cimg::keyPAD7
const unsigned int keyPAD7
Definition: CImg.h:2752

cimg_library::CImgDisplay::is_keyY
volatile bool is_keyY
Definition: CImg.h:6208

cimg_library::cimg::superset< short, float >::type
float type
Definition: CImg.h:2264

cimg_library::CImgList::CImgList
CImgList(const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const int val0, const int val1,...)
Construct an image list containing n images with specified size and specified pixel values (int versi...
Definition: CImg.h:33996

cimg_library::CImg::is_sameXYZV
bool is_sameXYZV(const CImg< t > &img) const
Return true if images (*this) and img have same width, same height, same depth and same number of cha...
Definition: CImg.h:12044

cimg_library::CImg::save_empty_cimg
static void save_empty_cimg(std::FILE *const file, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
Save an empty .cimg file with specified dimensions.
Definition: CImg.h:33321

cimg_library::CImg::cross
CImg< T > & cross(const CImg< t > &img)
Compute the cross product between two 3d vectors.
Definition: CImg.h:13457

cimg_library::CImgList::pop_back
CImgList< T > & pop_back()
Remove last element of the list (STL-compliant name).
Definition: CImg.h:35427

_cimg_fopcode2
#define _cimg_fopcode2(op, i1, i2)
Definition: CImg.h:12227

cimg_library::CImgDisplay::is_keyW
volatile bool is_keyW
Definition: CImg.h:6204

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n, const CImg< t > &img, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34210

cimg_library::CImg::operator&
CImg< T > operator&(const t val) const
Operator&amp;().
Definition: CImg.h:10870

cimg_library::cimg::rol
const T rol(const T a, const unsigned int n=1)
Return a left bitwise-rotated number.
Definition: CImg.h:4671

cimg_library::cimg::superset< unsigned int, char >::type
long type
Definition: CImg.h:2266

cimg_library::cimg::font16x32
const unsigned int font16x32[16 *32 *256/32]
Definition: CImg.h:3169

cimg_library::CImgList::split
CImgList< T > & split(const char axis, const int nb=0)
Return a list where each image has been split along the specified axis.
Definition: CImg.h:35392

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float zc, const float sigma, const CImg< tc > &color, const float opacity=1)
Draw an isotropic 3D gaussian function.
Definition: CImg.h:27499

cimg_library::cimg::type< float >::min
static float min()
Definition: CImg.h:2193

cimglist_for
#define cimglist_for(list, l)
Definition: CImg.h:1877

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const int, const tc *const background_color, const float opacity, const CImgList< t > &font,...)
Draw a text.
Definition: CImg.h:26368

cimg_library::CImg::get_displacement_field
CImg< Tfloat > get_displacement_field(const CImg< T > &target, const float smoothness=0.1f, const float precision=0.1f, const unsigned int nb_scales=0, const unsigned int itermax=1000, const bool backward=true) const
Definition: CImg.h:20337

cimg_library::CImg::draw_plasma
CImg< T > & draw_plasma(const int x0, const int y0, const int x1, const int y1, const float alpha=1, const float beta=1, const float opacity=1)
Draw a plasma random texture.
Definition: CImg.h:27177

cimg_library::CImg::get_split
CImgList< T > get_split(const char axis, const int nb=0) const
Split image into a list.
Definition: CImg.h:18582

cimg_library::CImg::operator/=
CImg< T > & operator/=(const char *const expression)
Operator/=().
Definition: CImg.h:10733

cimg_library::CImg::YCbCrtoRGB
CImg< T > & YCbCrtoRGB()
Convert color pixels from (R,G,B) to (Y,Cb,Cr)_8.
Definition: CImg.h:16051

cimg_library::CImg::load_pnm
CImg< T > & load_pnm(const char *const filename)
Load an image from a PNM file.
Definition: CImg.h:29812

cimg_library::CImg::load_ffmpeg
CImg< T > & load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false, const char axis='z', const char align='p')
Load a video sequence using FFMPEG av&#39;s libraries.
Definition: CImg.h:30985

cimg_library::cimg::superset< short, unsigned int >::type
long type
Definition: CImg.h:2260

cimg_library::CImg::resize
CImg< T > & resize(const CImgDisplay &disp, const int interpolation_type=1, const int border_condition=-1, const bool center=false)
Resize an image.
Definition: CImg.h:17000

cimg_library::cimg::superset< bool, float >::type
float type
Definition: CImg.h:2218

cimg_library::cimg::superset< int, double >::type
double type
Definition: CImg.h:2278

cimg_library::CImg::_display
const CImg< T > & _display(CImgDisplay &disp, const char *const title, const bool display_info) const
Definition: CImg.h:31479

cimg_library::CImg::get_pseudoinvert
CImg< Tfloat > get_pseudoinvert() const
Definition: CImg.h:13547

cimg_library::CImgList::empty
static CImgList< T > & empty()
Return a reference to an empty list.
Definition: CImg.h:34333

cimg_library::CImg::get_resize_doubleXY
CImg< T > get_resize_doubleXY() const
Definition: CImg.h:17039

cimg_library::CImg::_cimg_math_parser
Definition: CImg.h:12218

cimg_library::cimg::superset< unsigned long, signed char >::type
long type
Definition: CImg.h:2280

cimg_library::CImgDisplay::is_keyPAD5
volatile bool is_keyPAD5
Definition: CImg.h:6253

cimg_library::cimg::key0
const unsigned int key0
Definition: CImg.h:2694

cimg_library::CImg::atX
T atX(const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:11328

cimg_library::CImgDisplay::is_keyPAD7
volatile bool is_keyPAD7
Definition: CImg.h:6255

cimg_library::CImgList::_font
static CImgList< T > _font(const unsigned int *const font, const unsigned int w, const unsigned int h, const unsigned int paddingx, const unsigned int paddingy, const bool variable_size=true)
Definition: CImg.h:37097

cimg_library::CImg::operator-=
CImg< T > & operator-=(const CImg< t > &img)
Operator-=().
Definition: CImg.h:10621

cimg_library::cimg::superset< int, unsigned int >::type
long type
Definition: CImg.h:2274

cimg_library::CImg::is_sameZ
bool is_sameZ(const CImg< t > &img) const
Return true if images (*this) and img have same depth.
Definition: CImg.h:11907

cimg_library::CImg::atX
T & atX(const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the first coordinates (x).
Definition: CImg.h:11324

cimg_library::cimg::keyPAD4
const unsigned int keyPAD4
Definition: CImg.h:2749

cimg_library::cimg::keyPADSUB
const unsigned int keyPADSUB
Definition: CImg.h:2756

mask
std::vector< std::vector< bool > > mask
Masks the points that are shared (true) share (false) not shared.
Definition: hdf2pltV2.C:62

cimg_library::cimg::system
int system(const char *const command, const char *const module_name=0)
Definition: CImg.h:4491

cimg_library::CImg::get_convolve
CImg< _cimg_Ttfloat > get_convolve(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_convol=false) const
Definition: CImg.h:18904

cimg_library::CImg::rainbow_LUT256
static CImg< Tuchar > rainbow_LUT256()
Return a rainbow indexed color palette with 256 (R,G,B) entries.
Definition: CImg.h:15738

cimg_library::CImgList::load
CImgList< T > & load(const char *const filename)
Load an image list from a file.
Definition: CImg.h:35449

cimg_library::CImg::load_medcon_external
CImg< T > & load_medcon_external(const char *const filename)
Load a DICOM image file, using XMedcon&#39;s external tool &#39;medcon&#39;.
Definition: CImg.h:31325

cimg_library::CImg::get_resize_halfXY
CImg< T > get_resize_halfXY() const
Definition: CImg.h:17015

cimg_library::CImg::get_abs
CImg< Tfloat > get_abs() const
Definition: CImg.h:12575

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const tc *const foreground_color, const int background_color=0, const float opacity=1, const unsigned int font_size=11,...)
Draw a text.
Definition: CImg.h:26412

cimg_library::CImg::save_jpeg
const CImg< T > & save_jpeg(std::FILE *const file, const unsigned int quality=100) const
Save a file in JPEG format.
Definition: CImg.h:32649

cimg_library::CImgList::load_cimg
CImgList< T > & load_cimg(const char *const filename)
Load an image list from a .cimg file.
Definition: CImg.h:35533

cimg_library::CImg::blur_bilateral
CImg< T > & blur_bilateral(const float sigma_x, const float sigma_y, const float sigma_z, const float sigma_r, const int bgrid_x, const int bgrid_y, const int bgrid_z, const int bgrid_r, const bool interpolation_type=true)
Blur an image using the bilateral filter.
Definition: CImg.h:19537

cimg_library::cimg::superset< char, float >::type
float type
Definition: CImg.h:2248

cimg_library::CImg::get_invert_endianness
CImg< T > get_invert_endianness() const
Definition: CImg.h:14956

cimg_library::CImgList::contains
bool contains(const T &pixel, t &n, t &x) const
Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x).
Definition: CImg.h:34860

cimg_library::CImg::_solve
CImg< T > & _solve(const CImg< t > &A, const CImg< ti > &indx)
Definition: CImg.h:13605

cimg_library::cimg::type< unsigned long >::format
static unsigned long format(const unsigned long val)
Definition: CImg.h:2178

cimg_library::CImgDisplay::CImgDisplay
CImgDisplay(const unsigned int dimw, const unsigned int dimh, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
Create a display window with a specified size pwidth x height.
Definition: CImg.h:6332

cimg_library::CImg::get_vector_at
CImg< T > get_vector_at(const unsigned int x, const unsigned int y=0, const unsigned int z=0) const
Return a new image corresponding to the vector located at (x,y,z) of the current vector-valued image...
Definition: CImg.h:13270

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8)
Return a vector with specified coefficients.
Definition: CImg.h:14193

cimg_for
#define cimg_for(img, ptr, T_ptr)
Definition: CImg.h:589

cimg_library::CImg::CMYKtoCMY
CImg< T > & CMYKtoCMY()
Convert (C,M,Y,K) pixels of a color image into the (C,M,Y) color space.
Definition: CImg.h:16211

cimg_library::CImgList::get_append
CImg< T > get_append(const char axis, const char align='p') const
Return a single image which is the concatenation of all images of the current CImgList instance...
Definition: CImg.h:35280

cimg_library::CImg::draw_plasma
CImg< T > & draw_plasma(const float alpha=1, const float beta=1, const float opacity=1)
Draw a plasma random texture.
Definition: CImg.h:27243

cimg_library::CImg::front
const T & front() const
Return reference to the first image pixel (STL-compliant name).
Definition: CImg.h:11170

cimg_library::CImg::draw_image
CImg< T > & draw_image(const CImg< ti > &sprite, const CImg< tm > &mask, const float opacity=1, const float mask_valmax=1)
Draw an image.
Definition: CImg.h:26321

cimg_library::cimg::_pythagore
double _pythagore(double a, double b)
Definition: CImg.h:4881

cimg_library::CImg::BayertoRGB
CImg< T > & BayertoRGB(const unsigned int interpolation_type=3)
Convert a Bayer-coded image to a (R,G,B) color image.
Definition: CImg.h:16494

cimg_library::cimg::superset< unsigned short, double >::type
double type
Definition: CImg.h:2258

cimg_library::CImgException::message
char message[16384]
Message associated with the error that thrown the exception.
Definition: CImg.h:2032

cimg_library::CImgList::load_cimg
CImgList< T > & load_cimg(std::FILE *const file)
Load an image list from a .cimg file.
Definition: CImg.h:35542

cimg_library::CImg::draw_circle
CImg< T > & draw_circle(const int x0, const int y0, int radius, const tc *const color, const float opacity=1)
Draw a filled circle.
Definition: CImg.h:25869

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const float r1, const float r2, const float angle, const tc *const color, const float opacity=1)
Draw a filled ellipse.
Definition: CImg.h:26017

cimg_library::cimg::superset< char, short >::type
short type
Definition: CImg.h:2243

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const CImgList< tp > &points, const CImgList< tt > &tangents, const tc *const color, const float opacity=1, const bool close_set=false, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored splines in the instance image.
Definition: CImg.h:23406

cimg_library::CImgDisplay::mouse_y
volatile int mouse_y
Y-coordinate of the mouse pointer on the display.
Definition: CImg.h:6138

cimg_library::CImg::cone3d
static CImg< floatT > cone3d(CImgList< tf > &primitives, const float radius=50, const float size_z=100, const unsigned int subdivisions=24)
Create and return a 3D cone.
Definition: CImg.h:21845

_CImg_stdarg
#define _CImg_stdarg(img, a0, a1, N, t)

cimg_library::CImgList::operator()
T & operator()(const unsigned int pos, const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0)
Return a reference to (x,y,z,v) pixel of the pos-th image of the list.
Definition: CImg.h:34378

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const CImg< tc > &color, const float opacity=1)
Draw a 3D filled colored rectangle in the instance image, at coordinates (x0,y0,z0)-(x1,y1,z1).
Definition: CImg.h:25606

cimg_library::CImg::operator/=
CImg< T > & operator/=(const t val)
Operator/=().
Definition: CImg.h:10727

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const tc *const color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 3D colored line.
Definition: CImg.h:22524

cimg_library::cimg::font7x11
const unsigned int font7x11[7 *11 *256/32]
Definition: CImg.h:2764

cimg_library::CImgList::push_front
CImgList< T > & push_front(const CImg< t > &img)
Insert image img at the front of the list (STL-compliant name).
Definition: CImg.h:35410

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const int x, const CImg< t > &yvalues, const tc *const color, const float opacity=1, const unsigned int pattern=~0U)
Draw a labeled vertical axis on the instance image.
Definition: CImg.h:26597

cimg_library::CImg::get_sharpen
CImg< T > get_sharpen(const float amplitude, const bool sharpen_type=false, const float edge=1, const float alpha=0, const float sigma=0) const
Definition: CImg.h:20000

cimg_library::CImg::_draw_scanline
CImg< T > & _draw_scanline(const int x0, const int x1, const int y, const tc *const color, const float opacity=1, const float brightness=1, const bool init=false)
Definition: CImg.h:22095

cimg_library::cimg::type< float >::format
static double format(const float val)
Definition: CImg.h:2196

cimg_library::CImg::load_parrec
CImg< T > & load_parrec(const char *const filename, const char axis='v', const char align='p')
Load an image from a PAR-REC (Philips) file.
Definition: CImg.h:30916

cimg_library::CImg::RGBtoCMY
CImg< T > & RGBtoCMY()
Convert color pixels from (R,G,B) to (C,M,Y).
Definition: CImg.h:16130

cimg_library::CImgList::_save_cimg
const CImgList< T > & _save_cimg(std::FILE *const file, const char *const filename, const bool compression) const
Save an image list into a .cimg file.
Definition: CImg.h:36700

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 3D colored line.
Definition: CImg.h:22571

cimg_library::CImg::Tfloat
cimg::superset< T, float >::type Tfloat
Definition: CImg.h:9781

cimg_library::CImg::_linear_atXY
Tfloat _linear_atXY(const float fx, const float fy, const int z=0, const int v=0) const
Definition: CImg.h:11537

cimg_library::CImg::identity_matrix
static CImg< T > identity_matrix(const unsigned int N)
Return a NxN identity matrix.
Definition: CImg.h:14382

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(CImgDisplay &disp, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31699

cimg_library::CImgDisplay::is_keyR
volatile bool is_keyR
Definition: CImg.h:6206

cimg_library::CImg::_cubic_atXY
Tfloat _cubic_atXY(const float fx, const float fy, const int z=0, const int v=0) const
Definition: CImg.h:11644

cimg_library::CImg::get_map
CImg< t > get_map(const CImg< t > &palette) const
Definition: CImg.h:15576

cimg_library::CImg::get_blur
CImg< Tfloat > get_blur(const float sigmax, const float sigmay, const float sigmaz, const bool cond=true) const
Definition: CImg.h:19220

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const int z, const tc *const color, const float opacity=1, const float sigma=0, const bool high_connexity=false)
Draw a 3D filled region starting from a point (x,y,\ z) in the instance image.
Definition: CImg.h:27128

cimg_library::CImg::save_jpeg
const CImg< T > & save_jpeg(const char *const filename, const unsigned int quality=100) const
Save a file in JPEG format.
Definition: CImg.h:32644

cimg_library::cimg::abs
T abs(const T a)
Return the absolute value of a number.
Definition: CImg.h:4687

cimg_library::CImg::autocrop
CImg< T > & autocrop(const CImg< t > &color, const char *const axes="zyx")
Autocrop an image, regarding of the specified backround color.
Definition: CImg.h:18347

cimg_library::CImg::sort
CImg< T > & sort(const bool increasing=true)
Sort image values.
Definition: CImg.h:13784

cimg_library::CImg::CImg
CImg(const CImg< T > &img, const bool shared)
Definition: CImg.h:10042

cimg_library::CImg::CImg
CImg(const CImg< t > &img)
Default copy constructor.
Definition: CImg.h:9998

cimg_library::cimg::type< char >::is_float
static bool is_float()
Definition: CImg.h:2120

cimg_strescape
#define cimg_strescape(ci, co)

cimg_library::CImgDisplay::is_keyC
volatile bool is_keyC
Definition: CImg.h:6230

cimg_library::CImg::get_YCbCrtoRGB
CImg< Tuchar > get_YCbCrtoRGB() const
Definition: CImg.h:16073

cimg_library::CImgDisplay::close
CImgDisplay & close()
Close a visible display.
Definition: CImg.h:6791

cimg_library::CImgDisplay::is_keyPAGEUP
volatile bool is_keyPAGEUP
Definition: CImg.h:6201

cimg_library::CImg::get_CMYtoRGB
CImg< Tuchar > get_CMYtoRGB() const
Definition: CImg.h:16176

cimg_library::CImg::trace
Tfloat trace() const
Return the trace of the image, viewed as a matrix.
Definition: CImg.h:13217

cimg_library::CImgDisplay::is_keyPAD8
volatile bool is_keyPAD8
Definition: CImg.h:6256

cimg_library::CImg::get_XYZtoRGB
CImg< Tuchar > get_XYZtoRGB() const
Definition: CImg.h:16285

cimg_library::CImgList::get_load_yuv
static CImgList< T > get_load_yuv(std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
Definition: CImg.h:35897

cimg_library::CImgDisplay::is_key1
volatile bool is_key1
Definition: CImg.h:6188

cimg_library::CImg::contrast_LUT256
static CImg< Tuchar > contrast_LUT256()
Return a contrasted indexed color palette with 256 (R,G,B) entries.
Definition: CImg.h:15756

cimg_library::CImg::dijkstra
static CImg< T > dijkstra(const tf &distance, const unsigned int nb_nodes, const unsigned int starting_node, const unsigned int ending_node=~0U)
Return minimal path in a graph, using the Dijkstra algorithm.
Definition: CImg.h:14097

cimg_library::CImg::get_load_other
static CImg< T > get_load_other(const char *const filename)
Definition: CImg.h:31416

cimg_library::CImg::load_pnm
CImg< T > & load_pnm(std::FILE *const file)
Load an image from a PNM file.
Definition: CImg.h:29821

cimg_library::CImg::FFT
static void FFT(CImg< T > &real, CImg< T > &imag, const bool invert=false)
Compute a N-D Fast Fourier Transform.
Definition: CImg.h:21024

cimg_forV
#define cimg_forV(img, v)
Definition: CImg.h:596

cimg_library::CImg::is_sameZ
bool is_sameZ(const unsigned int dz) const
Return true if image (*this) has the specified depth.
Definition: CImg.h:11901

cimg_library::CImgDisplay::fps_fps
float fps_fps
Definition: CImg.h:6267

cimg_library::cimg::type< double >::string
static const char * string()
Definition: CImg.h:2200

cimg_library::cimg::keyPAD0
const unsigned int keyPAD0
Definition: CImg.h:2745

cimg_library::CImgList::_atNXY
T _atNXY(const int pos, const int x, const int y, const int z=0, const int v=0) const
Definition: CImg.h:34643

cimg_library::CImgDisplay::window_posx
int window_posx() const
Return X-coordinate of the window.
Definition: CImg.h:6643

cimg_library::CImg::draw_grid
CImg< T > & draw_grid(const float deltax, const float deltay, const float offsetx, const float offsety, const bool invertx, const bool inverty, const tc *const color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw grid.
Definition: CImg.h:26726

cimg_library::CImg::_draw_spline
CImg< T > & _draw_spline(const tp &points, const unsigned int W, const unsigned int H, const tc *const color, const float opacity, const bool close_set, const float precision, const unsigned int pattern, const bool init_hatch)
Definition: CImg.h:23329

cimg_library::CImg::_load_inr_header
static void _load_inr_header(std::FILE *file, int out[8], float *const voxsize)
Definition: CImg.h:30613

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const bool shared=false)
Construct an image list from four images.
Definition: CImg.h:34052

cimg_library::CImg::warp
CImg< T > & warp(const CImg< t > &warp, const bool relative=false, const bool interpolation=true, const unsigned int border_conditions=0)
Warp an image.
Definition: CImg.h:17863

cimg_library::CImgList::get_load_cimg
static CImgList< T > get_load_cimg(const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
Definition: CImg.h:35650

cimg_library::cimg::keyZ
const unsigned int keyZ
Definition: CImg.h:2725

cimg_library::CImg::RGBtoHSI
CImg< T > & RGBtoHSI()
Convert color pixels from (R,G,B) to (H,S,I).
Definition: CImg.h:15948

cimg_library::CImgList::longT
cimg::last< T, long >::type longT
Definition: CImg.h:33920

cimg_library::CImgDisplay::screen_dimx
static int screen_dimx()
Return the width of the screen resolution.
Definition: CImg.h:6655

cimg_library::CImg::get_crop
CImg< T > get_crop(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const bool border_condition=false) const
Definition: CImg.h:18224

cimg_library::CImgList::clear
CImgList< T > & clear()
In-place version of the default constructor.
Definition: CImg.h:34146

min
Vector_n min(const Array_n_const &v1, const Array_n_const &v2)
Definition: Vector_n.h:346

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(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 T val, const float opacity=1)
Draw a 4D filled rectangle in the instance image, at coordinates (x0,y0,z0,v0)-(x1,y1,z1,v1).
Definition: CImg.h:25546

cimg_library::cimg::type< short >::min
static short min()
Definition: CImg.h:2148

cimg_library::CImg::save_ascii
const CImg< T > & save_ascii(const char *const filename) const
Save the image as an ASCII file (ASCII Raw + simple header).
Definition: CImg.h:32376

cimg_library::CImg::append_object3d
CImg< T > & append_object3d(CImgList< tf > &primitives, const CImg< tp > &obj_vertices, const CImgList< tff > &obj_primitives)
Append a 3D object to another one.
Definition: CImg.h:21143

cimg_library::CImgList::get_shared
const CImgList< T > get_shared() const
Return a shared instance of the list.
Definition: CImg.h:34135

cimg_library::CImg::get_log
CImg< Tfloat > get_log() const
Definition: CImg.h:12555

cimg_library::CImg::draw_image
CImg< T > & draw_image(const CImg< t > &sprite, const float opacity=1)
Draw an image.
Definition: CImg.h:26223

cimg_library::cimg::superset< short, double >::type
double type
Definition: CImg.h:2265

cimg_library::CImg::save_rgba
const CImg< T > & save_rgba(std::FILE *const file) const
Save the image as a RGBA file.
Definition: CImg.h:33120

cimg_library::CImg::get_BayertoRGB
CImg< Tuchar > get_BayertoRGB(const unsigned int interpolation_type=3) const
Definition: CImg.h:16498

cimg_library::CImgList::get_images
CImgList< T > get_images(const unsigned int i0, const unsigned int i1) const
Definition: CImg.h:35246

cimg_library::CImg::diagonal
static CImg< T > diagonal(const T &a0)
Return a 1x1 diagonal matrix with specified coefficients.
Definition: CImg.h:14357

cimg_library::cimg::uncase
char uncase(const char x)
Remove the &#39;case&#39; of an ASCII character.
Definition: CImg.h:4888

cimg_library::CImg::lines
CImg< T > & lines(const unsigned int y0, const unsigned int y1)
Get a set of lines.
Definition: CImg.h:18430

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float zc, const CImg< t > &tensor, const CImg< tc > &color, const float opacity=1)
Draw an anisotropic 3D gaussian function.
Definition: CImg.h:27477

cimg_library::cimg::file_type
const char * file_type(std::FILE *const file, const char *const filename)
Try to guess the image format of a filename, using its magick numbers.
Definition: CImg.h:5516

cimg_library::CImg::atXYZV
T & atXYZV(const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions.
Definition: CImg.h:11222

cimg_library::CImg::draw_point
CImg< T > & draw_point(const CImg< t > &points, const tc *const color, const float opacity=1)
Draw a cloud of colored points.
Definition: CImg.h:22296

cimg_library::CImg::get_fill
CImg< T > get_fill(const CImg< t > &values, const bool repeat_values=true) const
Definition: CImg.h:14894

cimg_library::CImg::get_shared_points
CImg< T > get_shared_points(const unsigned int x0, const unsigned int x1, const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0)
Get a shared-memory image referencing a set of points of the instance image.
Definition: CImg.h:18475

cimg_library::CImg::load_rgb
CImg< T > & load_rgb(const char *const filename, const unsigned int dimw, const unsigned int dimh=1)
Load an image from a RGB file.
Definition: CImg.h:29949

cimg_library::CImgList::load_off
CImgList< T > & load_off(const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
Load a 3D object from a .OFF file.
Definition: CImg.h:36206

_cimg_blur_patch2d_fast
#define _cimg_blur_patch2d_fast(N)

cimg_library::CImg::save_pandore
const CImg< T > & save_pandore(const char *const filename, const unsigned int colorspace=0) const
Save the image as a PANDORE-5 file.
Definition: CImg.h:33533

cimg_library::CImgDisplay::empty
static CImgDisplay & empty()
Return a reference to an empty display.
Definition: CImg.h:6431

cimg_library::CImgDisplay::CImgDisplay
CImgDisplay(const CImgList< T > &list, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
Create a display window from an image list.
Definition: CImg.h:6366

cimg_library::CImgDisplay::is_key7
volatile bool is_key7
Definition: CImg.h:6194

cimg_library::cimg::type< unsigned long >::is_float
static bool is_float()
Definition: CImg.h:2174

cimg_library::CImgList::CImgList
CImgList(const CImg< t1 > &img1, const CImg< t2 > &img2, const bool shared=false)
Construct an image list from two images.
Definition: CImg.h:34037

cimg_library::CImg::resize_doubleXY
CImg< T > & resize_doubleXY()
Upscale an image by a factor 2x.
Definition: CImg.h:17035

cimg_library::CImg::operator()
const T & operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const
Definition: CImg.h:10455

cimg_library::CImg::get_crop
CImg< T > get_crop(const int x0, const int x1, const bool border_condition=false) const
Definition: CImg.h:18262

cimg_library::CImg::sqr
CImg< T > & sqr()
Compute the square value of each pixel.
Definition: CImg.h:12520

cimg_library::CImg::is_sameXY
bool is_sameXY(const unsigned int dx, const unsigned int dy) const
Return true if image (*this) has the specified width and height.
Definition: CImg.h:11923

cimg_library::CImgList::iterator
CImg< T > * iterator
Define a CImgList&lt;T&gt;::iterator.
Definition: CImg.h:33892

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const CImg< tx > &xvalues, const CImg< ty > &yvalues, const tc *const color, const float opacity=1, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw a labeled horizontal+vertical axis on the instance image.
Definition: CImg.h:26633

cimg_library::CImg::_save_rgba
const CImg< T > & _save_rgba(std::FILE *const file, const char *const filename) const
Definition: CImg.h:33058

cimg_library::CImgDisplay::is_keyI
volatile bool is_keyI
Definition: CImg.h:6210

cimg_for4x4
#define cimg_for4x4(img, x, y, z, v, I)
Definition: CImg.h:1120

cimg_library::CImgList::insert
CImgList< T > & insert(const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false)
Insert a copy of the image list list into the current image list, starting from position pos...
Definition: CImg.h:35146

cimg_library::CImgDisplay::render
CImgDisplay & render(const CImg< T > &img)
Render image buffer into GDI native image format.
Definition: CImg.h:6828

cimg_library::CImg::assign
CImg< T > & assign(const char *const filename)
In-place version of the previous constructor.
Definition: CImg.h:10244

cimg_library::CImg::linear_atXYZ
Tfloat linear_atXYZ(const float fx, const float fy, const float fz, const int v, const T out_val) const
Read a pixel value using linear interpolation and Dirichlet boundary conditions (first three coordina...
Definition: CImg.h:11451

cimg_library::CImg::get_resize
CImg< T > get_resize(const int pdx, const int pdy=-100, const int pdz=-100, const int pdv=-100, const int interpolation_type=1, const int border_condition=-1, const bool center=false) const
Definition: CImg.h:16650

cimg_library::CImgList::load_tiff
CImgList< T > & load_tiff(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)
Load a TIFF file.
Definition: CImg.h:36218

cimg_library::cimg::keyR
const unsigned int keyR
Definition: CImg.h:2703

cimg_library::CImg::Tshort
cimg::superset< T, short >::type Tshort
Definition: CImg.h:9776

cimg_library::sin
CImg< _cimg_Tfloat > sin(const CImg< T > &instance)
Definition: CImg.h:6041

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14736

cimg_library::cimg::type< unsigned int >::is_float
static bool is_float()
Definition: CImg.h:2156

cimg_library::CImg::threshold
CImg< T > & threshold(const T value, const bool soft_threshold=false, const bool strict_threshold=false)
Threshold values of the instance image.
Definition: CImg.h:15234

cimg_library::CImg::CImg
CImg(const T *const data_buffer, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1, const bool shared=false)
Definition: CImg.h:9954

cimg_library::CImgList::get_insert
CImgList< T > get_insert(const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false) const
Definition: CImg.h:35112

cimg_library::CImg::get_load_yuv
static CImg< T > get_load_yuv(const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true, const char axis='z', const char align='p')
Definition: CImg.h:31005

cimg_library::CImg::get_HSVtoRGB
CImg< Tuchar > get_HSVtoRGB() const
Definition: CImg.h:15865

cimg_library::cimg::superset< float, double >::type
double type
Definition: CImg.h:2288

cimg_library::CImg::get_load_analyze
static CImg< T > get_load_analyze(std::FILE *const file, float *const voxsize=0)
Definition: CImg.h:30421

cimg_stdout
#define cimg_stdout
Definition: CImg.h:136

cimg_library::CImg::get_isosurface3d
CImg< floatT > get_isosurface3d(CImgList< tf > &primitives, const float isovalue, const int size_x=-100, const int size_y=-100, const int size_z=-100) const
Create and return a isosurface of the instance image as a 3D object.
Definition: CImg.h:21264

cimg_library::cimg::superset< signed char, short >::type
short type
Definition: CImg.h:2233

cimg_library::CImgList::reverse_object3d
CImgList< T > & reverse_object3d()
Invert primitives orientation of a 3D object.
Definition: CImg.h:37144

cimg_library::CImg::map
CImg< T > & map(const CImg< t > &palette)
Map predefined palette on the scalar (indexed) instance image.
Definition: CImg.h:15571

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14641

cimg_library::cimg::type< bool >::max
static bool max()
Definition: CImg.h:2104

cimg_library::cimg::superset< unsigned char, unsigned short >::type
unsigned short type
Definition: CImg.h:2222

cimg_library::CImg::get_HSLtoRGB
CImg< Tuchar > get_HSLtoRGB() const
Definition: CImg.h:15942

cimg_library::cimg::split_filename
const char * split_filename(const char *const filename, char *const body=0)
Split a filename into two strings &#39;body&#39; and &#39;extension&#39;.
Definition: CImg.h:5470

_cimglist_def_is_same3
#define _cimglist_def_is_same3(axis1, axis2, axis3)
Definition: CImg.h:34767

cimg_library::CImg::_marching3d_func::ref
const CImg< T > & ref
Definition: CImg.h:21774

cimg_library::CImg::_load_raw
CImg< T > & _load_raw(std::FILE *const file, const char *const filename, const unsigned int sizex, const unsigned int sizey, const unsigned int sizez, const unsigned int sizev, const bool multiplexed, const bool invert_endianness)
Definition: CImg.h:30957

cimg_library::CImg::save_bmp
const CImg< T > & save_bmp(std::FILE *const file) const
Save the image as a BMP file.
Definition: CImg.h:32549

cimg_library::CImgList::min
const T & min() const
Definition: CImg.h:34914

cimg_library::CImg::_save_dlm
const CImg< T > & _save_dlm(std::FILE *const file, const char *const filename) const
Definition: CImg.h:32422

cimg_library::CImg::sort
CImg< T > & sort(CImg< t > &permutations, const bool increasing=true)
Sort values of a vector and get permutations.
Definition: CImg.h:13768

cimg_library::CImg::linear_atXYZV
Tfloat linear_atXYZV(const float fx, const float fy, const float fz, const float fv, const T out_val) const
Read a pixel value using linear interpolation and Dirichlet boundary conditions.
Definition: CImg.h:11356

cimg_library::CImg::_atXYZV
T & _atXYZV(const int x, const int y, const int z, const int v)
Definition: CImg.h:11246

cimg_library::CImg::contains
bool contains(const T &pixel, t &x, t &y, t &z, t &v) const
Return true if specified referenced value is inside image boundaries. If true, returns pixel coordina...
Definition: CImg.h:12055

cimg_library::cimg::type< double >::format
static const char * format()
Definition: CImg.h:2204

cimg_library::CImgDisplay::is_keyPADADD
volatile bool is_keyPADADD
Definition: CImg.h:6258

cimg_library::CImgList::Tchar
cimg::superset< T, char >::type Tchar
Definition: CImg.h:33903

cimg_library::CImg::blur
CImg< T > & blur(const float sigmax, const float sigmay, const float sigmaz, const bool cond=true)
Return a blurred version of the image, using a Canny-Deriche filter.
Definition: CImg.h:19211

j
j indices j
Definition: Indexing.h:6

cimg_library::CImgList::value_type
T value_type
Value type.
Definition: CImg.h:33898

cimg_library::CImg::operator,
CImgList< _cimg_Tt > operator,(const CImg< t > &img) const
Operator,().
Definition: CImg.h:11013

cimg_library::CImg::value_string
CImg< charT > value_string(const char separator=',', const unsigned int max_size=0) const
Return a C-string containing the values of the instance image.
Definition: CImg.h:11838

cimg_library::CImg::set_tensor_at
CImg< T > & set_tensor_at(const CImg< t > &ten, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0)
Set the image vec as the tensor valued pixel located at (x,y,z) of the current vector-valued image...
Definition: CImg.h:13316

cimg_library::cimg::strpare
bool strpare(char *const s, const char delimiter=' ', const bool symmetric=false)
Remove useless delimiters on the borders of a C-string.
Definition: CImg.h:4935

cimg_library::CImg::get_projections2d
CImg< T > get_projections2d(const unsigned int x0, const unsigned int y0, const unsigned int z0, const int dx=-100, const int dy=-100, const int dz=-100) const
Definition: CImg.h:18151

cimg_library::CImg::get_select
CImg< intT > get_select(const char *const title, const int select_type=2, unsigned int *const XYZ=0, const unsigned char *const color=0) const
Simple interface to select a shape from an image.
Definition: CImg.h:28609

cimg_library::cimg::keyF4
const unsigned int keyF4
Definition: CImg.h:2675

cimg_library::CImg::get_unroll
CImg< T > get_unroll(const char axis) const
Definition: CImg.h:17624

cimg_library::CImg::round
CImg< T > & round(const float x, const int rounding_type=0)
Compute image with rounded pixel values.
Definition: CImg.h:14976

cimg_library::CImg::get_identity_matrix
CImg< T > get_identity_matrix() const
Definition: CImg.h:13420

cimg_library::CImg::get_load_ffmpeg
static CImg< T > get_load_ffmpeg(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false, const char axis='z', const char align='p')
Definition: CImg.h:30991

cimg_library::CImg::PSNR
Tfloat PSNR(const CImg< t > &img, const Tfloat valmax=(Tfloat) 255) const
Compute the PSNR between two images.
Definition: CImg.h:13130

dy
NT dy
Definition: rational_rotation.h:82

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34271

cimg_library::operator&
CImg< T > operator&(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5991

cimg_library::CImg::ptr
T * ptr()
Return a pointer to the pixel buffer.
Definition: CImg.h:11080

cimg_library::CImg::_save_raw
const CImg< T > & _save_raw(std::FILE *const file, const char *const filename, const bool multiplexed) const
Definition: CImg.h:33543

cimg_library::CImgException::CImgException
CImgException(const char *format,...)
Definition: CImg.h:2034

cimg_library::CImg::get_gradient
CImgList< Tfloat > get_gradient(const char *const axes=0, const int scheme=3) const
Compute the list of images, corresponding to the XY-gradients of an image.
Definition: CImg.h:20014

cimg_library::cimg::keyINSERT
const unsigned int keyINSERT
Definition: CImg.h:2696

cimg_library::CImg::columns
CImg< T > & columns(const unsigned int x0, const unsigned int x1)
Get a set of columns.
Definition: CImg.h:18412

cimg_library::CImg::is_sameXZ
bool is_sameXZ(const unsigned int dx, const unsigned int dz) const
Return true if image (*this) has the specified width and depth.
Definition: CImg.h:11939

cimg_library::CImg::assign
CImg< T > & assign(const CImg< t > &img, const char *const dimensions, const char *const values, const bool repeat_values)
In-place version of the previous constructor.
Definition: CImg.h:10317

cimg_library::cimg::imagemagick_path
const char * imagemagick_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to the ImageMagick&#39;s convert tool.
Definition: CImg.h:5094

cimg_library::CImg::_cimg_math_parser::level
unsigned int * level
Definition: CImg.h:12221

cimg_library::cimg::wait
unsigned int wait(const unsigned int milliseconds)
Wait for a certain number of milliseconds since the last call.
Definition: CImg.h:4650

cimg_library::CImg::is_sameY
bool is_sameY(const CImg< t > &img) const
Return true if images (*this) and img have same height.
Definition: CImg.h:11891

cimg_library::CImgList::atNXYZV
T atNXYZV(const int pos, const int x, const int y, const int z, const int v) const
Definition: CImg.h:34568

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5, const T val6, const T val7)
Fill sequentially pixel values.
Definition: CImg.h:14556

cimg_library::CImgList::at
CImg< T > & at(const int pos)
Read an image in specified position.
Definition: CImg.h:34544

cimg_library::CImgDisplay::is_keyG
volatile bool is_keyG
Definition: CImg.h:6221

cimg_library::CImgList::erase
CImgList< T > & erase(const iterator iter)
Remove the element pointed by iterator iter (STL-compliant name).
Definition: CImg.h:35437

cimg_library::CImgList::transfer_to
CImgList< T > & transfer_to(CImgList< t > &list)
Transfer the content of the instance image list into another one.
Definition: CImg.h:34302

pi
const double pi
Definition: compare_normals.C:253

cimg_library::CImg::_save_bmp
const CImg< T > & _save_bmp(std::FILE *const file, const char *const filename) const
Definition: CImg.h:32458

cimg_library::cimg::time
unsigned long time()
Get the value of a system timer with a millisecond precision.
Definition: CImg.h:4605

cimg_library::CImg::resize
CImg< T > & resize(const CImg< t > &src, const int interpolation_type=1, const int border_condition=-1, const bool center=false)
Resize an image.
Definition: CImg.h:16975

_cimg_Labf
#define _cimg_Labf(x)

cimg_library::CImg::CImg
CImg(const CImg< t > &img, const bool shared)
Advanced copy constructor.
Definition: CImg.h:10030

cimg_library::CImg::projections2d
CImg< T > & projections2d(const unsigned int x0, const unsigned int y0, const unsigned int z0, const int dx=-100, const int dy=-100, const int dz=-100)
Return a 2D representation of a 3D image, with three slices.
Definition: CImg.h:18146

cimg_library::CImg::_draw_line
CImg< T > & _draw_line(const t &points, const unsigned int W, const unsigned int H, const tc *const color, const float opacity, const unsigned int pattern, const bool init_hatch)
Definition: CImg.h:22950

cimg_library::CImgList::_atNXYZV
T _atNXYZV(const int pos, const int x, const int y, const int z, const int v) const
Definition: CImg.h:34579

cimg_library::CImgDisplay::is_fullscreen
bool is_fullscreen
Fullscreen state of the display.
Definition: CImg.h:6264

cimg_library::CImg::is_sameXYZ
bool is_sameXYZ(const CImg< t > &img) const
Return true if images have same width, same height and same depth.
Definition: CImg.h:12000

cimg_library::cimg::keyS
const unsigned int keyS
Definition: CImg.h:2715

cimg_library::CImg::box3d
static CImg< floatT > box3d(CImgList< tf > &primitives, const float size_x=200, const float size_y=100, const float size_z=100)
Create and return a 3D box object.
Definition: CImg.h:21819

cimg_library::CImgDisplay::normalization
unsigned int normalization
Normalization type used for the display.
Definition: CImg.h:6141

cimg_library::CImg::operator<<
CImg< T > operator<<(const int n) const
Operator&lt;&lt;().
Definition: CImg.h:10979

q
NT q
Definition: rational_rotation.h:105

cimg_library::CImg::save_pandore
const CImg< T > & save_pandore(std::FILE *const file, const unsigned int colorspace=0) const
Save the image as a PANDORE-5 file.
Definition: CImg.h:33538

cimg_library::CImg::cubic_atXY
Tfloat cubic_atXY(const float fx, const float fy, const int z=0, const int v=0) const
Read a pixel value using cubic interpolation and Neumann boundary conditions.
Definition: CImg.h:11637

cimg_library::CImgList::atNX
T atNX(const int pos, const int x, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:34664

cimg_library::CImgList::end
iterator end()
Returns an iterator just past the last element (STL-compliant name).
Definition: CImg.h:34517

cimg_library::CImg::at
T at(const int off, const T out_val) const
Definition: CImg.h:11192

cimg_library::CImg::get_load_jpeg
static CImg< T > get_load_jpeg(std::FILE *const file)
Definition: CImg.h:29506

cimg_library::CImg::draw_graph
CImg< T > & draw_graph(const CImg< t > &data, const tc *const color, const float opacity=1, const unsigned int plot_type=1, const int vertex_type=1, const double ymin=0, const double ymax=0, const bool expand=false, const unsigned int pattern=~0U)
Draw a 1D graph on the instance image.
Definition: CImg.h:26788

cimg_library::CImg::matrix
static CImg< T > matrix(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8)
Return a 3x3 square matrix with specified coefficients.
Definition: CImg.h:14303

cimg_library::CImg::_atX
T _atX(const int x, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:11351

cimg_library::CImgDisplay::operator=
CImgDisplay & operator=(const CImgDisplay &disp)
Operator=().
Definition: CImg.h:6476

cimg_library::CImgDisplay::window_posy
int window_posy() const
Return Y-coordinate of the window.
Definition: CImg.h:6648

cimg_library::cimg::superset< short, unsigned short >::type
int type
Definition: CImg.h:2259

cimg_library::CImg::rotation_matrix
static CImg< T > rotation_matrix(const float x, const float y, const float z, const float w, const bool quaternion_data=false)
Return a 3x3 rotation matrix along the (x,y,z)-axis with an angle w.
Definition: CImg.h:14395

cimg_library::CImg::save_medcon_external
const CImg< T > & save_medcon_external(const char *const filename) const
Save an image as a Dicom file (need &#39;(X)Medcon&#39; : http://xmedcon.sourceforge.net ) ...
Definition: CImg.h:33784

cimg_library::cimg::superset< unsigned int, float >::type
float type
Definition: CImg.h:2272

nrow
const int nrow
Definition: ex1.C:95

cimg_library::CImg::get_load_ascii
static CImg< T > get_load_ascii(const char *const filename)
Definition: CImg.h:29270

cimg_library::CImg::draw_quiver
CImg< T > & draw_quiver(const CImg< t1 > &flow, const t2 *const color, const float opacity=1, const unsigned int sampling=25, const float factor=-20, const bool arrows=true, const unsigned int pattern=~0U)
Draw a vector field in the instance image, using a colormap.
Definition: CImg.h:26498

cimg_library::cimg::type< float >::format
static const char * format()
Definition: CImg.h:2195

cimg_library::CImg::_load_png
CImg< T > & _load_png(std::FILE *const file, const char *const filename)
Definition: CImg.h:29669

cimg_library::CImg::append
CImg< T > & append(const CImg< t > &img, const char axis='x', const char align='p')
Append an image.
Definition: CImg.h:18642

cimg_library::CImg::clear
CImg< T > & clear()
In-place version of the default constructor (STL-compliant name).
Definition: CImg.h:10090

cimg_library::CImgList::atNXYZV
T atNXYZV(const int pos, const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:34556

cimg_library::CImg::_draw_triangle
CImg< T > & _draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc *const color, const float opacity, const float brightness)
Definition: CImg.h:23774

cimg_forZV
#define cimg_forZV(img, z, v)
Definition: CImg.h:602

cimg_forXYZV
#define cimg_forXYZV(img, x, y, z, v)
Definition: CImg.h:607

cimg_library::CImgDisplay::window_height
volatile unsigned int window_height
Height of the underlying window.
Definition: CImg.h:6126

cimg_library::cimg::keyPAD5
const unsigned int keyPAD5
Definition: CImg.h:2750

cimg_library::CImg::get_LabtoRGB
CImg< Tuchar > get_LabtoRGB() const
Definition: CImg.h:16423

cimg_library::CImg::_load_bmp
CImg< T > & _load_bmp(std::FILE *const file, const char *const filename)
Definition: CImg.h:29379

cimg_library::CImgDisplay::is_event
volatile bool is_event
Event state of the window.
Definition: CImg.h:6171

cimg_library::CImg::draw_point
CImg< T > & draw_point(const CImgList< t > &points, const CImg< tc > &color, const float opacity=1)
Draw a cloud of colored points.
Definition: CImg.h:22284

cimg_library::CImg::save_cimg
const CImg< T > & save_cimg(const char *const filename, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
Insert the image into an existing .cimg file, at specified coordinates.
Definition: CImg.h:33296

cimg_library::CImg::get_index
CImg< typename cimg::superset< t, unsigned int >::type > get_index(const CImg< t > &palette, const bool dithering=false, const bool map_indexes=true) const
Definition: CImg.h:15349

cimg_library::cimg::sqr
T sqr(const T val)
Return the square of a number.
Definition: CImg.h:4717

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const CImg< t > &sprite, const float opacity=1)
Draw an image.
Definition: CImg.h:26216

cimg_library::CImgDisplay::resize
CImgDisplay & resize(const int width, const int height, const bool redraw=true)
Resize window.
Definition: CImg.h:6733

cimg_library::CImg::transfer_to
CImg< T > & transfer_to(CImg< T > &img)
Definition: CImg.h:10338

cimg_library::CImg::operator=
CImg< T > & operator=(const T val)
Operator=().
Definition: CImg.h:10470

cimg_library::CImgList::is_empty
bool is_empty() const
Return true if list is empty.
Definition: CImg.h:34734

cimg_library::CImg::_marching2d_func_expr::~_marching2d_func_expr
~_marching2d_func_expr()
Definition: CImg.h:21453

cimg_library::CImg::display_graph
const CImg< T > & display_graph(CImgDisplay &disp, const unsigned int plot_type=1, const unsigned int vertex_type=1, const char *const labelx=0, const double xmin=0, const double xmax=0, const char *const labely=0, const double ymin=0, const double ymax=0) const
High-level interface for displaying a graph.
Definition: CImg.h:32133

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const int xc, const int yc, const float r1, const float r2, const float ru, const float rv, const tc *const color, const float opacity=1)
Draw an anisotropic 2D gaussian function.
Definition: CImg.h:27403

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14635

cimg_library::cimg::keyF7
const unsigned int keyF7
Definition: CImg.h:2678

cimg_library::CImg::cubic_atXY
Tfloat cubic_atXY(const float fx, const float fy, const int z, const int v, const T out_val) const
Read a pixel value using cubic interpolation and Dirichlet boundary conditions.
Definition: CImg.h:11590

cimg_library::CImg::_linear_atX
Tfloat _linear_atX(const float fx, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:11575

cimg_library::cimg::superset< char, unsigned char >::type
short type
Definition: CImg.h:2240

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int x1, const int y1, const tc *const color, const float opacity=1)
Draw a 2D filled colored rectangle in the instance image, at coordinates (x0,y0)-(x1,y1).
Definition: CImg.h:25653

cimg_library::CImg::get_SVD
CImgList< Tfloat > get_SVD(const bool sorting=true, const unsigned int max_iter=40, const float lambda=0) const
Definition: CImg.h:13985

cimg_library::CImg::get_column
CImg< T > get_column(const unsigned int x0) const
Definition: CImg.h:18407

cimg_library::CImgList::push_back
CImgList< T > & push_back(const CImgList< t > &list)
Insert list list at the end of the current list (STL-compliant name).
Definition: CImg.h:35416

cimg_library::CImg::save_pnm
const CImg< T > & save_pnm(std::FILE *const file, const unsigned int bytes_per_pixel=0) const
Save the image as a PNM file.
Definition: CImg.h:32997

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const float sigma, const tc *const color, const float opacity=1)
Draw an isotropic 2D gaussian function.
Definition: CImg.h:27429

cimg_for3x3x3
#define cimg_for3x3x3(img, x, y, z, v, I)
Definition: CImg.h:1808

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const CImg< tl > &light, const int lx0, const int ly0, const int lx1, const int ly1, const int lx2, const int ly2, const float opacity=1)
Draw a 2D Pseudo-Phong-shaded textured triangle, with perspective correction.
Definition: CImg.h:25280

cimg_library::CImg::draw_line
CImg< T > & draw_line(const CImg< t > &points, const tc *const color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23028

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34251

_cimg_for_triangle1
#define _cimg_for_triangle1(img, xl, xr, y, x0, y0, x1, y1, x2, y2)
Definition: CImg.h:23480

cimg_library::CImg::get_dilate
CImg< _cimg_Tt > get_dilate(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_dilatation=false) const
Definition: CImg.h:19020

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const tc *const color, const float opacity=1, const float sigma=0, const bool high_connexity=false)
Draw a 2D filled region starting from a point (x,y) in the instance image.
Definition: CImg.h:27152

cimg_library::CImg::operator^
CImg< T > operator^(const t val) const
Operator^().
Definition: CImg.h:10960

cimg_forZ
#define cimg_forZ(img, z)
Definition: CImg.h:595

cimg_library::CImg::get_shared_channel
CImg< T > get_shared_channel(const unsigned int v0)
Return a shared-memory image referencing one channel v0 of the instance image.
Definition: CImg.h:18573

cimg_library::CImg::get_fill
CImg< T > get_fill(const T val0, const T val1, const T val2, const T val3, const T val4, const T val5) const
Definition: CImg.h:14528

cimg_library::cimg::key7
const unsigned int key7
Definition: CImg.h:2691

cimg_library::CImg::get_load_tiff
static CImg< T > get_load_tiff(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)
Definition: CImg.h:30086

cimg_library::abs
CImg< _cimg_Tfloat > abs(const CImg< T > &instance)
Definition: CImg.h:6031

cimg_library::CImg::draw_mandelbrot
CImg< T > & draw_mandelbrot(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &color_palette, const float opacity=1, const double z0r=-2, const double z0i=-2, const double z1r=2, const double z1i=2, const unsigned int itermax=255, const bool normalized_iteration=false, const bool julia_set=false, const double paramr=0, const double parami=0)
Draw a quadratic Mandelbrot or Julia fractal set, computed using the Escape Time Algorithm.
Definition: CImg.h:27250

cimg_library::CImgDisplay::is_keyPAD0
volatile bool is_keyPAD0
Definition: CImg.h:6248

cimg_library::CImg::slice
CImg< T > & slice(const unsigned int z0)
Get a slice.
Definition: CImg.h:18439

cimg_library::CImg::invert
CImg< T > & invert(const bool use_LU=true)
Invert the current matrix.
Definition: CImg.h:13474

cimg_library::cimg::sleep
void sleep(const unsigned int milliseconds)
Sleep for a certain numbers of milliseconds.
Definition: CImg.h:4624

cimg_library::CImg::operator+
CImg< T > operator+() const
Operator+() (unary).
Definition: CImg.h:10573

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const int x0, const int y0, const int z0, const float u0, const float v0, const float w0, const int x1, const int y1, const int z1, const float u1, const float v1, const float w1, const tc *const color, const float opacity=1, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a cubic spline curve in the instance image (for volumetric images).
Definition: CImg.h:23173

cimg_library::CImgList::intT
cimg::last< T, int >::type intT
Definition: CImg.h:33918

cimg_library::CImgList::Tdouble
cimg::superset< T, double >::type Tdouble
Definition: CImg.h:33911

cimg_library::CImgDisplay::resize
CImgDisplay & resize(const CImg< T > &img, const bool redraw=true)
Resize a display window with the size of an image.
Definition: CImg.h:6715

cimg_library::CImg::median
T median() const
Return the median value of the image.
Definition: CImg.h:13015

cimg_library::CImg::_marching3d_func
Definition: CImg.h:21773

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const tc *const color, const float opacity=1, const float brightness=1)
Draw a 2D filled colored triangle, with z-buffering.
Definition: CImg.h:23846

cimg_library::CImgDisplay::is_key0
volatile bool is_key0
Definition: CImg.h:6197

cimg_library::CImg::XYZtoxyY
CImg< T > & XYZtoxyY()
Convert (X,Y,Z)_709 pixels of a color image into the (x,y,Y) color space.
Definition: CImg.h:16359

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12, const T &a13, const T &a14, const T &a15)
Return a vector with specified coefficients.
Definition: CImg.h:14276

cimg_library::CImg::translate
CImg< T > & translate(const int deltax, const int deltay=0, const int deltaz=0, const int deltav=0, const int border_condition=0)
Translate the image.
Definition: CImg.h:17229

cimg_library::CImg::_load_pnm
CImg< T > & _load_pnm(std::FILE *const file, const char *const filename)
Definition: CImg.h:29829

NTS::abs
NT abs(const NT &x)
Definition: number_utils.h:130

cimg_library::CImg::fillV
CImg< T > & fillV(const unsigned int x, const unsigned int y, const unsigned int z, const double a0,...)
Definition: CImg.h:14944

cimg_library::CImg::max
CImg< T > & max(const T val)
Pointwise max operator between an image and a value.
Definition: CImg.h:12830

cimg_library::CImg::CImg
CImg(const t *const data_buffer, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1, const bool shared=false)
Construct an image from a raw memory buffer.
Definition: CImg.h:9941

cimg_library::CImg::get_load_rgb
static CImg< T > get_load_rgb(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1)
Definition: CImg.h:29962

cimg_library::CImgList::operator,
CImgList< T > & operator,(const CImgList< t > &list)
Operator,().
Definition: CImg.h:34435

_cimg_load_cimg_case2
#define _cimg_load_cimg_case2(Ts, Tss)

cimg_library::CImg::histogram
CImg< T > & histogram(const unsigned int nb_levels, const T value_min=(T) 0, const T value_max=(T) 0)
Compute the histogram of the instance image.
Definition: CImg.h:15269

cimg_library::CImg::get_norm
CImg< Tfloat > get_norm(const int norm_type=2) const
Definition: CImg.h:15131

cimg_library::CImgDisplay::is_empty
bool is_empty() const
Return true is display is empty.
Definition: CImg.h:6493

cimg_library::CImg::distance
CImg< T > & distance(const T isovalue, const float sizex=1, const float sizey=1, const float sizez=1, const bool compute_sqrt=true)
Compute the Euclidean distance map to a shape of specified isovalue.
Definition: CImg.h:20441

cimg_library::CImgDisplay::resize
CImgDisplay & resize(const CImgDisplay &disp, const bool redraw=true)
Resize a display window using the size of the given display disp.
Definition: CImg.h:6720

cimg_library::CImgList::Tuint
cimg::superset< T, unsigned int >::type Tuint
Definition: CImg.h:33906

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6)
Return a vector with specified coefficients.
Definition: CImg.h:14175

cimg_library::CImgList::is_sameN
bool is_sameN(const CImgList< t > &list) const
Return true if list if of specified size.
Definition: CImg.h:34745

cimg_library::CImgList::display
const CImgList< T > & display(CImgDisplay &disp, const bool display_info, const char axis='x', const char align='p') const
Display the current CImgList instance in a new display window.
Definition: CImg.h:36316

cimg_library::cimg::superset< bool, unsigned short >::type
unsigned short type
Definition: CImg.h:2212

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const unsigned int key5, const unsigned int key6, const unsigned int key7, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6543

cimg_library::CImg::matrix
static CImg< T > matrix(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9, const T &a10, const T &a11, const T &a12, const T &a13, const T &a14, const T &a15, const T &a16, const T &a17, const T &a18, const T &a19, const T &a20, const T &a21, const T &a22, const T &a23, const T &a24)
Return a 5x5 square matrix with specified coefficients.
Definition: CImg.h:14327

cimg_library::CImg::fill
CImg< T > & fill(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)
Fill sequentially pixel values.
Definition: CImg.h:14773

cimg_library::cimg::superset< bool, signed char >::type
signed char type
Definition: CImg.h:2211

_cimg_load_inr_case
#define _cimg_load_inr_case(Tf, sign, pixsize, Ts)

cimg_library::CImg::atXYZ
T atXYZ(const int x, const int y, const int z, const int v=0) const
Definition: CImg.h:11274

cimg_library::CImgList::operator[]
const CImg< T > & operator[](const unsigned int pos) const
Definition: CImg.h:34357

cimg_library::CImgList::_save_empty_cimg
static void _save_empty_cimg(std::FILE *const file, const char *const filename, const unsigned int nb, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv)
Definition: CImg.h:36886

cimg_library::cimg::superset< short, long >::type
long type
Definition: CImg.h:2263

cimg_library::CImgDisplay::is_closed
volatile bool is_closed
Closed state of the window.
Definition: CImg.h:6162

cimg_library::CImgList::assign
CImgList< T > & assign(const CImg< t1 > &img1, const CImg< t2 > &img2, const bool shared=false)
In-place version of the corresponding constructor.
Definition: CImg.h:34226

cimg_library::CImgDisplay::buttons
volatile unsigned int buttons[512]
Button state of the mouse.
Definition: CImg.h:6147

cimg_library::CImg::_save_cpp
const CImg< T > & _save_cpp(std::FILE *const file, const char *const filename) const
Definition: CImg.h:32386

cimg_library::CImg::get_warp
CImg< T > get_warp(const CImg< t > &warp, const bool relative=false, const bool interpolation=true, const unsigned int border_conditions=0) const
Definition: CImg.h:17869

cimg_library::cimg::minmod
T minmod(const T a, const T b)
Return the minmod of two numbers.
Definition: CImg.h:4828

cimg_library::cimg::keyALT
const unsigned int keyALT
Definition: CImg.h:2736

cimg_library::cimg::key6
const unsigned int key6
Definition: CImg.h:2690

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const float x0, const float x1, const float y0, const float y1, const tc *const color, const float opacity=1, const int subdivisionx=-60, const int subdivisiony=-60, const float precisionx=0, const float precisiony=0, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw a labeled horizontal+vertical axis on the instance image.
Definition: CImg.h:26671

cimg_forY
#define cimg_forY(img, y)
Definition: CImg.h:594

CImg_2x2
#define CImg_2x2(I, T)
Definition: CImg.h:415

cimg_library::CImg::ptr
T * ptr(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0)
Return a pointer to the pixel value located at (x,y,z,v).
Definition: CImg.h:11122

cimg_library::CImg::linear_atXY
Tfloat linear_atXY(const float fx, const float fy, const int z, const int v, const T out_val) const
Read a pixel value using linear interpolation and Dirichlet boundary conditions (first two coordinate...
Definition: CImg.h:11516

cimg_library::CImg::get_autocrop
CImg< T > get_autocrop(const CImg< t > &color, const char *const axes="zyx") const
Definition: CImg.h:18351

cimg_library::CImg::operator*
CImg< _cimg_Tt > operator*(const CImg< t > &img) const
Operator*().
Definition: CImg.h:10712

cimg_library::CImg::channels
CImg< T > & channels(const unsigned int v0, const unsigned int v1)
Get a set of channels.
Definition: CImg.h:18466

cimg_library::CImg::_load_jpeg
CImg< T > & _load_jpeg(std::FILE *const file, const char *const filename)
Definition: CImg.h:29510

cimg_library::cimg::keyPADDIV
const unsigned int keyPADDIV
Definition: CImg.h:2758

_cimglist_def_is_same1
#define _cimglist_def_is_same1(axis)
Definition: CImg.h:34751

cimg_library::cimg::keyTAB
const unsigned int keyTAB
Definition: CImg.h:2699

cimg_library::CImg::assign
CImg< T > & assign(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const char *const values, const bool repeat_values)
In-place version of the corresponding constructor.
Definition: CImg.h:10172

cimg_library::CImg::get_HSItoRGB
CImg< Tfloat > get_HSItoRGB() const
Definition: CImg.h:16019

cimg_library::cimg::keyD
const unsigned int keyD
Definition: CImg.h:2716

cimg_library::CImg::get_cosh
CImg< Tfloat > get_cosh() const
Definition: CImg.h:12615

cimg_library::CImg::operator*=
CImg< T > & operator*=(const char *const expression)
Operator*=().
Definition: CImg.h:10676

cimg_library::CImg::elevation3d
static CImg< floatT > elevation3d(CImgList< tf > &primitives, const tfunc &func, const float x0, const float y0, const float x1, const float y1, const int size_x=256, const int size_y=256)
Get elevation3d of a function.
Definition: CImg.h:21284

cimg_library::CImg::get_equalize
CImg< T > get_equalize(const unsigned int nblevels, const T val_min=(T) 0, const T val_max=(T) 0) const
Definition: CImg.h:15321

cimg_library::cimg::rand
double rand()
Return a random variable between [0,1] with respect to an uniform distribution.
Definition: CImg.h:4833

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImg< t > &points, const CImg< tc > &color, const float opacity=1)
Draw a filled polygon in the instance image.
Definition: CImg.h:25783

cimg_library::CImgList::uintT
cimg::last< T, unsigned int >::type uintT
Definition: CImg.h:33917

cimg_library::CImg::get_shared_points
const CImg< T > get_shared_points(const unsigned int x0, const unsigned int x1, const unsigned int y0=0, const unsigned int z0=0, const unsigned int v0=0) const
Definition: CImg.h:18485

cimg_library::CImg::get_transpose
CImg< T > get_transpose() const
Definition: CImg.h:13451

cimg_library::CImg::load_raw
CImg< T > & load_raw(const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int sizez=1, const unsigned int sizev=1, const bool multiplexed=false, const bool invert_endianness=false)
Load an image from a .RAW file.
Definition: CImg.h:30928

cimg_library::acos
CImg< _cimg_Tfloat > acos(const CImg< T > &instance)
Definition: CImg.h:6051

cimg_library::CImg::is_sameXYZV
bool is_sameXYZV(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const
Return true if image (*this) has the specified width, height, depth and number of channels...
Definition: CImg.h:12038

cimg_library::CImg::is_sameXYZ
bool is_sameXYZ(const unsigned int dx, const unsigned int dy, const unsigned int dz) const
Return true if image (*this) has the specified width, height and depth.
Definition: CImg.h:11994

cimg_library::CImgDisplay::button
volatile unsigned int & button
Definition: CImg.h:6148

cimg_library::cimg::superset< signed char, unsigned int >::type
long type
Definition: CImg.h:2234

cimg_library::CImg::get_RGBtoHSI
CImg< Tfloat > get_RGBtoHSI() const
Definition: CImg.h:15977

cimg_library::CImgDisplay::hide_mouse
CImgDisplay & hide_mouse()
Hide mouse pointer.
Definition: CImg.h:6808

cimg_library::CImg::draw_arrow
CImg< T > & draw_arrow(const int x0, const int y0, const int x1, const int y1, const tc *const color, const float opacity=1, const float angle=30, const float length=-10, const unsigned int pattern=~0U)
Draw a colored arrow in the instance image.
Definition: CImg.h:23057

cimg_library::CImg::get_shared_line
CImg< T > get_shared_line(const unsigned int y0, const unsigned int z0=0, const unsigned int v0=0)
Return a shared-memory image referencing one particular line (y0,z0,v0) of the instance image...
Definition: CImg.h:18517

cimg_library::CImgList::insert
CImgList< T > & insert(const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
Insert a copy of the image img into the current image list, at position pos.
Definition: CImg.h:35041

cimg_library::CImg::get_invert
CImg< Tfloat > get_invert(const bool use_LU=true) const
Definition: CImg.h:13538

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14697

cimg_library::CImg::isosurface3d
static CImg< floatT > isosurface3d(CImgList< tf > &primitives, const char *const expression, const float isovalue, const float x0, const float y0, const float z0, const float x1, const float y1, const float z1, const int dx=32, const int dy=32, const int dz=32)
Definition: CImg.h:21745

cimg_library::cimg::keyBACKSPACE
const unsigned int keyBACKSPACE
Definition: CImg.h:2695

cimg_library::CImg::load_imagemagick_external
CImg< T > & load_imagemagick_external(const char *const filename)
Load an image using ImageMagick&#39;s external tool &#39;convert&#39;.
Definition: CImg.h:31291

cimg_library::CImg::get_load_imagemagick_external
static CImg< T > get_load_imagemagick_external(const char *const filename)
Definition: CImg.h:31320

cimg_library::CImgList::assign
CImgList< T > & assign(const unsigned int n)
In-place version of the corresponding constructor.
Definition: CImg.h:34159

cimg_library::CImg::fillX
CImg< T > & fillX(const unsigned int y, const unsigned int z, const unsigned int v, const int a0,...)
Fill image values along the X-axis at the specified pixel position (y,z,v).
Definition: CImg.h:14899

cimg_library::CImg::__draw_object3d
void __draw_object3d(const unsigned int n_primitive, const unsigned int nb_opacities, const CImgList< to > &opacities, const CImg< tc > &color, const int nx0, const int ny0, const CImg< T > &sprite, const float opac)
Definition: CImg.h:27611

cimg_library::CImg::quantize
CImg< T > & quantize(const unsigned int nb_levels, const bool keep_range=true)
Uniformly quantize values of the instance image into nb_levels levels.
Definition: CImg.h:15197

nj
void int * nj
Definition: read.cpp:74

cimg_library::CImg::draw_rectangle
CImg< T > & draw_rectangle(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &color, const float opacity=1)
Draw a 2D filled colored rectangle in the instance image, at coordinates (x0,y0)-(x1,y1).
Definition: CImg.h:25661

cimg_library::CImg::operator%=
CImg< T > & operator%=(const char *const expression)
Operator%=().
Definition: CImg.h:10781

cimg_library::CImg::fill
CImg< T > & fill(const T val0, const T val1, const T val2, const T val3)
Fill sequentially all pixel values with values val0 and val1 and val2 and val3.
Definition: CImg.h:14474

cimg_library::CImgList::crop_font
CImgList< T > & crop_font()
Create an auto-cropped font (along the X axis) from a input font font.
Definition: CImg.h:37025

cimg_library::CImgList::operator()
const CImg< T > & operator()(const unsigned int pos) const
Definition: CImg.h:34373

cimg_library::cimg::keyPAD8
const unsigned int keyPAD8
Definition: CImg.h:2753

cimg_library::CImg::draw_line
CImg< T > & draw_line(const int x0, const int y0, const int x1, const int y1, const tc *const color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D colored line.
Definition: CImg.h:22330

cimg_library::CImgList::maxmin
const T & maxmin(t &min_val) const
Definition: CImg.h:35014

cimg_library::CImgList::floatT
cimg::last< T, float >::type floatT
Definition: CImg.h:33921

dist
long double dist(long double *coord1, long double *coord2, int size)
Definition: utilities/rc_cmp/util.cpp:305

cimg_library::CImgList::ulongT
cimg::last< T, unsigned long >::type ulongT
Definition: CImg.h:33919

cimg_library::CImg::get_translate
CImg< T > get_translate(const int deltax, const int deltay=0, const int deltaz=0, const int deltav=0, const int border_condition=0) const
Definition: CImg.h:17424

cimg_library::CImg::get_RGBtoxyY
CImg< Tfloat > get_RGBtoxyY() const
Definition: CImg.h:16432

cimg_library::cimg::type< signed char >::format
static unsigned int format(const signed char val)
Definition: CImg.h:2133

cimg_library::CImg::load_cimg
CImg< T > & load_cimg(std::FILE *const file, const char axis='z', const char align='p')
Load an image (list) from a .cimg file.
Definition: CImg.h:30543

cimg_library::CImg::save_yuv
const CImg< T > & save_yuv(std::FILE *const file, const bool rgb2yuv=true) const
Save the image as a YUV video sequence file.
Definition: CImg.h:33600

cimg_library::CImgDisplay::is_key4
volatile bool is_key4
Definition: CImg.h:6191

cimg_library::CImg::_distance_sep
static int _distance_sep(const int i, const int u, const int gi2, const int gu2, const float fact)
Definition: CImg.h:20541

cimg_library::CImgList::get_FFT
CImgList< Tfloat > get_FFT(const char axis, const bool invert=false) const
Definition: CImg.h:37125

cimg_library::CImg::get_exp
CImg< Tfloat > get_exp() const
Definition: CImg.h:12545

cimg_library::CImg::atXYZ
T & atXYZ(const int x, const int y, const int z, const int v, const T out_val)
Read a pixel value with Dirichlet boundary conditions for the three first coordinates (x...
Definition: CImg.h:11257

cimg_library::CImgDisplay::wait
static void wait(CImgDisplay &disp1)
Wait for any event occuring on the display disp1.
Definition: CImg.h:6882

cimg_library::CImg::get_fill
CImg< T > get_fill(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
Definition: CImg.h:14606

cimg_library::CImgList::save_ffmpeg_external
const CImgList< T > & save_ffmpeg_external(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const char *const codec="mpeg2video") const
Save an image sequence using the external tool &#39;ffmpeg&#39;.
Definition: CImg.h:36975

cimg_library::CImg::get_min
CImg< _cimg_Tt > get_min(const CImg< t > &img) const
Definition: CImg.h:12799

CImg_2x2x2
#define CImg_2x2x2(I, T)
Definition: CImg.h:451

cimg_library::cimg::type< int >::format
static int format(const int val)
Definition: CImg.h:2169

cimg_library::CImgList::save_cimg
const CImgList< T > & save_cimg(std::FILE *const file, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
Insert the instance image into into an existing .cimg file, at specified coordinates.
Definition: CImg.h:36878

cimg_library::CImg::fillZ
CImg< T > & fillZ(const unsigned int x, const unsigned int y, const unsigned int v, const double a0,...)
Definition: CImg.h:14931

cimg_library::cimg::ffmpeg_path
const char * ffmpeg_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to the &#39;ffmpeg&#39; command.
Definition: CImg.h:5346

cimg_library::CImg::CImg
CImg(const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const double val0, const double val1,...)
Construct an image with given size (dx,dy,dz,dv) and with specified pixel values (double version)...
Definition: CImg.h:9921

cimg_library::CImg::_cimg_math_parser::expr
char * expr
Definition: CImg.h:12223

cimg_library::cimg::argument
const char * argument(const unsigned int nb, const int argc, const char *const *const argv, const unsigned int nb_singles=0,...)
Definition: CImg.h:5682

cimg_for6x6
#define cimg_for6x6(img, x, y, z, v, I)
Definition: CImg.h:1247

cimg_library::CImg::operator<
CImgList< T > operator<(const char axis) const
Operator&lt;().
Definition: CImg.h:11024

cimg_library::CImg::cylinder3d
static CImg< floatT > cylinder3d(CImgList< tf > &primitives, const float radius=50, const float size_z=100, const unsigned int subdivisions=24)
Create and return a 3D cylinder.
Definition: CImg.h:21882

cimg_library::cimg::type< bool >::format
static const char * format(const bool val)
Definition: CImg.h:2106

cimg_library::CImg::get_rand
CImg< T > get_rand(const T val_min, const T val_max) const
Definition: CImg.h:14967

cimg_library::CImg::sequence
static CImg< T > sequence(const unsigned int N, const T a0, const T a1)
Return a N-numbered sequence vector from a0 to a1.
Definition: CImg.h:14389

cimg_library::CImgDisplay::assign
CImgDisplay & assign(const CImgList< T > &list, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
In-place version of the previous constructor.
Definition: CImg.h:6415

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const tc *const color, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded colored triangle.
Definition: CImg.h:23972

cimg_library::CImg::_load_dlm
CImg< T > & _load_dlm(std::FILE *const file, const char *const filename)
Definition: CImg.h:29331

cimg_library::CImg::ucharT
cimg::last< T, unsigned char >::type ucharT
Definition: CImg.h:9784

cimg_library::cimg::keyF2
const unsigned int keyF2
Definition: CImg.h:2673

cimg_library::cimg::keyARROWDOWN
const unsigned int keyARROWDOWN
Definition: CImg.h:2743

cimg_library::cimg::superset< unsigned int, double >::type
double type
Definition: CImg.h:2273

cimg_library::CImg::is_sameXYV
bool is_sameXYV(const CImg< t > &img) const
Return true if images have same width, same height and same number of channels.
Definition: CImg.h:12011

cimg_library::CImgList::get_load_cimg
static CImgList< T > get_load_cimg(std::FILE *const file)
Definition: CImg.h:35546

cimg_library::CImg::operator()
T & operator()(const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0)
Fast access to pixel value for reading or writing.
Definition: CImg.h:10451

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float opacity=1, const float brightness=1)
Draw a 2D textured triangle, with z-buffering and perspective correction.
Definition: CImg.h:24434

cimg_library::tanh
CImg< _cimg_Tfloat > tanh(const CImg< T > &instance)
Definition: CImg.h:6076

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const int xc, const int yc, const float r1, const float r2, const float ru, const float rv, const CImg< tc > &color, const float opacity=1)
Draw an anisotropic 2D gaussian function.
Definition: CImg.h:27415

cimg_library::CImg::channel
CImg< T > & channel(const unsigned int v0)
Get a channel.
Definition: CImg.h:18457

cimg_library::CImg::atXYZV
T atXYZV(const int x, const int y, const int z, const int v) const
Definition: CImg.h:11239

for
for(;;)
Definition: rational_rotation.h:111

cimg_library::CImg::operator!=
bool operator!=(const CImg< t > &img) const
Operator!=().
Definition: CImg.h:11007

cimg_library::CImgList::get_reverse
CImgList< T > get_reverse() const
Definition: CImg.h:35237

_cimglist_def_is_same2
#define _cimglist_def_is_same2(axis1, axis2)
Definition: CImg.h:34759

cimg_library::cimg::dialog
int dialog(const char *title, const char *msg, const char *button1_txt="OK", const char *button2_txt=0, const char *button3_txt=0, const char *button4_txt=0, const char *button5_txt=0, const char *button6_txt=0, const bool centering=false)
Definition: CImg.h:37329

cimg_library::CImg::min
CImg< T > & min(const T val)
Pointwise min operator between an image and a value.
Definition: CImg.h:12779

cimg_library::cimg::superset< unsigned int, int >::type
long type
Definition: CImg.h:2269

cimg_library::CImg::_marching2d_func_expr::mp
_cimg_math_parser * mp
Definition: CImg.h:21446

cimg_library::CImg::get_sequence
CImg< T > get_sequence(const T a0, const T a1) const
Definition: CImg.h:13436

cimg_library::CImg::variancemean
Tfloat variancemean(const unsigned int variance_method, t &mean) const
Return the variance and the mean of the image.
Definition: CImg.h:13064

key
static T_Key key
Definition: vinci_lass.c:76

cimg_library::CImg::get_atan2
CImg< Tfloat > get_atan2(const CImg< t > &img) const
Definition: CImg.h:12679

cimg_library::CImg::matrix
static CImg< T > matrix(const T &a0)
Return a 1x1 square matrix with specified coefficients.
Definition: CImg.h:14289

cimg_library::CImgList::pop_front
CImgList< T > & pop_front()
Remove first element of the list (STL-compliant name).
Definition: CImg.h:35432

cimg_library::CImg::_save_off
const CImg< T > & _save_off(std::FILE *const file, const char *const filename, const CImgList< tf > &primitives, const CImgList< tc > &colors) const
Definition: CImg.h:33607

cimg_library::CImgList::load_gzip_external
CImgList< T > & load_gzip_external(const char *const filename)
Load a gzipped list, using external tool &#39;gunzip&#39;.
Definition: CImg.h:36169

cimg_library::CImg::atX
T & atX(const int x, const int y=0, const int z=0, const int v=0)
Read a pixel value with Neumann boundary conditions for the first coordinates (x).
Definition: CImg.h:11333

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const CImg< t > &tensor, const CImg< tc > &color, const float opacity=1)
Draw a filled ellipse.
Definition: CImg.h:26047

cimg_library::CImg::get_dilate
CImg< T > get_dilate(const unsigned int n, const unsigned int cond=1) const
Definition: CImg.h:19104

cimg_library::CImg::set_matrix_at
CImg< T > & set_matrix_at(const CImg< t > &mat, const unsigned int x=0, const unsigned int y=0, const unsigned int z=0)
Set the image vec as the square matrix-valued pixel located at (x,y,z) of the current vector-valued i...
Definition: CImg.h:13310

cimg_library::CImg::get_pow
CImg< Tfloat > get_pow(const double p) const
Definition: CImg.h:12733

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6516

cimg_library::CImg::get_tensor
CImg< T > get_tensor() const
Definition: CImg.h:13376

cimg_library::CImg::_marching3d_func::_marching3d_func
_marching3d_func(const CImg< T > &pref)
Definition: CImg.h:21775

cimg_library::CImg::atXYZV
T & atXYZV(const int x, const int y, const int z, const int v)
Read a pixel value with Neumann boundary conditions.
Definition: CImg.h:11232

cimg_library::CImg::get_load_dlm
static CImg< T > get_load_dlm(const char *const filename)
Definition: CImg.h:29318

cimg_library::cimg::nearest_pow2
unsigned int nearest_pow2(const T x)
Return the nearest power of 2 higher than a given number.
Definition: CImg.h:4776

cimg_library::CImg::_display_object3d
const CImg< T > & _display_object3d(CImgDisplay &disp, const char *const title, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const to &opacities, const bool centering, const int render_static, const int render_motion, const bool double_sided, const float focale, const float specular_light, const float specular_shine, const bool display_axes, float *const pose_matrix) const
Definition: CImg.h:31788

cimg_library::cimg::superset< char, signed char >::type
short type
Definition: CImg.h:2241

cimg_library::CImg::atan
CImg< T > & atan()
Compute the arc-tangent of each pixel.
Definition: CImg.h:12660

cimg_library::CImgList::front
const CImg< T > & front() const
Definition: CImg.h:34530

cimg_library::CImgDisplay::is_keyARROWLEFT
volatile bool is_keyARROWLEFT
Definition: CImg.h:6245

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImg< t > &points, const tc *const color, const float opacity=1)
Draw a filled polygon in the instance image.
Definition: CImg.h:25773

cimg_library::CImg::Tulong
cimg::superset< T, unsigned long >::type Tulong
Definition: CImg.h:9779

cimg_library::CImg::HSItoRGB
CImg< T > & HSItoRGB()
Convert color pixels from (H,S,I) to (R,G,B).
Definition: CImg.h:15982

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int *const keyseq, const unsigned int N, const bool remove=true)
Test if a key sequence has been typed.
Definition: CImg.h:6567

cimg_library::CImgList::push_back
CImgList< T > & push_back(const CImg< t > &img)
Insert image img at the end of the list (STL-compliant name).
Definition: CImg.h:35404

cimg_library::CImgDisplay::is_keyF5
volatile bool is_keyF5
Definition: CImg.h:6179

cimg_library::CImg::operator-
CImg< Tfloat > operator-(const char *const expression) const
Operator-().
Definition: CImg.h:10658

cimg_library::cimg::superset< signed char, long >::type
long type
Definition: CImg.h:2237

cimg_library::operator/
CImg< _cimg_Tfloat > operator/(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5986

cimg_library::cimg::superset< unsigned char, unsigned int >::type
unsigned int type
Definition: CImg.h:2224

cimg_library::CImgList::display
const CImgList< T > & display(CImgDisplay &disp, const char axis='x', const char align='p') const
Display the current CImgList instance in an existing CImgDisplay window (by reference).
Definition: CImg.h:36301

cimg_library::CImg::draw_line
CImg< T > & draw_line(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const tc *const color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a 2D colored line, with z-buffering.
Definition: CImg.h:22402

cimg_library::CImg::depth
unsigned int depth
Variable representing the depth of the instance image (i.e. dimensions along the Z-axis).
Definition: CImg.h:9733

cimg_library::CImg::is_sameY
bool is_sameY(const CImgDisplay &disp) const
Return true if images (*this) and the display disp have same height.
Definition: CImg.h:11896

cimg_library::CImg::draw_spline
CImg< T > & draw_spline(const int x0, const int y0, const int z0, const float u0, const float v0, const float w0, const int x1, const int y1, const int z1, const float u1, const float v1, const float w1, const CImg< tc > &color, const float opacity=1, const float precision=4, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a cubic spline curve in the instance image (for volumetric images).
Definition: CImg.h:23214

cimg_library::CImg::dilate
CImg< T > & dilate(const CImg< t > &mask, const unsigned int cond=1, const bool weighted_dilatation=false)
Dilate the image by a structuring element.
Definition: CImg.h:19015

cimg_library::CImg::max
const T & max() const
Definition: CImg.h:12909

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const CImg< tc > &color, const float opacity=1, const float sigma=0, const bool high_connexity=false)
Draw a 2D filled region starting from a point (x,y) in the instance image.
Definition: CImg.h:27161

cimg_library::cimg::basename
const char * basename(const char *const s)
Compute the basename of a filename.
Definition: CImg.h:4989

cimg_library::CImg::assign
CImg< T > & assign(const t *const data_buffer, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const bool shared)
In-place version of the previous constructor, allowing to force the shared state of the instance imag...
Definition: CImg.h:10208

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

cimg_library::CImg::assign
CImg< T > & assign(const CImg< t > &img, const char *const dimensions)
In-place version of the previous constructor.
Definition: CImg.h:10283

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7)
Return a vector with specified coefficients.
Definition: CImg.h:14184

cimg_library::CImg::_save_png
const CImg< T > & _save_png(std::FILE *const file, const char *const filename, const unsigned int bytes_per_pixel=0) const
Definition: CImg.h:32714

cimg_library::CImg::RGBtoYCbCr
CImg< T > & RGBtoYCbCr()
Convert color pixels from (R,G,B) to (Y,Cb,Cr)_8.
Definition: CImg.h:16024

cimg_library::CImg::get_min
CImg< Tfloat > get_min(const char *const expression) const
Definition: CImg.h:12825

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(const int x0, const int y0, const int x1, const int y1, const int x2, const int y2, const CImg< tc > &texture, const int tx0, const int ty0, const int tx1, const int ty1, const int tx2, const int ty2, const float brightness0, const float brightness1, const float brightness2, const float opacity=1)
Draw a 2D Gouraud-shaded textured triangle.
Definition: CImg.h:24843

cimg_library::CImg::_marching2d_func_expr::_marching2d_func_expr
_marching2d_func_expr(const char *const expr)
Definition: CImg.h:21447

_cimg_valign2d
#define _cimg_valign2d(i, j)

cimg_library::CImg::RGBtoBayer
CImg< T > & RGBtoBayer()
Convert a (R,G,B) image to a Bayer-coded representation.
Definition: CImg.h:16467

cimg_library::cimg::type< long >::string
static const char * string()
Definition: CImg.h:2182

cimg_library::cimg::type::format
static const char * format()
Definition: CImg.h:2096

cimg_library::CImg::blur_patch
CImg< T > & blur_patch(const float sigma_s, const float sigma_p, const unsigned int patch_size=3, const unsigned int lookup_size=4, const float smoothness=0, const bool fast_approx=true)
Blur an image in its patch-based space.
Definition: CImg.h:19633

cimg_library::CImg::pow
CImg< T > & pow(const CImg< t > &img)
Compute the power of each pixel value.
Definition: CImg.h:12739

cimg_library::CImg::assign
CImg< T > & assign(const T *const data_buffer, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv, const bool shared)
Definition: CImg.h:10217

cimg_library::cimg::superset< long, float >::type
float type
Definition: CImg.h:2286

cimg_library::cimg::type::string
static const char * string()
Definition: CImg.h:2085

cimg_library::cimg::type< double >::min
static double min()
Definition: CImg.h:2202

cimg_library::CImgList::const_iterator
const CImg< T > * const_iterator
Define a CImgList&lt;T&gt;::const_iterator.
Definition: CImg.h:33895

cimg_library::CImg::vector
static CImg< T > vector(const T &a0, const T &a1, const T &a2, const T &a3, const T &a4, const T &a5, const T &a6, const T &a7, const T &a8, const T &a9)
Return a vector with specified coefficients.
Definition: CImg.h:14204

cimg_library::CImgList::get_load_gzip_external
static CImgList< T > get_load_gzip_external(const char *const filename)
Definition: CImg.h:36200

cimg_library::cimg::last
Definition: CImg.h:2298

cimg_library::cimg::dcraw_path
const char * dcraw_path(const char *const user_path=0, const bool reinit_path=false)
Return or set path to the &#39;dcraw&#39; command.
Definition: CImg.h:5439

cimg_library::CImg::variance
Tfloat variance(const unsigned int variance_method=1) const
Return the variance of the image.
Definition: CImg.h:13057

cimg_library::CImg::get_load_pnm
static CImg< T > get_load_pnm(std::FILE *const file)
Definition: CImg.h:29825

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float sigma, const tc *const color, const float opacity=1)
Draw a 1D gaussian function in the instance image.
Definition: CImg.h:27328

cimg_library::CImg::diagonal
CImg< T > & diagonal()
Get a diagonal matrix, whose diagonal coefficients are the coefficients of the input image...
Definition: CImg.h:13404

cimg_library::CImg::draw_triangle
CImg< T > & draw_triangle(CImg< floatT > &zbuffer, const int x0, const int y0, const float z0, const int x1, const int y1, const float z1, const int x2, const int y2, const float z2, const CImg< tc > &color, const float opacity=1, const float brightness=1)
Draw a 2D filled colored triangle, with z-buffering.
Definition: CImg.h:23947

cimg_library::CImg::get_CMYtoCMYK
CImg< Tfloat > get_CMYtoCMYK() const
Definition: CImg.h:16185

cimg_library::CImg::autocrop
CImg< T > & autocrop(const T value, const char *const axes="vzyx")
Autocrop an image, regarding of the specified backround value.
Definition: CImg.h:18267

cimg_library::cimg::superset2
Definition: CImg.h:2290

cimg_library::CImg::operator*
CImg< Tfloat > operator*(const char *const expression) const
Operator*().
Definition: CImg.h:10706

cimg_library::CImgList::CImgList
CImgList(const CImg< t > &img, const bool shared=false)
Construct an image list from one image.
Definition: CImg.h:34030

cimg_library::CImg::load_tiff
CImg< T > & load_tiff(const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)
Load an image from a TIFF file.
Definition: CImg.h:30043

Mesquite::pow
double pow(double value, const Exponent &exp)
Definition: includeLinks/Exponent.hpp:89

cimg_library::CImg::draw_mandelbrot
CImg< T > & draw_mandelbrot(const CImg< tc > &color_palette, const float opacity=1, const double z0r=-2, const double z0i=-2, const double z1r=2, const double z1i=2, const unsigned int itermax=255, const bool normalized_iteration=false, const bool julia_set=false, const double paramr=0, const double parami=0)
Draw a quadratic Mandelbrot or Julia fractal set, computed using the Escape Time Algorithm.
Definition: CImg.h:27311

cimg_library::CImg::operator=
CImg< T > & operator=(const char *const expression)
Operator=().
Definition: CImg.h:10482

cimg_library::CImg::operator+=
CImg< T > & operator+=(const CImg< t > &img)
Operator+=().
Definition: CImg.h:10543

_cimg_Labfi
#define _cimg_Labfi(x)

cimg_library::cimg::key8
const unsigned int key8
Definition: CImg.h:2692

cimg_library::cimg::superset< unsigned long, long >::type
long type
Definition: CImg.h:2283

cimg_library::cimg::type< char >::max
static char max()
Definition: CImg.h:2122

cimg_library::CImg::draw_axis
CImg< T > & draw_axis(const float x0, const float x1, const float y0, const float y1, const CImg< tc > &color, const float opacity=1, const int subdivisionx=-60, const int subdivisiony=-60, const float precisionx=0, const float precisiony=0, const unsigned int patternx=~0U, const unsigned int patterny=~0U)
Draw a labeled horizontal+vertical axis on the instance image.
Definition: CImg.h:26690

cimg_library::CImgList::get_reverse_object3d
CImgList< T > get_reverse_object3d() const
Definition: CImg.h:37154

cimg_library::CImgList::save_cimg
const CImgList< T > & save_cimg(const char *const filename, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
Insert the instance image into into an existing .cimg file, at specified coordinates.
Definition: CImg.h:36870

cimg_library::CImgList::Tuchar
cimg::superset< T, unsigned char >::type Tuchar
Definition: CImg.h:33902

cimg_library::CImg::intT
cimg::last< T, int >::type intT
Definition: CImg.h:9789

cimg_library::CImgInstanceException
Definition: CImg.h:2039

CImg_3x3
#define CImg_3x3(I, T)
Definition: CImg.h:421

cimg_library::CImgList::atNX
T atNX(const int pos, const int x, const int y, const int z, const int v, const T out_val) const
Definition: CImg.h:34652

cimglist_for_in
#define cimglist_for_in(list, l0, l1, l)
Definition: CImg.h:1878

cimg_library::CImgList::load_cimg
CImgList< T > & load_cimg(std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
Load a sub-image list from a non compressed .cimg file.
Definition: CImg.h:35658

cimg_library::CImg::operator++
CImg< T > & operator++()
Operator++() (prefix).
Definition: CImg.h:10556

cimg_library::CImg::get_RGBtoHSL
CImg< Tfloat > get_RGBtoHSL() const
Definition: CImg.h:15906

cimg_library::CImg::save_analyze
const CImg< T > & save_analyze(const char *const filename, const float *const voxsize=0) const
Save the image as an ANALYZE7.5 or NIFTI file.
Definition: CImg.h:33219

cimg_library::CImg::operator|=
CImg< T > & operator|=(const char *const expression)
Operator|=().
Definition: CImg.h:10882

cimg_library::cimg::superset< unsigned short, long >::type
long type
Definition: CImg.h:2256

cimg_library::CImgDisplay::released_keys
volatile unsigned int released_keys[512]
Definition: CImg.h:6159

cimg_library::cimg::superset< unsigned short, int >::type
int type
Definition: CImg.h:2254

cimg_library::CImg::resize_object3d
CImg< T > & resize_object3d(const float sx, const float sy=-100, const float sz=-100)
Resize a 3D object.
Definition: CImg.h:21107

cimg_library::CImg::display
const CImg< T > & display(CImgDisplay &disp) const
Display an image into a CImgDisplay window.
Definition: CImg.h:31463

cimg_library::CImg::get_normalize
CImg< Tfloat > get_normalize() const
Definition: CImg.h:15110

cimg_library::cimg::superset< unsigned int, unsigned long >::type
unsigned long type
Definition: CImg.h:2270

cimg_library::operator-
CImg< _cimg_Tfloat > operator-(const char *const expression, const CImg< T > &img)
Definition: CImg.h:5976

cimg_library::CImg::YUVtoRGB
CImg< T > & YUVtoRGB()
Convert color pixels from (Y,U,V) to (R,G,B).
Definition: CImg.h:16103

cimg_library::CImg::display_object3d
const CImg< T > & display_object3d(const char *const title, const CImg< tp > &vertices, const CImgList< tf > &primitives, const CImgList< tc > &colors, const to &opacities, const bool centering=true, const int render_static=4, const int render_motion=1, const bool double_sided=true, const float focale=500, const float specular_light=0.2f, const float specular_shine=0.1f, const bool display_axes=true, float *const pose_matrix=0) const
High-level interface for displaying a 3d object.
Definition: CImg.h:31681

cimg_library::CImg::swap
CImg< T > & swap(CImg< T > &img)
Swap all fields of two images. Use with care !
Definition: CImg.h:10357

cimg_library::CImg::get_min
CImg< T > get_min(const T val) const
Definition: CImg.h:12784

cimg_library::CImg::save_rgb
const CImg< T > & save_rgb(const char *const filename) const
Save the image as a RGB file.
Definition: CImg.h:33048

cimg_library::cimg::keyF1
const unsigned int keyF1
Definition: CImg.h:2672

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImg< t > &points, const tc *const color, const float opacity, const unsigned int pattern)
Draw a polygon outline.
Definition: CImg.h:25844

cimg_library::CImgList::contains
bool contains(const CImg< T > &img, t &n) const
Return true if the list contains the image &#39;img&#39;. If true, returns the position (n) of the image in t...
Definition: CImg.h:34880

cimg_library::CImg::draw_line
CImg< T > & draw_line(const CImgList< t > &points, const CImg< tc > &color, const float opacity=1, const unsigned int pattern=~0U, const bool init_hatch=true)
Draw a set of consecutive colored lines in the instance image.
Definition: CImg.h:23015

cimg_library::CImg::vector
static CImg< T > vector(const T &a0)
Return a vector with specified coefficients.
Definition: CImg.h:14134

cimg_library::CImg::get_shared_lines
const CImg< T > get_shared_lines(const unsigned int y0, const unsigned int y1, const unsigned int z0=0, const unsigned int v0=0) const
Definition: CImg.h:18506

cimg_library::cimg::fopen
std::FILE * fopen(const char *const path, const char *const mode)
Open a file, and check for possible errors.
Definition: CImg.h:5494

cos
NT & cos
Definition: rational_rotation.h:79

cimg_library::CImg::get_structure_tensor
CImg< Tfloat > get_structure_tensor(const unsigned int scheme=1) const
Definition: CImg.h:20186

cimg_library::CImgDisplayException::CImgDisplayException
CImgDisplayException(const char *format,...)
Definition: CImg.h:2058

cimg_library::CImg::operator=
CImg< T > & operator=(const CImg< t > &img)
Operator=().
Definition: CImg.h:10502

cimg_library::CImg::tensor
static CImg< T > tensor(const T &a1)
Return a 1x1 symmetric matrix with specified coefficients.
Definition: CImg.h:14342

cimg_library::CImgList::get_load_off
static CImgList< T > get_load_off(const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
Definition: CImg.h:36212

cimg_forXV
#define cimg_forXV(img, x, v)
Definition: CImg.h:600

cimg_library::cimg::type< short >::string
static const char * string()
Definition: CImg.h:2146

cimg_library::CImg::eval
double eval(const char *const expression, const double x=0, const double y=0, const double z=0, const double v=0) const
Evaluate math expression.
Definition: CImg.h:13140

cimg_for2x2x2
#define cimg_for2x2x2(img, x, y, z, v, I)
Definition: CImg.h:1774

cimg_library::cimg::type< bool >::is_float
static bool is_float()
Definition: CImg.h:2102

cimg_library::CImgInstanceException::CImgInstanceException
CImgInstanceException(const char *format,...)
Definition: CImg.h:2040

cimg_library::CImgDisplay::is_key
bool is_key(const unsigned int key1, const unsigned int key2, const unsigned int key3, const unsigned int key4, const unsigned int key5, const unsigned int key6, const bool remove)
Test if a key sequence has been typed.
Definition: CImg.h:6536

cimg_library::cimg::font10x19
const unsigned int font10x19[10 *19 *256/32]
Definition: CImg.h:2935

cimg_library::CImgDisplay::wait
CImgDisplay & wait(const unsigned int milliseconds)
Synchronized waiting function. Same as cimg::wait().
Definition: CImg.h:6870

cimg_library::CImg::dim
unsigned int dim
Variable representing the number of channels of the instance image (i.e. dimensions along the V-axis)...
Definition: CImg.h:9744

cimg_library::CImg::contains
bool contains(const T &pixel) const
Return true if specified referenced value is inside the image boundaries.
Definition: CImg.h:12105

cimg_library::CImg::load_rgba
CImg< T > & load_rgba(std::FILE *const file, const unsigned int dimw, const unsigned int dimh=1)
Load an image from a RGBA file.
Definition: CImg.h:30004

cimg_library::cimg::superset< unsigned char, int >::type
int type
Definition: CImg.h:2225

cimg_library::CImg::load_gzip_external
CImg< T > & load_gzip_external(const char *const filename)
Load a gzipped image file, using external tool &#39;gunzip&#39;.
Definition: CImg.h:31255

cimg_library::CImg::linear_atX
Tfloat linear_atX(const float fx, const int y=0, const int z=0, const int v=0) const
Read a pixel value using linear interpolation and Neumann boundary conditions (first coordinate)...
Definition: CImg.h:11568

cimg_library::CImg::get_load_medcon_external
static CImg< T > get_load_medcon_external(const char *const filename)
Definition: CImg.h:31354

cimg_library::CImg::structure_tensor
CImg< T > & structure_tensor(const unsigned int scheme=1)
Compute the structure tensor field of an image.
Definition: CImg.h:20182

cimg_library::CImg::get_fill
CImg< T > get_fill(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) const
Definition: CImg.h:14842

cimg_library::cimg::type< long >::min
static long min()
Definition: CImg.h:2184

cimg_library::cimg::info
void info()
Print informations about CImg environement variables.
Definition: CImg.h:5702

cimg_library::CImg::get_elevation3d
CImg< floatT > get_elevation3d(CImgList< tf > &primitives, CImgList< tc > &colors, const CImg< te > &elevation) const
Create and return a 3D elevation of the instance image.
Definition: CImg.h:21187

cimg_library::CImg::get_resize_object3d
CImg< Tfloat > get_resize_object3d() const
Definition: CImg.h:21137

cimg_library::CImg::draw_fill
CImg< T > & draw_fill(const int x, const int y, const int z, const CImg< tc > &color, const float opacity, CImg< t > &region, const float sigma=0, const bool high_connexity=false)
Draw a 3D filled region starting from a point (x,y,\ z) in the instance image.
Definition: CImg.h:27112

cimg_library::cimg::type< unsigned short >::is_float
static bool is_float()
Definition: CImg.h:2138

cimg_library::CImg::draw_text
CImg< T > & draw_text(const int x0, const int y0, const char *const text, const CImg< tc1 > &foreground_color, const CImg< tc2 > &background_color, const float opacity=1, const unsigned int font_size=11,...)
Draw a text.
Definition: CImg.h:26400

cimg_library::CImgDisplay::is_keyS
volatile bool is_keyS
Definition: CImg.h:6218

cimg_library::CImg::get_distance_hamilton
CImg< Tfloat > get_distance_hamilton(const unsigned int nb_iter, const float band_size=0, const float precision=0.5f) const
Definition: CImg.h:20590

cimg_library::CImg::get_sort
CImg< T > get_sort(CImg< t > &permutations, const bool increasing=true) const
Definition: CImg.h:13779

cimg_library::CImgDisplay::wait
static void wait(CImgDisplay &disp1, CImgDisplay &disp2, CImgDisplay &disp3)
Wait for any event occuring either on the display disp1, disp2 or disp3.
Definition: CImg.h:6894

cimg_library::CImgList::operator[]
CImg< T > & operator[](const unsigned int pos)
Return a reference to the i-th element of the image list.
Definition: CImg.h:34346

cimg_library::CImg::get_haar
CImg< Tfloat > get_haar(const bool invert=false, const unsigned int nb_scales=1) const
Definition: CImg.h:20733

cimg_library::CImg::get_dijkstra
CImg< T > get_dijkstra(const unsigned int starting_node, const unsigned int ending_node, CImg< t > &previous) const
Definition: CImg.h:14116

cimg_library::CImg::contains
bool contains(const T &pixel, t &x, t &y) const
Return true if specified referenced value is inside image boundaries. If true, returns pixel coordina...
Definition: CImg.h:12085

_cimg_for_triangle5
#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: CImg.h:23686

cimg_library::CImgList::CImgList
CImgList(const CImgList< T > &list)
Definition: CImg.h:34105

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const CImg< t > &tensor, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw an outlined ellipse.
Definition: CImg.h:26098

cimg_library::CImg::get_round
CImg< T > get_round(const float x, const unsigned int rounding_type=0) const
Definition: CImg.h:14981

cimg_library::CImg::solve_tridiagonal
CImg< T > & solve_tridiagonal(const CImg< t > &a, const CImg< t > &b, const CImg< t > &c)
Solve a linear system AX=B where B=*this and A is a tridiagonal matrix A = [ b0,c0,0,...; a1,b1,c1,0,... ; ... ; ...,0,aN,bN ].
Definition: CImg.h:13629

cimg_library::CImg::kth_smallest
T kth_smallest(const unsigned int k) const
Return the kth smallest element of the image.
Definition: CImg.h:12981

cimg_library::cimg::superset< bool, double >::type
double type
Definition: CImg.h:2219

cimg_library::CImg::atan2
CImg< T > & atan2(const CImg< t > &img)
Compute the arc-tangent of each pixel.
Definition: CImg.h:12671

cimg_library::CImg::get_load_cimg
static CImg< T > get_load_cimg(std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1, const char axis='z', const char align='p')
Definition: CImg.h:30586

cimg_library::CImgList::allocated_width
unsigned int allocated_width
Allocation size of the list.
Definition: CImg.h:33886

cimg_library::CImg::get_div
CImg< _cimg_Tt > get_div(const CImg< t > &img) const
Definition: CImg.h:12717

cimg_library::CImg::draw_gaussian
CImg< T > & draw_gaussian(const float xc, const float yc, const CImg< t > &tensor, const CImg< tc > &color, const float opacity=1)
Draw an anisotropic 2D gaussian function.
Definition: CImg.h:27396

cimg_library::CImgList::Tushort
cimg::superset< T, unsigned short >::type Tushort
Definition: CImg.h:33904

cimg_library::CImg::_draw_text
CImg< T > & _draw_text(const int x0, const int y0, const char *const text, const tc1 *const foreground_color, const tc2 *const background_color, const float opacity, const CImgList< t > &font)
Definition: CImg.h:26435

cimg_library::cimg::type< unsigned long >::string
static const char * string()
Definition: CImg.h:2173

cimg_library::CImg::operator[]
T & operator[](const unsigned int off)
Fast access to pixel value for reading or writing, using an offset to the image pixel.
Definition: CImg.h:10405

cimg_library::CImgList::_atN
T & _atN(const int pos, const int x=0, const int y=0, const int z=0, const int v=0)
Definition: CImg.h:34703

cimg_library::CImg::draw_arrow
CImg< T > & draw_arrow(const int x0, const int y0, const int x1, const int y1, const CImg< tc > &color, const float opacity=1, const float angle=30, const float length=-10, const unsigned int pattern=~0U)
Draw a colored arrow in the instance image.
Definition: CImg.h:23081

cimg_forYZV
#define cimg_forYZV(img, y, z, v)
Definition: CImg.h:606

cimg_library::CImgList::contains
bool contains(const T &pixel, t &n, t &x, t &y) const
Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y).
Definition: CImg.h:34853

cimg_library::cimg::key1
const unsigned int key1
Definition: CImg.h:2685

cimg_library::CImg::is_sameXYV
bool is_sameXYV(const unsigned int dx, const unsigned int dy, const unsigned int dv) const
Return true if image (*this) has the specified width, height and depth.
Definition: CImg.h:12005

cimg_library::cimg::type< int >::string
static const char * string()
Definition: CImg.h:2164

cimg_library::CImg::operator~
CImg< T > operator~() const
Operator~().
Definition: CImg.h:10965

cimg_library::CImg::crop
CImg< T > & crop(const int x0, const int y0, const int z0, const int x1, const int y1, const int z1, const bool border_condition=false)
Get a rectangular part of the instance image.
Definition: CImg.h:18218

cimg_library::CImgDisplay::is_keyCTRLRIGHT
volatile bool is_keyCTRLRIGHT
Definition: CImg.h:6244

cimg_library::CImg::is_sameZV
bool is_sameZV(const unsigned int dz, const unsigned int dv) const
Return true if image (*this) has the specified depth and number of channels.
Definition: CImg.h:11983

cimg_library::CImgDisplay::is_keyT
volatile bool is_keyT
Definition: CImg.h:6207

cimg_library::cimg::keyF3
const unsigned int keyF3
Definition: CImg.h:2674

cimg_library::CImg::load_magick
CImg< T > & load_magick(const char *const filename)
Load an image from a file, using Magick++ library.
Definition: CImg.h:29585

cimg_library::CImg::get_RGBtoLab
CImg< Tfloat > get_RGBtoLab() const
Definition: CImg.h:16414

cimg_library::CImg::Tuint
cimg::superset< T, unsigned int >::type Tuint
Definition: CImg.h:9777

cimg_library::CImg::RGBtoHSL
CImg< T > & RGBtoHSL()
Convert color pixels from (R,G,B) to (H,S,L).
Definition: CImg.h:15870

cimg_library::cimg::keyDELETE
const unsigned int keyDELETE
Definition: CImg.h:2710

cimg_library::CImgList::operator=
CImgList< T > & operator=(const CImg< t > &img)
Operator=().
Definition: CImg.h:34394

cimg_library::CImg::draw_circle
CImg< T > & draw_circle(const int x0, const int y0, int radius, const CImg< tc > &color, const float opacity=1)
Draw a filled circle.
Definition: CImg.h:25899

cimg_library::CImg::cubic_atX
Tfloat cubic_atX(const float fx, const int y, const int z, const int v, const T out_val) const
Read a pixel value using cubic interpolation and Dirichlet boundary conditions (first coordinates)...
Definition: CImg.h:11697

cimg_library::CImgDisplay::fps_timer
unsigned long fps_timer
Definition: CImg.h:6268

cimg_library::CImgDisplay::is_keyMENU
volatile bool is_keyMENU
Definition: CImg.h:6243

cimg_library::CImgDisplay::assign
CImgDisplay & assign(const unsigned int dimw, const unsigned int dimh, const char *title=0, const unsigned int normalization_type=3, const bool fullscreen_flag=false, const bool closed_flag=false)
In-place version of the previous constructor.
Definition: CImg.h:6393

cimg_library::cimg::keyCTRLRIGHT
const unsigned int keyCTRLRIGHT
Definition: CImg.h:2741

cimg_library::CImgList::Tulong
cimg::superset< T, unsigned long >::type Tulong
Definition: CImg.h:33908

cimg_library::CImg::rotate
CImg< T > & rotate(const float angle, const unsigned int border_conditions=3, const unsigned int interpolation=1)
Rotate an image.
Definition: CImg.h:17637

cimg_for_inXY
#define cimg_for_inXY(img, x0, y0, x1, y1, x, y)
Definition: CImg.h:615

cimg_library::CImgDisplay::is_keyH
volatile bool is_keyH
Definition: CImg.h:6222

cimg_library::cimg::type< char >::format
static int format(const char val)
Definition: CImg.h:2124

cimg_library::CImg::_cimg_math_parser::eval
double eval(const CImg< t > &img, const double x, const double y, const double z, const double v)
Definition: CImg.h:12423

cimg_library::CImgList::CImgList
CImgList(const unsigned int n)
Construct an image list containing n empty images.
Definition: CImg.h:33975

cimg_library::CImg::_save_pandore_header_length
unsigned int _save_pandore_header_length(unsigned int id, unsigned int *dims, const unsigned int colorspace) const
Definition: CImg.h:33372

cimg_library::CImg::_draw_spline
CImg< T > & _draw_spline(const tp &points, const tt &tangents, const unsigned int W, const unsigned int H, const tc *const color, const float opacity, const bool close_set, const float precision, const unsigned int pattern, const bool init_hatch)
Definition: CImg.h:23285

cimg_library::CImgList::end
const_iterator end() const
Definition: CImg.h:34521

cimg_library::CImg::FFT
static void FFT(CImg< T > &real, CImg< T > &imag, const char axis, const bool invert=false)
Compute a 1D Fast Fourier Transform, along a specified axis.
Definition: CImg.h:20832

cimg_forXZ
#define cimg_forXZ(img, x, z)
Definition: CImg.h:598

cimg_library::CImg::is_sameXZ
bool is_sameXZ(const CImg< t > &img) const
Return true if images have same width and same depth.
Definition: CImg.h:11945

cimg_library::CImg::log
CImg< T > & log()
Compute the log of each each pixel value.
Definition: CImg.h:12550

cimg_library::CImg::get_load_ascii
static CImg< T > get_load_ascii(std::FILE *const file)
Definition: CImg.h:29279

cimg_library::CImg::_marching2d_func_expr::operator()
float operator()(const float x, const float y) const
Definition: CImg.h:21450

cimg_library::CImg::get_symmetric_eigen
CImgList< Tfloat > get_symmetric_eigen() const
Definition: CImg.h:13760

cimg_library::CImgList::load_yuv
CImgList< T > & load_yuv(std::FILE *const file, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
Load an image sequence from a YUV file.
Definition: CImg.h:35890

cimg_library::cimg::type< unsigned char >::min
static unsigned char min()
Definition: CImg.h:2112

cimg_library::CImgDisplay::is_keyARROWDOWN
volatile bool is_keyARROWDOWN
Definition: CImg.h:6246

cimg_library::CImg::front
T & front()
Definition: CImg.h:11174

cimg_library::CImg::get_RGBtoBayer
CImg< T > get_RGBtoBayer() const
Definition: CImg.h:16471

cimg_library::CImgList::font
static CImgList< T > font(const unsigned int font_width, const bool variable_size=true)
Return a CImg pre-defined font with desired size.
Definition: CImg.h:37048

cimg_library::CImg::value_type
T value_type
Value type.
Definition: CImg.h:9769

cimg_library::CImgList::insert
CImgList< T > & insert(const unsigned int n, const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false)
Insert n copies of the list list at position pos of the current list.
Definition: CImg.h:35160

cimg_library::CImg::draw_image
CImg< T > & draw_image(const int x0, const CImg< ti > &sprite, const CImg< tm > &mask, const float opacity=1, const float mask_valmax=1)
Draw an image.
Definition: CImg.h:26313

cimg_library::CImg::get_lines
CImg< T > get_lines(const unsigned int y0, const unsigned int y1) const
Definition: CImg.h:18434

cimg_library::CImg::_save_inr
const CImg< T > & _save_inr(std::FILE *const file, const char *const filename, const float *const voxsize) const
Definition: CImg.h:33328

cimg_library::CImg::distance_hamilton
CImg< T > & distance_hamilton(const unsigned int nb_iter, const float band_size=0, const float precision=0.5f)
Compute distance function from 0-valued isophotes by the application of an Hamilton-Jacobi PDE...
Definition: CImg.h:20547

cimg_library::CImg::draw_ellipse
CImg< T > & draw_ellipse(const int x0, const int y0, const CImg< t > &tensor, const tc *const color, const float opacity=1)
Draw a filled ellipse.
Definition: CImg.h:26038

cimg_library::CImg::atX
T atX(const int x, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:11340

cimg_library::CImg::operator&=
CImg< T > & operator&=(const char *const expression)
Operator&amp;=().
Definition: CImg.h:10837

cimg_library::CImgList::transfer_to
CImgList< t > & transfer_to(CImgList< t > &list, const unsigned int pos)
Definition: CImg.h:34315

cimg_library::CImg::_cubic_atX
Tfloat _cubic_atX(const float fx, const int y=0, const int z=0, const int v=0) const
Definition: CImg.h:11722

cimg_library::CImg::load_cimg
CImg< T > & load_cimg(const char *const filename, const char axis='z', const char align='p')
Load an image (list) from a .cimg file.
Definition: CImg.h:30531

cimg_library::CImg::CImg
CImg(const CImg< t > &img, const char *const dimensions, const char *const values, const bool repeat_values)
Construct an image using dimensions of another image, and fill it with given values.
Definition: CImg.h:10066

cimg_library::CImgException
Instances of this class are thrown when errors occur during a CImg library function call...
Definition: CImg.h:2020

cimg_library::CImg::get_translate_object3d
CImg< Tfloat > get_translate_object3d() const
Definition: CImg.h:21102

cimg_library::CImg::cubic_atX
Tfloat cubic_atX(const float fx, const int y=0, const int z=0, const int v=0) const
Read a pixel value using cubic interpolation and Neumann boundary conditions (first coordinates)...
Definition: CImg.h:11715

cimg_library::CImg::asin
CImg< T > & asin()
Compute the arc-sinus of each pixel value.
Definition: CImg.h:12650

cimg_library::cimg::superset3::type
superset< t1, typename superset2< t2, t3, t4 >::type >::type type
Definition: CImg.h:2295

_cimg_get_label_test
#define _cimg_get_label_test(p, q)

cimg_library::sqr
CImg< _cimg_Tfloat > sqr(const CImg< T > &instance)
Definition: CImg.h:6006

cimg_library::CImgList::dimx
int dimx() const
Return the size of the list.
Definition: CImg.h:34465

cimg_library::CImg::is_sameX
bool is_sameX(const unsigned int dx) const
Return true if image (*this) has the specified width.
Definition: CImg.h:11869

_cimg_fopcode0
#define _cimg_fopcode0(op)
Definition: CImg.h:12225

cimg_library::CImgList::push_front
CImgList< T > & push_front(const CImgList< t > &list)
Insert list list at the front of the current list (STL-compliant name).
Definition: CImg.h:35422

cimg_library::CImg::get_blur_patch
CImg< T > get_blur_patch(const float sigma_s, const float sigma_p, const unsigned int patch_size=3, const unsigned int lookup_size=4, const float smoothness=0, const bool fast_approx=true) const
Definition: CImg.h:19638

cimg_library::cimg::keyPAUSE
const unsigned int keyPAUSE
Definition: CImg.h:2684

cimg_library::CImg::draw_polygon
CImg< T > & draw_polygon(const CImg< t > &points, const CImg< tc > &color, const float opacity, const unsigned int pattern)
Draw a polygon outline.
Definition: CImg.h:25852

cimg_library::CImg::sequence
CImg< T > & sequence(const T a0, const T a1)
Return a N-numbered sequence vector from a0 to a1.
Definition: CImg.h:13425

cimg_library::CImg::RGBtoXYZ
CImg< T > & RGBtoXYZ()
Convert color pixels from (R,G,B) to (X,Y,Z)_709.
Definition: CImg.h:16239

cimg_library::CImg::dimv
int dimv() const
Return the number of vector channels of the instance image (size along the V-axis).
Definition: CImg.h:11061

cimg_library::cimg::xln
int xln(const int x)
Return 1 + log_10(x).
Definition: CImg.h:4722

cimg_library::CImg::get_load_png
static CImg< T > get_load_png(const char *const filename)
Definition: CImg.h:29655

cimg_library::CImg::resize_halfXY
CImg< T > & resize_halfXY()
Half-resize an image, using a special optimized filter.
Definition: CImg.h:17011