codebase / stimlib

Commit 8718a1a02f0cd15cc633b4a3bc29bdb501354840

Authored by David Mayerich
1 parent 6691c66c

moved back to CImg

Showing 2 changed files with 62441 additions and 165 deletions   Show diff stats
Inline Side-by-side
stim/image/CImg.h 0 → 100644
  Show/Hide comments   View file @8718a1a
Changes suppressed. Click to show
  1 +/*
  2 + #
  3 + # File : CImg.h
  4 + # ( C++ header file )
  5 + #
  6 + # Description : The C++ Template Image Processing Toolkit.
  7 + # This file is the main component of the CImg Library project.
  8 + # ( http://cimg.eu )
  9 + #
  10 + # Project manager : David Tschumperle.
  11 + # ( http://tschumperle.users.greyc.fr/ )
  12 + #
  13 + # A complete list of contributors is available in file 'README.txt'
  14 + # distributed within the CImg package.
  15 + #
  16 + # Licenses : This file is 'dual-licensed', you have to choose one
  17 + # of the two licenses below to apply.
  18 + #
  19 + # CeCILL-C
  20 + # The CeCILL-C license is close to the GNU LGPL.
  21 + # ( http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html )
  22 + #
  23 + # or CeCILL v2.1
  24 + # The CeCILL license is compatible with the GNU GPL.
  25 + # ( http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.html )
  26 + #
  27 + # This software is governed either by the CeCILL or the CeCILL-C license
  28 + # under French law and abiding by the rules of distribution of free software.
  29 + # You can use, modify and or redistribute the software under the terms of
  30 + # the CeCILL or CeCILL-C licenses as circulated by CEA, CNRS and INRIA
  31 + # at the following URL: "http://www.cecill.info".
  32 + #
  33 + # As a counterpart to the access to the source code and rights to copy,
  34 + # modify and redistribute granted by the license, users are provided only
  35 + # with a limited warranty and the software's author, the holder of the
  36 + # economic rights, and the successive licensors have only limited
  37 + # liability.
  38 + #
  39 + # In this respect, the user's attention is drawn to the risks associated
  40 + # with loading, using, modifying and/or developing or reproducing the
  41 + # software by the user in light of its specific status of free software,
  42 + # that may mean that it is complicated to manipulate, and that also
  43 + # therefore means that it is reserved for developers and experienced
  44 + # professionals having in-depth computer knowledge. Users are therefore
  45 + # encouraged to load and test the software's suitability as regards their
  46 + # requirements in conditions enabling the security of their systems and/or
  47 + # data to be ensured and, more generally, to use and operate it in the
  48 + # same conditions as regards security.
  49 + #
  50 + # The fact that you are presently reading this means that you have had
  51 + # knowledge of the CeCILL and CeCILL-C licenses and that you accept its terms.
  52 + #
  53 +*/
  54 +
  55 +// Set version number of the library.
  56 +#ifndef cimg_version
  57 +#define cimg_version 253
  58 +
  59 +/*-----------------------------------------------------------
  60 + #
  61 + # Test and possibly auto-set CImg configuration variables
  62 + # and include required headers.
  63 + #
  64 + # If you find that the default configuration variables are
  65 + # not adapted to your system, you can override their values
  66 + # before including the header file "CImg.h"
  67 + # (use the #define directive).
  68 + #
  69 + ------------------------------------------------------------*/
  70 +
  71 +// Include standard C++ headers.
  72 +// This is the minimal set of required headers to make CImg-based codes compile.
  73 +#include <cstdio>
  74 +#include <cstdlib>
  75 +#include <cstdarg>
  76 +#include <cstring>
  77 +#include <cmath>
  78 +#include <cfloat>
  79 +#include <climits>
  80 +#include <ctime>
  81 +#include <exception>
  82 +#include <algorithm>
  83 +
  84 +// Detect/configure OS variables.
  85 +//
  86 +// Define 'cimg_OS' to: '0' for an unknown OS (will try to minize library dependencies).
  87 +// '1' for a Unix-like OS (Linux, Solaris, BSD, MacOSX, Irix, ...).
  88 +// '2' for Microsoft Windows.
  89 +// (auto-detection is performed if 'cimg_OS' is not set by the user).
  90 +#ifndef cimg_OS
  91 +#if defined(unix) || defined(__unix) || defined(__unix__) \
  92 + || defined(linux) || defined(__linux) || defined(__linux__) \
  93 + || defined(sun) || defined(__sun) \
  94 + || defined(BSD) || defined(__OpenBSD__) || defined(__NetBSD__) \
  95 + || defined(__FreeBSD__) || defined (__DragonFly__) \
  96 + || defined(sgi) || defined(__sgi) \
  97 + || defined(__MACOSX__) || defined(__APPLE__) \
  98 + || defined(__CYGWIN__)
  99 +#define cimg_OS 1
  100 +#elif defined(_MSC_VER) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) \
  101 + || defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
  102 +#define cimg_OS 2
  103 +#else
  104 +#define cimg_OS 0
  105 +#endif
  106 +#elif !(cimg_OS==0 || cimg_OS==1 || cimg_OS==2)
  107 +#error CImg Library: Invalid configuration variable 'cimg_OS'.
  108 +#error (correct values are '0 = unknown OS', '1 = Unix-like OS', '2 = Microsoft Windows').
  109 +#endif
  110 +#ifndef cimg_date
  111 +#define cimg_date __DATE__
  112 +#endif
  113 +#ifndef cimg_time
  114 +#define cimg_time __TIME__
  115 +#endif
  116 +
  117 +// Disable silly warnings on some Microsoft VC++ compilers.
  118 +#ifdef _MSC_VER
  119 +#pragma warning(push)
  120 +#pragma warning(disable:4127)
  121 +#pragma warning(disable:4244)
  122 +#pragma warning(disable:4311)
  123 +#pragma warning(disable:4312)
  124 +#pragma warning(disable:4319)
  125 +#pragma warning(disable:4512)
  126 +#pragma warning(disable:4571)
  127 +#pragma warning(disable:4640)
  128 +#pragma warning(disable:4706)
  129 +#pragma warning(disable:4710)
  130 +#pragma warning(disable:4800)
  131 +#pragma warning(disable:4804)
  132 +#pragma warning(disable:4820)
  133 +#pragma warning(disable:4996)
  134 +
  135 +#ifndef _CRT_SECURE_NO_DEPRECATE
  136 +#define _CRT_SECURE_NO_DEPRECATE 1
  137 +#endif
  138 +#ifndef _CRT_SECURE_NO_WARNINGS
  139 +#define _CRT_SECURE_NO_WARNINGS 1
  140 +#endif
  141 +#ifndef _CRT_NONSTDC_NO_DEPRECATE
  142 +#define _CRT_NONSTDC_NO_DEPRECATE 1
  143 +#endif
  144 +#endif
  145 +
  146 +// Define correct string functions for each compiler and OS.
  147 +#if cimg_OS==2 && defined(_MSC_VER)
  148 +#define cimg_sscanf std::sscanf
  149 +#define cimg_sprintf std::sprintf
  150 +#define cimg_snprintf cimg::_snprintf
  151 +#define cimg_vsnprintf cimg::_vsnprintf
  152 +#else
  153 +#include <stdio.h>
  154 +#if defined(__MACOSX__) || defined(__APPLE__)
  155 +#define cimg_sscanf cimg::_sscanf
  156 +#define cimg_sprintf cimg::_sprintf
  157 +#define cimg_snprintf cimg::_snprintf
  158 +#define cimg_vsnprintf cimg::_vsnprintf
  159 +#else
  160 +#define cimg_sscanf std::sscanf
  161 +#define cimg_sprintf std::sprintf
  162 +#define cimg_snprintf snprintf
  163 +#define cimg_vsnprintf vsnprintf
  164 +#endif
  165 +#endif
  166 +
  167 +// Include OS-specific headers.
  168 +#if cimg_OS==1
  169 +#include <sys/types.h>
  170 +#include <sys/time.h>
  171 +#include <sys/stat.h>
  172 +#include <unistd.h>
  173 +#include <dirent.h>
  174 +#include <fnmatch.h>
  175 +#elif cimg_OS==2
  176 +#ifndef NOMINMAX
  177 +#define NOMINMAX
  178 +#endif
  179 +#ifndef WIN32_LEAN_AND_MEAN
  180 +#define WIN32_LEAN_AND_MEAN
  181 +#endif
  182 +#include <windows.h>
  183 +#ifndef _WIN32_IE
  184 +#define _WIN32_IE 0x0400
  185 +#endif
  186 +#include <shlobj.h>
  187 +#include <process.h>
  188 +#include <io.h>
  189 +#endif
  190 +
  191 +// Look for C++11 features.
  192 +#ifndef cimg_use_cpp11
  193 +#if __cplusplus>201100
  194 +#define cimg_use_cpp11 1
  195 +#else
  196 +#define cimg_use_cpp11 0
  197 +#endif
  198 +#endif
  199 +#if cimg_use_cpp11==1
  200 +#include <initializer_list>
  201 +#include <utility>
  202 +#endif
  203 +
  204 +// Convenient macro to define pragma
  205 +#ifdef _MSC_VER
  206 +#define cimg_pragma(x) __pragma(x)
  207 +#else
  208 +#define cimg_pragma(x) _Pragma(#x)
  209 +#endif
  210 +
  211 +// Define own types 'cimg_long/ulong' and 'cimg_int64/uint64' to ensure portability.
  212 +// ( constrained to 'sizeof(cimg_ulong/cimg_long) = sizeof(void*)' and 'sizeof(cimg_int64/cimg_uint64)=8' ).
  213 +#if cimg_OS==2
  214 +
  215 +#define cimg_uint64 unsigned __int64
  216 +#define cimg_int64 __int64
  217 +#define cimg_ulong UINT_PTR
  218 +#define cimg_long INT_PTR
  219 +#ifdef _MSC_VER
  220 +#define cimg_fuint64 "%I64u"
  221 +#define cimg_fint64 "%I64d"
  222 +#else
  223 +#define cimg_fuint64 "%llu"
  224 +#define cimg_fint64 "%lld"
  225 +#endif
  226 +
  227 +#else
  228 +
  229 +#if UINTPTR_MAX==0xffffffff || defined(__arm__) || defined(_M_ARM) || ((ULONG_MAX)==(UINT_MAX))
  230 +#define cimg_uint64 unsigned long long
  231 +#define cimg_int64 long long
  232 +#define cimg_fuint64 "%llu"
  233 +#define cimg_fint64 "%lld"
  234 +#else
  235 +#define cimg_uint64 unsigned long
  236 +#define cimg_int64 long
  237 +#define cimg_fuint64 "%lu"
  238 +#define cimg_fint64 "%ld"
  239 +#endif
  240 +
  241 +#if defined(__arm__) || defined(_M_ARM)
  242 +#define cimg_ulong unsigned long long
  243 +#define cimg_long long long
  244 +#else
  245 +#define cimg_ulong unsigned long
  246 +#define cimg_long long
  247 +#endif
  248 +
  249 +#endif
  250 +
  251 +// Configure filename separator.
  252 +//
  253 +// Filename separator is set by default to '/', except for Windows where it is '\'.
  254 +#ifndef cimg_file_separator
  255 +#if cimg_OS==2
  256 +#define cimg_file_separator '\\'
  257 +#else
  258 +#define cimg_file_separator '/'
  259 +#endif
  260 +#endif
  261 +
  262 +// Configure verbosity of output messages.
  263 +//
  264 +// Define 'cimg_verbosity' to: '0' to hide library messages (quiet mode).
  265 +// '1' to output library messages on the console.
  266 +// '2' to output library messages on a basic dialog window (default behavior).
  267 +// '3' to do as '1' + add extra warnings (may slow down the code!).
  268 +// '4' to do as '2' + add extra warnings (may slow down the code!).
  269 +//
  270 +// Define 'cimg_strict_warnings' to replace warning messages by exception throwns.
  271 +//
  272 +// Define 'cimg_use_vt100' to allow output of color messages on VT100-compatible terminals.
  273 +#ifndef cimg_verbosity
  274 +#if cimg_OS==2
  275 +#define cimg_verbosity 2
  276 +#else
  277 +#define cimg_verbosity 1
  278 +#endif
  279 +#elif !(cimg_verbosity==0 || cimg_verbosity==1 || cimg_verbosity==2 || cimg_verbosity==3 || cimg_verbosity==4)
  280 +#error CImg Library: Configuration variable 'cimg_verbosity' is badly defined.
  281 +#error (should be { 0=quiet | 1=console | 2=dialog | 3=console+warnings | 4=dialog+warnings }).
  282 +#endif
  283 +
  284 +// Configure display framework.
  285 +//
  286 +// Define 'cimg_display' to: '0' to disable display capabilities.
  287 +// '1' to use the X-Window framework (X11).
  288 +// '2' to use the Microsoft GDI32 framework.
  289 +#ifndef cimg_display
  290 +#if cimg_OS==0
  291 +#define cimg_display 0
  292 +#elif cimg_OS==1
  293 +#define cimg_display 1
  294 +#elif cimg_OS==2
  295 +#define cimg_display 2
  296 +#endif
  297 +#elif !(cimg_display==0 || cimg_display==1 || cimg_display==2)
  298 +#error CImg Library: Configuration variable 'cimg_display' is badly defined.
  299 +#error (should be { 0=none | 1=X-Window (X11) | 2=Microsoft GDI32 }).
  300 +#endif
  301 +
  302 +// Configure the 'abort' signal handler (does nothing by default).
  303 +// A typical signal handler can be defined in your own source like this:
  304 +// #define cimg_abort_test if (is_abort) throw CImgAbortException("")
  305 +//
  306 +// where 'is_abort' is a boolean variable defined somewhere in your code and reachable in the method.
  307 +// 'cimg_abort_test2' does the same but is called more often (in inner loops).
  308 +#if defined(cimg_abort_test) && defined(cimg_use_openmp)
  309 +
  310 +// Define abort macros to be used with OpenMP.
  311 +#ifndef _cimg_abort_init_omp
  312 +#define _cimg_abort_init_omp bool _cimg_abort_go_omp = true; cimg::unused(_cimg_abort_go_omp)
  313 +#endif
  314 +#ifndef _cimg_abort_try_omp
  315 +#define _cimg_abort_try_omp if (_cimg_abort_go_omp) try
  316 +#endif
  317 +#ifndef _cimg_abort_catch_omp
  318 +#define _cimg_abort_catch_omp catch (CImgAbortException&) { cimg_pragma(omp atomic) _cimg_abort_go_omp&=false; }
  319 +#endif
  320 +#ifdef cimg_abort_test2
  321 +#ifndef _cimg_abort_try_omp2
  322 +#define _cimg_abort_try_omp2 _cimg_abort_try_omp
  323 +#endif
  324 +#ifndef _cimg_abort_catch_omp2
  325 +#define _cimg_abort_catch_omp2 _cimg_abort_catch_omp
  326 +#endif
  327 +#ifndef _cimg_abort_catch_fill_omp
  328 +#define _cimg_abort_catch_fill_omp \
  329 + catch (CImgException& e) { cimg_pragma(omp critical(abort)) CImg<charT>::string(e._message).move_to(is_error); \
  330 + cimg_pragma(omp atomic) _cimg_abort_go_omp&=false; }
  331 +#endif
  332 +#endif
  333 +#endif
  334 +
  335 +#ifndef _cimg_abort_init_omp
  336 +#define _cimg_abort_init_omp
  337 +#endif
  338 +#ifndef _cimg_abort_try_omp
  339 +#define _cimg_abort_try_omp
  340 +#endif
  341 +#ifndef _cimg_abort_catch_omp
  342 +#define _cimg_abort_catch_omp
  343 +#endif
  344 +#ifndef _cimg_abort_try_omp2
  345 +#define _cimg_abort_try_omp2
  346 +#endif
  347 +#ifndef _cimg_abort_catch_omp2
  348 +#define _cimg_abort_catch_omp2
  349 +#endif
  350 +#ifndef _cimg_abort_catch_fill_omp
  351 +#define _cimg_abort_catch_fill_omp
  352 +#endif
  353 +#ifndef cimg_abort_init
  354 +#define cimg_abort_init
  355 +#endif
  356 +#ifndef cimg_abort_test
  357 +#define cimg_abort_test
  358 +#endif
  359 +#ifndef cimg_abort_test2
  360 +#define cimg_abort_test2
  361 +#endif
  362 +
  363 +// Include display-specific headers.
  364 +#if cimg_display==1
  365 +#include <X11/Xlib.h>
  366 +#include <X11/Xutil.h>
  367 +#include <X11/keysym.h>
  368 +#include <pthread.h>
  369 +#ifdef cimg_use_xshm
  370 +#include <sys/ipc.h>
  371 +#include <sys/shm.h>
  372 +#include <X11/extensions/XShm.h>
  373 +#endif
  374 +#ifdef cimg_use_xrandr
  375 +#include <X11/extensions/Xrandr.h>
  376 +#endif
  377 +#endif
  378 +#ifndef cimg_appname
  379 +#define cimg_appname "CImg"
  380 +#endif
  381 +
  382 +// Configure OpenCV support.
  383 +// (http://opencv.willowgarage.com/wiki/)
  384 +//
  385 +// Define 'cimg_use_opencv' to enable OpenCV support.
  386 +//
  387 +// OpenCV library may be used to access images from cameras
  388 +// (see method 'CImg<T>::load_camera()').
  389 +#ifdef cimg_use_opencv
  390 +#ifdef True
  391 +#undef True
  392 +#define _cimg_redefine_True
  393 +#endif
  394 +#ifdef False
  395 +#undef False
  396 +#define _cimg_redefine_False
  397 +#endif
  398 +#ifdef Status
  399 +#undef Status
  400 +#define _cimg_redefine_Status
  401 +#endif
  402 +#include <cstddef>
  403 +#include <opencv2/opencv.hpp>
  404 +#if CV_MAJOR_VERSION >=3
  405 +#define _cimg_fourcc cv::VideoWriter::fourcc
  406 +#else
  407 +#define _cimg_fourcc CV_FOURCC
  408 +#endif
  409 +#endif
  410 +
  411 +// Configure OpenMP support.
  412 +// (http://www.openmp.org)
  413 +//
  414 +// Define 'cimg_use_openmp' to enable OpenMP support (requires OpenMP 3.0+).
  415 +//
  416 +// OpenMP directives are used in many CImg functions to get
  417 +// advantages of multi-core CPUs.
  418 +#ifdef cimg_use_openmp
  419 +#include <omp.h>
  420 +#define cimg_pragma_openmp(p) cimg_pragma(omp p)
  421 +#else
  422 +#define cimg_pragma_openmp(p)
  423 +#endif
  424 +
  425 +// Configure LibPNG support.
  426 +// (http://www.libpng.org)
  427 +//
  428 +// Define 'cimg_use_png' to enable LibPNG support.
  429 +//
  430 +// PNG library may be used to get a native support of '.png' files.
  431 +// (see methods 'CImg<T>::{load,save}_png()'.
  432 +#ifdef cimg_use_png
  433 +extern "C" {
  434 +#include "png.h"
  435 +}
  436 +#endif
  437 +
  438 +// Configure LibJPEG support.
  439 +// (http://en.wikipedia.org/wiki/Libjpeg)
  440 +//
  441 +// Define 'cimg_use_jpeg' to enable LibJPEG support.
  442 +//
  443 +// JPEG library may be used to get a native support of '.jpg' files.
  444 +// (see methods 'CImg<T>::{load,save}_jpeg()').
  445 +#ifdef cimg_use_jpeg
  446 +extern "C" {
  447 +#include "jpeglib.h"
  448 +#include "setjmp.h"
  449 +}
  450 +#endif
  451 +
  452 +// Configure LibTIFF support.
  453 +// (http://www.libtiff.org)
  454 +//
  455 +// Define 'cimg_use_tiff' to enable LibTIFF support.
  456 +//
  457 +// TIFF library may be used to get a native support of '.tif' files.
  458 +// (see methods 'CImg[List]<T>::{load,save}_tiff()').
  459 +#ifdef cimg_use_tiff
  460 +extern "C" {
  461 +#define uint64 uint64_hack_
  462 +#define int64 int64_hack_
  463 +#include "tiffio.h"
  464 +#undef uint64
  465 +#undef int64
  466 +}
  467 +#endif
  468 +
  469 +// Configure LibMINC2 support.
  470 +// (http://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference)
  471 +//
  472 +// Define 'cimg_use_minc2' to enable LibMINC2 support.
  473 +//
  474 +// MINC2 library may be used to get a native support of '.mnc' files.
  475 +// (see methods 'CImg<T>::{load,save}_minc2()').
  476 +#ifdef cimg_use_minc2
  477 +#include "minc_io_simple_volume.h"
  478 +#include "minc_1_simple.h"
  479 +#include "minc_1_simple_rw.h"
  480 +#endif
  481 +
  482 +// Configure Zlib support.
  483 +// (http://www.zlib.net)
  484 +//
  485 +// Define 'cimg_use_zlib' to enable Zlib support.
  486 +//
  487 +// Zlib library may be used to allow compressed data in '.cimgz' files
  488 +// (see methods 'CImg[List]<T>::{load,save}_cimg()').
  489 +#ifdef cimg_use_zlib
  490 +extern "C" {
  491 +#include "zlib.h"
  492 +}
  493 +#endif
  494 +
  495 +// Configure libcurl support.
  496 +// (http://curl.haxx.se/libcurl/)
  497 +//
  498 +// Define 'cimg_use_curl' to enable libcurl support.
  499 +//
  500 +// Libcurl may be used to get a native support of file downloading from the network.
  501 +// (see method 'cimg::load_network()'.)
  502 +#ifdef cimg_use_curl
  503 +#include "curl/curl.h"
  504 +#endif
  505 +
  506 +// Configure Magick++ support.
  507 +// (http://www.imagemagick.org/Magick++)
  508 +//
  509 +// Define 'cimg_use_magick' to enable Magick++ support.
  510 +//
  511 +// Magick++ library may be used to get a native support of various image file formats.
  512 +// (see methods 'CImg<T>::{load,save}()').
  513 +#ifdef cimg_use_magick
  514 +#include "Magick++.h"
  515 +#endif
  516 +
  517 +// Configure FFTW3 support.
  518 +// (http://www.fftw.org)
  519 +//
  520 +// Define 'cimg_use_fftw3' to enable libFFTW3 support.
  521 +//
  522 +// FFTW3 library may be used to efficiently compute the Fast Fourier Transform
  523 +// of image data, without restriction on the image size.
  524 +// (see method 'CImg[List]<T>::FFT()').
  525 +#ifdef cimg_use_fftw3
  526 +extern "C" {
  527 +#include "fftw3.h"
  528 +}
  529 +#endif
  530 +
  531 +// Configure LibBoard support.
  532 +// (http://libboard.sourceforge.net/)
  533 +//
  534 +// Define 'cimg_use_board' to enable Board support.
  535 +//
  536 +// Board library may be used to draw 3D objects in vector-graphics canvas
  537 +// that can be saved as '.ps' or '.svg' files afterwards.
  538 +// (see method 'CImg<T>::draw_object3d()').
  539 +#ifdef cimg_use_board
  540 +#include "Board.h"
  541 +#endif
  542 +
  543 +// Configure OpenEXR support.
  544 +// (http://www.openexr.com/)
  545 +//
  546 +// Define 'cimg_use_openexr' to enable OpenEXR support.
  547 +//
  548 +// OpenEXR library may be used to get a native support of '.exr' files.
  549 +// (see methods 'CImg<T>::{load,save}_exr()').
  550 +#ifdef cimg_use_openexr
  551 +#include "ImfRgbaFile.h"
  552 +#include "ImfInputFile.h"
  553 +#include "ImfChannelList.h"
  554 +#include "ImfMatrixAttribute.h"
  555 +#include "ImfArray.h"
  556 +#endif
  557 +
  558 +// Configure TinyEXR support.
  559 +// (https://github.com/syoyo/tinyexr)
  560 +//
  561 +// Define 'cimg_use_tinyexr' to enable TinyEXR support.
  562 +//
  563 +// TinyEXR is a small, single header-only library to load and save OpenEXR(.exr) images.
  564 +#ifdef cimg_use_tinyexr
  565 +#ifndef TINYEXR_IMPLEMENTATION
  566 +#define TINYEXR_IMPLEMENTATION
  567 +#endif
  568 +#include "tinyexr.h"
  569 +#endif
  570 +
  571 +// Lapack configuration.
  572 +// (http://www.netlib.org/lapack)
  573 +//
  574 +// Define 'cimg_use_lapack' to enable LAPACK support.
  575 +//
  576 +// Lapack library may be used in several CImg methods to speed up
  577 +// matrix computations (eigenvalues, inverse, ...).
  578 +#ifdef cimg_use_lapack
  579 +extern "C" {
  580 + extern void sgetrf_(int*, int*, float*, int*, int*, int*);
  581 + extern void sgetri_(int*, float*, int*, int*, float*, int*, int*);
  582 + extern void sgetrs_(char*, int*, int*, float*, int*, int*, float*, int*, int*);
  583 + extern void sgesvd_(char*, char*, int*, int*, float*, int*, float*, float*, int*, float*, int*, float*, int*, int*);
  584 + extern void ssyev_(char*, char*, int*, float*, int*, float*, float*, int*, int*);
  585 + extern void dgetrf_(int*, int*, double*, int*, int*, int*);
  586 + extern void dgetri_(int*, double*, int*, int*, double*, int*, int*);
  587 + extern void dgetrs_(char*, int*, int*, double*, int*, int*, double*, int*, int*);
  588 + extern void dgesvd_(char*, char*, int*, int*, double*, int*, double*, double*,
  589 + int*, double*, int*, double*, int*, int*);
  590 + extern void dsyev_(char*, char*, int*, double*, int*, double*, double*, int*, int*);
  591 + extern void dgels_(char*, int*,int*,int*,double*,int*,double*,int*,double*,int*,int*);
  592 + extern void sgels_(char*, int*,int*,int*,float*,int*,float*,int*,float*,int*,int*);
  593 +}
  594 +#endif
  595 +
  596 +// Check if min/max/PI macros are defined.
  597 +//
  598 +// CImg does not compile if macros 'min', 'max' or 'PI' are defined,
  599 +// because it redefines functions min(), max() and const variable PI in the cimg:: namespace.
  600 +// so it '#undef' these macros if necessary, and restore them to reasonable
  601 +// values at the end of this file.
  602 +#ifdef min
  603 +#undef min
  604 +#define _cimg_redefine_min
  605 +#endif
  606 +#ifdef max
  607 +#undef max
  608 +#define _cimg_redefine_max
  609 +#endif
  610 +#ifdef PI
  611 +#undef PI
  612 +#define _cimg_redefine_PI
  613 +#endif
  614 +
  615 +// Define 'cimg_library' namespace suffix.
  616 +//
  617 +// You may want to add a suffix to the 'cimg_library' namespace, for instance if you need to work
  618 +// with several versions of the library at the same time.
  619 +#ifdef cimg_namespace_suffix
  620 +#define __cimg_library_suffixed(s) cimg_library_##s
  621 +#define _cimg_library_suffixed(s) __cimg_library_suffixed(s)
  622 +#define cimg_library_suffixed _cimg_library_suffixed(cimg_namespace_suffix)
  623 +#else
  624 +#define cimg_library_suffixed cimg_library
  625 +#endif
  626 +
  627 +/*------------------------------------------------------------------------------
  628 + #
  629 + # Define user-friendly macros.
  630 + #
  631 + # These CImg macros are prefixed by 'cimg_' and can be used safely in your own
  632 + # code. They are useful to parse command line options, or to write image loops.
  633 + #
  634 + ------------------------------------------------------------------------------*/
  635 +
  636 +// Macros to define program usage, and retrieve command line arguments.
  637 +#define cimg_usage(usage) cimg_library_suffixed::cimg::option((char*)0,argc,argv,(char*)0,usage,false)
  638 +#define cimg_help(str) cimg_library_suffixed::cimg::option((char*)0,argc,argv,str,(char*)0)
  639 +#define cimg_option(name,defaut,usage) cimg_library_suffixed::cimg::option(name,argc,argv,defaut,usage)
  640 +
  641 +// Macros to define and manipulate local neighborhoods.
  642 +#define CImg_2x2(I,T) T I[4]; \
  643 + T& I##cc = I[0]; T& I##nc = I[1]; \
  644 + T& I##cn = I[2]; T& I##nn = I[3]; \
  645 + I##cc = I##nc = \
  646 + I##cn = I##nn = 0
  647 +
  648 +#define CImg_3x3(I,T) T I[9]; \
  649 + T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; \
  650 + T& I##pc = I[3]; T& I##cc = I[4]; T& I##nc = I[5]; \
  651 + T& I##pn = I[6]; T& I##cn = I[7]; T& I##nn = I[8]; \
  652 + I##pp = I##cp = I##np = \
  653 + I##pc = I##cc = I##nc = \
  654 + I##pn = I##cn = I##nn = 0
  655 +
  656 +#define CImg_4x4(I,T) T I[16]; \
  657 + T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; T& I##ap = I[3]; \
  658 + T& I##pc = I[4]; T& I##cc = I[5]; T& I##nc = I[6]; T& I##ac = I[7]; \
  659 + T& I##pn = I[8]; T& I##cn = I[9]; T& I##nn = I[10]; T& I##an = I[11]; \
  660 + T& I##pa = I[12]; T& I##ca = I[13]; T& I##na = I[14]; T& I##aa = I[15]; \
  661 + I##pp = I##cp = I##np = I##ap = \
  662 + I##pc = I##cc = I##nc = I##ac = \
  663 + I##pn = I##cn = I##nn = I##an = \
  664 + I##pa = I##ca = I##na = I##aa = 0
  665 +
  666 +#define CImg_5x5(I,T) T I[25]; \
  667 + 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]; \
  668 + 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]; \
  669 + 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]; \
  670 + 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]; \
  671 + 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]; \
  672 + I##bb = I##pb = I##cb = I##nb = I##ab = \
  673 + I##bp = I##pp = I##cp = I##np = I##ap = \
  674 + I##bc = I##pc = I##cc = I##nc = I##ac = \
  675 + I##bn = I##pn = I##cn = I##nn = I##an = \
  676 + I##ba = I##pa = I##ca = I##na = I##aa = 0
  677 +
  678 +#define CImg_2x2x2(I,T) T I[8]; \
  679 + T& I##ccc = I[0]; T& I##ncc = I[1]; \
  680 + T& I##cnc = I[2]; T& I##nnc = I[3]; \
  681 + T& I##ccn = I[4]; T& I##ncn = I[5]; \
  682 + T& I##cnn = I[6]; T& I##nnn = I[7]; \
  683 + I##ccc = I##ncc = \
  684 + I##cnc = I##nnc = \
  685 + I##ccn = I##ncn = \
  686 + I##cnn = I##nnn = 0
  687 +
  688 +#define CImg_3x3x3(I,T) T I[27]; \
  689 + T& I##ppp = I[0]; T& I##cpp = I[1]; T& I##npp = I[2]; \
  690 + T& I##pcp = I[3]; T& I##ccp = I[4]; T& I##ncp = I[5]; \
  691 + T& I##pnp = I[6]; T& I##cnp = I[7]; T& I##nnp = I[8]; \
  692 + T& I##ppc = I[9]; T& I##cpc = I[10]; T& I##npc = I[11]; \
  693 + T& I##pcc = I[12]; T& I##ccc = I[13]; T& I##ncc = I[14]; \
  694 + T& I##pnc = I[15]; T& I##cnc = I[16]; T& I##nnc = I[17]; \
  695 + T& I##ppn = I[18]; T& I##cpn = I[19]; T& I##npn = I[20]; \
  696 + T& I##pcn = I[21]; T& I##ccn = I[22]; T& I##ncn = I[23]; \
  697 + T& I##pnn = I[24]; T& I##cnn = I[25]; T& I##nnn = I[26]; \
  698 + I##ppp = I##cpp = I##npp = \
  699 + I##pcp = I##ccp = I##ncp = \
  700 + I##pnp = I##cnp = I##nnp = \
  701 + I##ppc = I##cpc = I##npc = \
  702 + I##pcc = I##ccc = I##ncc = \
  703 + I##pnc = I##cnc = I##nnc = \
  704 + I##ppn = I##cpn = I##npn = \
  705 + I##pcn = I##ccn = I##ncn = \
  706 + I##pnn = I##cnn = I##nnn = 0
  707 +
  708 +#define cimg_get2x2(img,x,y,z,c,I,T) \
  709 + I[0] = (T)(img)(x,y,z,c), I[1] = (T)(img)(_n1##x,y,z,c), I[2] = (T)(img)(x,_n1##y,z,c), \
  710 + I[3] = (T)(img)(_n1##x,_n1##y,z,c)
  711 +
  712 +#define cimg_get3x3(img,x,y,z,c,I,T) \
  713 + I[0] = (T)(img)(_p1##x,_p1##y,z,c), I[1] = (T)(img)(x,_p1##y,z,c), I[2] = (T)(img)(_n1##x,_p1##y,z,c), \
  714 + I[3] = (T)(img)(_p1##x,y,z,c), I[4] = (T)(img)(x,y,z,c), I[5] = (T)(img)(_n1##x,y,z,c), \
  715 + I[6] = (T)(img)(_p1##x,_n1##y,z,c), I[7] = (T)(img)(x,_n1##y,z,c), I[8] = (T)(img)(_n1##x,_n1##y,z,c)
  716 +
  717 +#define cimg_get4x4(img,x,y,z,c,I,T) \
  718 + I[0] = (T)(img)(_p1##x,_p1##y,z,c), I[1] = (T)(img)(x,_p1##y,z,c), I[2] = (T)(img)(_n1##x,_p1##y,z,c), \
  719 + I[3] = (T)(img)(_n2##x,_p1##y,z,c), I[4] = (T)(img)(_p1##x,y,z,c), I[5] = (T)(img)(x,y,z,c), \
  720 + I[6] = (T)(img)(_n1##x,y,z,c), I[7] = (T)(img)(_n2##x,y,z,c), I[8] = (T)(img)(_p1##x,_n1##y,z,c), \
  721 + I[9] = (T)(img)(x,_n1##y,z,c), I[10] = (T)(img)(_n1##x,_n1##y,z,c), I[11] = (T)(img)(_n2##x,_n1##y,z,c), \
  722 + I[12] = (T)(img)(_p1##x,_n2##y,z,c), I[13] = (T)(img)(x,_n2##y,z,c), I[14] = (T)(img)(_n1##x,_n2##y,z,c), \
  723 + I[15] = (T)(img)(_n2##x,_n2##y,z,c)
  724 +
  725 +#define cimg_get5x5(img,x,y,z,c,I,T) \
  726 + I[0] = (T)(img)(_p2##x,_p2##y,z,c), I[1] = (T)(img)(_p1##x,_p2##y,z,c), I[2] = (T)(img)(x,_p2##y,z,c), \
  727 + I[3] = (T)(img)(_n1##x,_p2##y,z,c), I[4] = (T)(img)(_n2##x,_p2##y,z,c), I[5] = (T)(img)(_p2##x,_p1##y,z,c), \
  728 + I[6] = (T)(img)(_p1##x,_p1##y,z,c), I[7] = (T)(img)(x,_p1##y,z,c), I[8] = (T)(img)(_n1##x,_p1##y,z,c), \
  729 + I[9] = (T)(img)(_n2##x,_p1##y,z,c), I[10] = (T)(img)(_p2##x,y,z,c), I[11] = (T)(img)(_p1##x,y,z,c), \
  730 + I[12] = (T)(img)(x,y,z,c), I[13] = (T)(img)(_n1##x,y,z,c), I[14] = (T)(img)(_n2##x,y,z,c), \
  731 + I[15] = (T)(img)(_p2##x,_n1##y,z,c), I[16] = (T)(img)(_p1##x,_n1##y,z,c), I[17] = (T)(img)(x,_n1##y,z,c), \
  732 + I[18] = (T)(img)(_n1##x,_n1##y,z,c), I[19] = (T)(img)(_n2##x,_n1##y,z,c), I[20] = (T)(img)(_p2##x,_n2##y,z,c), \
  733 + I[21] = (T)(img)(_p1##x,_n2##y,z,c), I[22] = (T)(img)(x,_n2##y,z,c), I[23] = (T)(img)(_n1##x,_n2##y,z,c), \
  734 + I[24] = (T)(img)(_n2##x,_n2##y,z,c)
  735 +
  736 +#define cimg_get6x6(img,x,y,z,c,I,T) \
  737 + I[0] = (T)(img)(_p2##x,_p2##y,z,c), I[1] = (T)(img)(_p1##x,_p2##y,z,c), I[2] = (T)(img)(x,_p2##y,z,c), \
  738 + I[3] = (T)(img)(_n1##x,_p2##y,z,c), I[4] = (T)(img)(_n2##x,_p2##y,z,c), I[5] = (T)(img)(_n3##x,_p2##y,z,c), \
  739 + I[6] = (T)(img)(_p2##x,_p1##y,z,c), I[7] = (T)(img)(_p1##x,_p1##y,z,c), I[8] = (T)(img)(x,_p1##y,z,c), \
  740 + I[9] = (T)(img)(_n1##x,_p1##y,z,c), I[10] = (T)(img)(_n2##x,_p1##y,z,c), I[11] = (T)(img)(_n3##x,_p1##y,z,c), \
  741 + I[12] = (T)(img)(_p2##x,y,z,c), I[13] = (T)(img)(_p1##x,y,z,c), I[14] = (T)(img)(x,y,z,c), \
  742 + I[15] = (T)(img)(_n1##x,y,z,c), I[16] = (T)(img)(_n2##x,y,z,c), I[17] = (T)(img)(_n3##x,y,z,c), \
  743 + I[18] = (T)(img)(_p2##x,_n1##y,z,c), I[19] = (T)(img)(_p1##x,_n1##y,z,c), I[20] = (T)(img)(x,_n1##y,z,c), \
  744 + I[21] = (T)(img)(_n1##x,_n1##y,z,c), I[22] = (T)(img)(_n2##x,_n1##y,z,c), I[23] = (T)(img)(_n3##x,_n1##y,z,c), \
  745 + I[24] = (T)(img)(_p2##x,_n2##y,z,c), I[25] = (T)(img)(_p1##x,_n2##y,z,c), I[26] = (T)(img)(x,_n2##y,z,c), \
  746 + I[27] = (T)(img)(_n1##x,_n2##y,z,c), I[28] = (T)(img)(_n2##x,_n2##y,z,c), I[29] = (T)(img)(_n3##x,_n2##y,z,c), \
  747 + I[30] = (T)(img)(_p2##x,_n3##y,z,c), I[31] = (T)(img)(_p1##x,_n3##y,z,c), I[32] = (T)(img)(x,_n3##y,z,c), \
  748 + I[33] = (T)(img)(_n1##x,_n3##y,z,c), I[34] = (T)(img)(_n2##x,_n3##y,z,c), I[35] = (T)(img)(_n3##x,_n3##y,z,c)
  749 +
  750 +#define cimg_get7x7(img,x,y,z,c,I,T) \
  751 + I[0] = (T)(img)(_p3##x,_p3##y,z,c), I[1] = (T)(img)(_p2##x,_p3##y,z,c), I[2] = (T)(img)(_p1##x,_p3##y,z,c), \
  752 + I[3] = (T)(img)(x,_p3##y,z,c), I[4] = (T)(img)(_n1##x,_p3##y,z,c), I[5] = (T)(img)(_n2##x,_p3##y,z,c), \
  753 + I[6] = (T)(img)(_n3##x,_p3##y,z,c), I[7] = (T)(img)(_p3##x,_p2##y,z,c), I[8] = (T)(img)(_p2##x,_p2##y,z,c), \
  754 + I[9] = (T)(img)(_p1##x,_p2##y,z,c), I[10] = (T)(img)(x,_p2##y,z,c), I[11] = (T)(img)(_n1##x,_p2##y,z,c), \
  755 + I[12] = (T)(img)(_n2##x,_p2##y,z,c), I[13] = (T)(img)(_n3##x,_p2##y,z,c), I[14] = (T)(img)(_p3##x,_p1##y,z,c), \
  756 + I[15] = (T)(img)(_p2##x,_p1##y,z,c), I[16] = (T)(img)(_p1##x,_p1##y,z,c), I[17] = (T)(img)(x,_p1##y,z,c), \
  757 + I[18] = (T)(img)(_n1##x,_p1##y,z,c), I[19] = (T)(img)(_n2##x,_p1##y,z,c), I[20] = (T)(img)(_n3##x,_p1##y,z,c), \
  758 + I[21] = (T)(img)(_p3##x,y,z,c), I[22] = (T)(img)(_p2##x,y,z,c), I[23] = (T)(img)(_p1##x,y,z,c), \
  759 + I[24] = (T)(img)(x,y,z,c), I[25] = (T)(img)(_n1##x,y,z,c), I[26] = (T)(img)(_n2##x,y,z,c), \
  760 + I[27] = (T)(img)(_n3##x,y,z,c), I[28] = (T)(img)(_p3##x,_n1##y,z,c), I[29] = (T)(img)(_p2##x,_n1##y,z,c), \
  761 + I[30] = (T)(img)(_p1##x,_n1##y,z,c), I[31] = (T)(img)(x,_n1##y,z,c), I[32] = (T)(img)(_n1##x,_n1##y,z,c), \
  762 + I[33] = (T)(img)(_n2##x,_n1##y,z,c), I[34] = (T)(img)(_n3##x,_n1##y,z,c), I[35] = (T)(img)(_p3##x,_n2##y,z,c), \
  763 + I[36] = (T)(img)(_p2##x,_n2##y,z,c), I[37] = (T)(img)(_p1##x,_n2##y,z,c), I[38] = (T)(img)(x,_n2##y,z,c), \
  764 + I[39] = (T)(img)(_n1##x,_n2##y,z,c), I[40] = (T)(img)(_n2##x,_n2##y,z,c), I[41] = (T)(img)(_n3##x,_n2##y,z,c), \
  765 + I[42] = (T)(img)(_p3##x,_n3##y,z,c), I[43] = (T)(img)(_p2##x,_n3##y,z,c), I[44] = (T)(img)(_p1##x,_n3##y,z,c), \
  766 + I[45] = (T)(img)(x,_n3##y,z,c), I[46] = (T)(img)(_n1##x,_n3##y,z,c), I[47] = (T)(img)(_n2##x,_n3##y,z,c), \
  767 + I[48] = (T)(img)(_n3##x,_n3##y,z,c)
  768 +
  769 +#define cimg_get8x8(img,x,y,z,c,I,T) \
  770 + I[0] = (T)(img)(_p3##x,_p3##y,z,c), I[1] = (T)(img)(_p2##x,_p3##y,z,c), I[2] = (T)(img)(_p1##x,_p3##y,z,c), \
  771 + I[3] = (T)(img)(x,_p3##y,z,c), I[4] = (T)(img)(_n1##x,_p3##y,z,c), I[5] = (T)(img)(_n2##x,_p3##y,z,c), \
  772 + I[6] = (T)(img)(_n3##x,_p3##y,z,c), I[7] = (T)(img)(_n4##x,_p3##y,z,c), I[8] = (T)(img)(_p3##x,_p2##y,z,c), \
  773 + I[9] = (T)(img)(_p2##x,_p2##y,z,c), I[10] = (T)(img)(_p1##x,_p2##y,z,c), I[11] = (T)(img)(x,_p2##y,z,c), \
  774 + I[12] = (T)(img)(_n1##x,_p2##y,z,c), I[13] = (T)(img)(_n2##x,_p2##y,z,c), I[14] = (T)(img)(_n3##x,_p2##y,z,c), \
  775 + I[15] = (T)(img)(_n4##x,_p2##y,z,c), I[16] = (T)(img)(_p3##x,_p1##y,z,c), I[17] = (T)(img)(_p2##x,_p1##y,z,c), \
  776 + I[18] = (T)(img)(_p1##x,_p1##y,z,c), I[19] = (T)(img)(x,_p1##y,z,c), I[20] = (T)(img)(_n1##x,_p1##y,z,c), \
  777 + I[21] = (T)(img)(_n2##x,_p1##y,z,c), I[22] = (T)(img)(_n3##x,_p1##y,z,c), I[23] = (T)(img)(_n4##x,_p1##y,z,c), \
  778 + I[24] = (T)(img)(_p3##x,y,z,c), I[25] = (T)(img)(_p2##x,y,z,c), I[26] = (T)(img)(_p1##x,y,z,c), \
  779 + I[27] = (T)(img)(x,y,z,c), I[28] = (T)(img)(_n1##x,y,z,c), I[29] = (T)(img)(_n2##x,y,z,c), \
  780 + I[30] = (T)(img)(_n3##x,y,z,c), I[31] = (T)(img)(_n4##x,y,z,c), I[32] = (T)(img)(_p3##x,_n1##y,z,c), \
  781 + I[33] = (T)(img)(_p2##x,_n1##y,z,c), I[34] = (T)(img)(_p1##x,_n1##y,z,c), I[35] = (T)(img)(x,_n1##y,z,c), \
  782 + I[36] = (T)(img)(_n1##x,_n1##y,z,c), I[37] = (T)(img)(_n2##x,_n1##y,z,c), I[38] = (T)(img)(_n3##x,_n1##y,z,c), \
  783 + I[39] = (T)(img)(_n4##x,_n1##y,z,c), I[40] = (T)(img)(_p3##x,_n2##y,z,c), I[41] = (T)(img)(_p2##x,_n2##y,z,c), \
  784 + I[42] = (T)(img)(_p1##x,_n2##y,z,c), I[43] = (T)(img)(x,_n2##y,z,c), I[44] = (T)(img)(_n1##x,_n2##y,z,c), \
  785 + I[45] = (T)(img)(_n2##x,_n2##y,z,c), I[46] = (T)(img)(_n3##x,_n2##y,z,c), I[47] = (T)(img)(_n4##x,_n2##y,z,c), \
  786 + I[48] = (T)(img)(_p3##x,_n3##y,z,c), I[49] = (T)(img)(_p2##x,_n3##y,z,c), I[50] = (T)(img)(_p1##x,_n3##y,z,c), \
  787 + I[51] = (T)(img)(x,_n3##y,z,c), I[52] = (T)(img)(_n1##x,_n3##y,z,c), I[53] = (T)(img)(_n2##x,_n3##y,z,c), \
  788 + I[54] = (T)(img)(_n3##x,_n3##y,z,c), I[55] = (T)(img)(_n4##x,_n3##y,z,c), I[56] = (T)(img)(_p3##x,_n4##y,z,c), \
  789 + I[57] = (T)(img)(_p2##x,_n4##y,z,c), I[58] = (T)(img)(_p1##x,_n4##y,z,c), I[59] = (T)(img)(x,_n4##y,z,c), \
  790 + I[60] = (T)(img)(_n1##x,_n4##y,z,c), I[61] = (T)(img)(_n2##x,_n4##y,z,c), I[62] = (T)(img)(_n3##x,_n4##y,z,c), \
  791 + I[63] = (T)(img)(_n4##x,_n4##y,z,c);
  792 +
  793 +#define cimg_get9x9(img,x,y,z,c,I,T) \
  794 + I[0] = (T)(img)(_p4##x,_p4##y,z,c), I[1] = (T)(img)(_p3##x,_p4##y,z,c), I[2] = (T)(img)(_p2##x,_p4##y,z,c), \
  795 + I[3] = (T)(img)(_p1##x,_p4##y,z,c), I[4] = (T)(img)(x,_p4##y,z,c), I[5] = (T)(img)(_n1##x,_p4##y,z,c), \
  796 + I[6] = (T)(img)(_n2##x,_p4##y,z,c), I[7] = (T)(img)(_n3##x,_p4##y,z,c), I[8] = (T)(img)(_n4##x,_p4##y,z,c), \
  797 + I[9] = (T)(img)(_p4##x,_p3##y,z,c), I[10] = (T)(img)(_p3##x,_p3##y,z,c), I[11] = (T)(img)(_p2##x,_p3##y,z,c), \
  798 + I[12] = (T)(img)(_p1##x,_p3##y,z,c), I[13] = (T)(img)(x,_p3##y,z,c), I[14] = (T)(img)(_n1##x,_p3##y,z,c), \
  799 + I[15] = (T)(img)(_n2##x,_p3##y,z,c), I[16] = (T)(img)(_n3##x,_p3##y,z,c), I[17] = (T)(img)(_n4##x,_p3##y,z,c), \
  800 + I[18] = (T)(img)(_p4##x,_p2##y,z,c), I[19] = (T)(img)(_p3##x,_p2##y,z,c), I[20] = (T)(img)(_p2##x,_p2##y,z,c), \
  801 + I[21] = (T)(img)(_p1##x,_p2##y,z,c), I[22] = (T)(img)(x,_p2##y,z,c), I[23] = (T)(img)(_n1##x,_p2##y,z,c), \
  802 + I[24] = (T)(img)(_n2##x,_p2##y,z,c), I[25] = (T)(img)(_n3##x,_p2##y,z,c), I[26] = (T)(img)(_n4##x,_p2##y,z,c), \
  803 + I[27] = (T)(img)(_p4##x,_p1##y,z,c), I[28] = (T)(img)(_p3##x,_p1##y,z,c), I[29] = (T)(img)(_p2##x,_p1##y,z,c), \
  804 + I[30] = (T)(img)(_p1##x,_p1##y,z,c), I[31] = (T)(img)(x,_p1##y,z,c), I[32] = (T)(img)(_n1##x,_p1##y,z,c), \
  805 + I[33] = (T)(img)(_n2##x,_p1##y,z,c), I[34] = (T)(img)(_n3##x,_p1##y,z,c), I[35] = (T)(img)(_n4##x,_p1##y,z,c), \
  806 + I[36] = (T)(img)(_p4##x,y,z,c), I[37] = (T)(img)(_p3##x,y,z,c), I[38] = (T)(img)(_p2##x,y,z,c), \
  807 + I[39] = (T)(img)(_p1##x,y,z,c), I[40] = (T)(img)(x,y,z,c), I[41] = (T)(img)(_n1##x,y,z,c), \
  808 + I[42] = (T)(img)(_n2##x,y,z,c), I[43] = (T)(img)(_n3##x,y,z,c), I[44] = (T)(img)(_n4##x,y,z,c), \
  809 + I[45] = (T)(img)(_p4##x,_n1##y,z,c), I[46] = (T)(img)(_p3##x,_n1##y,z,c), I[47] = (T)(img)(_p2##x,_n1##y,z,c), \
  810 + I[48] = (T)(img)(_p1##x,_n1##y,z,c), I[49] = (T)(img)(x,_n1##y,z,c), I[50] = (T)(img)(_n1##x,_n1##y,z,c), \
  811 + I[51] = (T)(img)(_n2##x,_n1##y,z,c), I[52] = (T)(img)(_n3##x,_n1##y,z,c), I[53] = (T)(img)(_n4##x,_n1##y,z,c), \
  812 + I[54] = (T)(img)(_p4##x,_n2##y,z,c), I[55] = (T)(img)(_p3##x,_n2##y,z,c), I[56] = (T)(img)(_p2##x,_n2##y,z,c), \
  813 + I[57] = (T)(img)(_p1##x,_n2##y,z,c), I[58] = (T)(img)(x,_n2##y,z,c), I[59] = (T)(img)(_n1##x,_n2##y,z,c), \
  814 + I[60] = (T)(img)(_n2##x,_n2##y,z,c), I[61] = (T)(img)(_n3##x,_n2##y,z,c), I[62] = (T)(img)(_n4##x,_n2##y,z,c), \
  815 + I[63] = (T)(img)(_p4##x,_n3##y,z,c), I[64] = (T)(img)(_p3##x,_n3##y,z,c), I[65] = (T)(img)(_p2##x,_n3##y,z,c), \
  816 + I[66] = (T)(img)(_p1##x,_n3##y,z,c), I[67] = (T)(img)(x,_n3##y,z,c), I[68] = (T)(img)(_n1##x,_n3##y,z,c), \
  817 + I[69] = (T)(img)(_n2##x,_n3##y,z,c), I[70] = (T)(img)(_n3##x,_n3##y,z,c), I[71] = (T)(img)(_n4##x,_n3##y,z,c), \
  818 + I[72] = (T)(img)(_p4##x,_n4##y,z,c), I[73] = (T)(img)(_p3##x,_n4##y,z,c), I[74] = (T)(img)(_p2##x,_n4##y,z,c), \
  819 + I[75] = (T)(img)(_p1##x,_n4##y,z,c), I[76] = (T)(img)(x,_n4##y,z,c), I[77] = (T)(img)(_n1##x,_n4##y,z,c), \
  820 + I[78] = (T)(img)(_n2##x,_n4##y,z,c), I[79] = (T)(img)(_n3##x,_n4##y,z,c), I[80] = (T)(img)(_n4##x,_n4##y,z,c)
  821 +
  822 +#define cimg_get2x2x2(img,x,y,z,c,I,T) \
  823 + I[0] = (T)(img)(x,y,z,c), I[1] = (T)(img)(_n1##x,y,z,c), I[2] = (T)(img)(x,_n1##y,z,c), \
  824 + I[3] = (T)(img)(_n1##x,_n1##y,z,c), I[4] = (T)(img)(x,y,_n1##z,c), I[5] = (T)(img)(_n1##x,y,_n1##z,c), \
  825 + I[6] = (T)(img)(x,_n1##y,_n1##z,c), I[7] = (T)(img)(_n1##x,_n1##y,_n1##z,c)
  826 +
  827 +#define cimg_get3x3x3(img,x,y,z,c,I,T) \
  828 + I[0] = (T)(img)(_p1##x,_p1##y,_p1##z,c), I[1] = (T)(img)(x,_p1##y,_p1##z,c), \
  829 + I[2] = (T)(img)(_n1##x,_p1##y,_p1##z,c), I[3] = (T)(img)(_p1##x,y,_p1##z,c), I[4] = (T)(img)(x,y,_p1##z,c), \
  830 + I[5] = (T)(img)(_n1##x,y,_p1##z,c), I[6] = (T)(img)(_p1##x,_n1##y,_p1##z,c), I[7] = (T)(img)(x,_n1##y,_p1##z,c), \
  831 + I[8] = (T)(img)(_n1##x,_n1##y,_p1##z,c), I[9] = (T)(img)(_p1##x,_p1##y,z,c), I[10] = (T)(img)(x,_p1##y,z,c), \
  832 + I[11] = (T)(img)(_n1##x,_p1##y,z,c), I[12] = (T)(img)(_p1##x,y,z,c), I[13] = (T)(img)(x,y,z,c), \
  833 + I[14] = (T)(img)(_n1##x,y,z,c), I[15] = (T)(img)(_p1##x,_n1##y,z,c), I[16] = (T)(img)(x,_n1##y,z,c), \
  834 + I[17] = (T)(img)(_n1##x,_n1##y,z,c), I[18] = (T)(img)(_p1##x,_p1##y,_n1##z,c), I[19] = (T)(img)(x,_p1##y,_n1##z,c), \
  835 + I[20] = (T)(img)(_n1##x,_p1##y,_n1##z,c), I[21] = (T)(img)(_p1##x,y,_n1##z,c), I[22] = (T)(img)(x,y,_n1##z,c), \
  836 + I[23] = (T)(img)(_n1##x,y,_n1##z,c), I[24] = (T)(img)(_p1##x,_n1##y,_n1##z,c), I[25] = (T)(img)(x,_n1##y,_n1##z,c), \
  837 + I[26] = (T)(img)(_n1##x,_n1##y,_n1##z,c)
  838 +
  839 +// Macros to perform various image loops.
  840 +//
  841 +// These macros are simpler to use than loops with C++ iterators.
  842 +#define cimg_for(img,ptrs,T_ptrs) \
  843 + for (T_ptrs *ptrs = (img)._data, *_max##ptrs = (img)._data + (img).size(); ptrs<_max##ptrs; ++ptrs)
  844 +#define cimg_rof(img,ptrs,T_ptrs) for (T_ptrs *ptrs = (img)._data + (img).size() - 1; ptrs>=(img)._data; --ptrs)
  845 +#define cimg_foroff(img,off) for (cimg_ulong off = 0, _max##off = (img).size(); off<_max##off; ++off)
  846 +#define cimg_rofoff(img,off) for (cimg_long off = (cimg_long)((img).size() - 1); off>=0; --off)
  847 +
  848 +#define cimg_for1(bound,i) for (int i = 0; i<(int)(bound); ++i)
  849 +#define cimg_forX(img,x) cimg_for1((img)._width,x)
  850 +#define cimg_forY(img,y) cimg_for1((img)._height,y)
  851 +#define cimg_forZ(img,z) cimg_for1((img)._depth,z)
  852 +#define cimg_forC(img,c) cimg_for1((img)._spectrum,c)
  853 +#define cimg_forXY(img,x,y) cimg_forY(img,y) cimg_forX(img,x)
  854 +#define cimg_forXZ(img,x,z) cimg_forZ(img,z) cimg_forX(img,x)
  855 +#define cimg_forYZ(img,y,z) cimg_forZ(img,z) cimg_forY(img,y)
  856 +#define cimg_forXC(img,x,c) cimg_forC(img,c) cimg_forX(img,x)
  857 +#define cimg_forYC(img,y,c) cimg_forC(img,c) cimg_forY(img,y)
  858 +#define cimg_forZC(img,z,c) cimg_forC(img,c) cimg_forZ(img,z)
  859 +#define cimg_forXYZ(img,x,y,z) cimg_forZ(img,z) cimg_forXY(img,x,y)
  860 +#define cimg_forXYC(img,x,y,c) cimg_forC(img,c) cimg_forXY(img,x,y)
  861 +#define cimg_forXZC(img,x,z,c) cimg_forC(img,c) cimg_forXZ(img,x,z)
  862 +#define cimg_forYZC(img,y,z,c) cimg_forC(img,c) cimg_forYZ(img,y,z)
  863 +#define cimg_forXYZC(img,x,y,z,c) cimg_forC(img,c) cimg_forXYZ(img,x,y,z)
  864 +
  865 +#define cimg_rof1(bound,i) for (int i = (int)(bound) - 1; i>=0; --i)
  866 +#define cimg_rofX(img,x) cimg_rof1((img)._width,x)
  867 +#define cimg_rofY(img,y) cimg_rof1((img)._height,y)
  868 +#define cimg_rofZ(img,z) cimg_rof1((img)._depth,z)
  869 +#define cimg_rofC(img,c) cimg_rof1((img)._spectrum,c)
  870 +#define cimg_rofXY(img,x,y) cimg_rofY(img,y) cimg_rofX(img,x)
  871 +#define cimg_rofXZ(img,x,z) cimg_rofZ(img,z) cimg_rofX(img,x)
  872 +#define cimg_rofYZ(img,y,z) cimg_rofZ(img,z) cimg_rofY(img,y)
  873 +#define cimg_rofXC(img,x,c) cimg_rofC(img,c) cimg_rofX(img,x)
  874 +#define cimg_rofYC(img,y,c) cimg_rofC(img,c) cimg_rofY(img,y)
  875 +#define cimg_rofZC(img,z,c) cimg_rofC(img,c) cimg_rofZ(img,z)
  876 +#define cimg_rofXYZ(img,x,y,z) cimg_rofZ(img,z) cimg_rofXY(img,x,y)
  877 +#define cimg_rofXYC(img,x,y,c) cimg_rofC(img,c) cimg_rofXY(img,x,y)
  878 +#define cimg_rofXZC(img,x,z,c) cimg_rofC(img,c) cimg_rofXZ(img,x,z)
  879 +#define cimg_rofYZC(img,y,z,c) cimg_rofC(img,c) cimg_rofYZ(img,y,z)
  880 +#define cimg_rofXYZC(img,x,y,z,c) cimg_rofC(img,c) cimg_rofXYZ(img,x,y,z)
  881 +
  882 +#define cimg_for_in1(bound,i0,i1,i) \
  883 + for (int i = (int)(i0)<0?0:(int)(i0), _max##i = (int)(i1)<(int)(bound)?(int)(i1):(int)(bound) - 1; i<=_max##i; ++i)
  884 +#define cimg_for_inX(img,x0,x1,x) cimg_for_in1((img)._width,x0,x1,x)
  885 +#define cimg_for_inY(img,y0,y1,y) cimg_for_in1((img)._height,y0,y1,y)
  886 +#define cimg_for_inZ(img,z0,z1,z) cimg_for_in1((img)._depth,z0,z1,z)
  887 +#define cimg_for_inC(img,c0,c1,c) cimg_for_in1((img)._spectrum,c0,c1,c)
  888 +#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)
  889 +#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)
  890 +#define cimg_for_inXC(img,x0,c0,x1,c1,x,c) cimg_for_inC(img,c0,c1,c) cimg_for_inX(img,x0,x1,x)
  891 +#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)
  892 +#define cimg_for_inYC(img,y0,c0,y1,c1,y,c) cimg_for_inC(img,c0,c1,c) cimg_for_inY(img,y0,y1,y)
  893 +#define cimg_for_inZC(img,z0,c0,z1,c1,z,c) cimg_for_inC(img,c0,c1,c) cimg_for_inZ(img,z0,z1,z)
  894 +#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)
  895 +#define cimg_for_inXYC(img,x0,y0,c0,x1,y1,c1,x,y,c) cimg_for_inC(img,c0,c1,c) cimg_for_inXY(img,x0,y0,x1,y1,x,y)
  896 +#define cimg_for_inXZC(img,x0,z0,c0,x1,z1,c1,x,z,c) cimg_for_inC(img,c0,c1,c) cimg_for_inXZ(img,x0,z0,x1,z1,x,z)
  897 +#define cimg_for_inYZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_inC(img,c0,c1,c) cimg_for_inYZ(img,y0,z0,y1,z1,y,z)
  898 +#define cimg_for_inXYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  899 + cimg_for_inC(img,c0,c1,c) cimg_for_inXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  900 +#define cimg_for_insideX(img,x,n) cimg_for_inX(img,n,(img)._width - 1 - (n),x)
  901 +#define cimg_for_insideY(img,y,n) cimg_for_inY(img,n,(img)._height - 1 - (n),y)
  902 +#define cimg_for_insideZ(img,z,n) cimg_for_inZ(img,n,(img)._depth - 1 - (n),z)
  903 +#define cimg_for_insideC(img,c,n) cimg_for_inC(img,n,(img)._spectrum - 1 - (n),c)
  904 +#define cimg_for_insideXY(img,x,y,n) cimg_for_inXY(img,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n),x,y)
  905 +#define cimg_for_insideXYZ(img,x,y,z,n) \
  906 + cimg_for_inXYZ(img,n,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n),(img)._depth - 1 - (n),x,y,z)
  907 +#define cimg_for_insideXYZC(img,x,y,z,c,n) \
  908 + cimg_for_inXYZ(img,n,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n),(img)._depth - 1 - (n),x,y,z)
  909 +
  910 +#define cimg_for_out1(boundi,i0,i1,i) \
  911 + for (int i = (int)(i0)>0?0:(int)(i1) + 1; i<(int)(boundi); ++i, i = i==(int)(i0)?(int)(i1) + 1:i)
  912 +#define cimg_for_out2(boundi,boundj,i0,j0,i1,j1,i,j) \
  913 + for (int j = 0; j<(int)(boundj); ++j) \
  914 + for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j?0:(int)(i0)>0?0:(int)(i1) + 1; i<(int)(boundi); \
  915 + ++i, i = _n1j?i:(i==(int)(i0)?(int)(i1) + 1:i))
  916 +#define cimg_for_out3(boundi,boundj,boundk,i0,j0,k0,i1,j1,k1,i,j,k) \
  917 + for (int k = 0; k<(int)(boundk); ++k) \
  918 + for (int _n1k = (int)(k<(int)(k0) || k>(int)(k1)), j = 0; j<(int)(boundj); ++j) \
  919 + for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j || _n1k?0:(int)(i0)>0?0:(int)(i1) + 1; i<(int)(boundi); \
  920 + ++i, i = _n1j || _n1k?i:(i==(int)(i0)?(int)(i1) + 1:i))
  921 +#define cimg_for_out4(boundi,boundj,boundk,boundl,i0,j0,k0,l0,i1,j1,k1,l1,i,j,k,l) \
  922 + for (int l = 0; l<(int)(boundl); ++l) \
  923 + for (int _n1l = (int)(l<(int)(l0) || l>(int)(l1)), k = 0; k<(int)(boundk); ++k) \
  924 + for (int _n1k = (int)(k<(int)(k0) || k>(int)(k1)), j = 0; j<(int)(boundj); ++j) \
  925 + for (int _n1j = (int)(j<(int)(j0) || j>(int)(j1)), i = _n1j || _n1k || _n1l?0:(int)(i0)>0?0:(int)(i1) + 1; \
  926 + i<(int)(boundi); ++i, i = _n1j || _n1k || _n1l?i:(i==(int)(i0)?(int)(i1) + 1:i))
  927 +#define cimg_for_outX(img,x0,x1,x) cimg_for_out1((img)._width,x0,x1,x)
  928 +#define cimg_for_outY(img,y0,y1,y) cimg_for_out1((img)._height,y0,y1,y)
  929 +#define cimg_for_outZ(img,z0,z1,z) cimg_for_out1((img)._depth,z0,z1,z)
  930 +#define cimg_for_outC(img,c0,c1,c) cimg_for_out1((img)._spectrum,c0,c1,c)
  931 +#define cimg_for_outXY(img,x0,y0,x1,y1,x,y) cimg_for_out2((img)._width,(img)._height,x0,y0,x1,y1,x,y)
  932 +#define cimg_for_outXZ(img,x0,z0,x1,z1,x,z) cimg_for_out2((img)._width,(img)._depth,x0,z0,x1,z1,x,z)
  933 +#define cimg_for_outXC(img,x0,c0,x1,c1,x,c) cimg_for_out2((img)._width,(img)._spectrum,x0,c0,x1,c1,x,c)
  934 +#define cimg_for_outYZ(img,y0,z0,y1,z1,y,z) cimg_for_out2((img)._height,(img)._depth,y0,z0,y1,z1,y,z)
  935 +#define cimg_for_outYC(img,y0,c0,y1,c1,y,c) cimg_for_out2((img)._height,(img)._spectrum,y0,c0,y1,c1,y,c)
  936 +#define cimg_for_outZC(img,z0,c0,z1,c1,z,c) cimg_for_out2((img)._depth,(img)._spectrum,z0,c0,z1,c1,z,c)
  937 +#define cimg_for_outXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z) \
  938 + cimg_for_out3((img)._width,(img)._height,(img)._depth,x0,y0,z0,x1,y1,z1,x,y,z)
  939 +#define cimg_for_outXYC(img,x0,y0,c0,x1,y1,c1,x,y,c) \
  940 + cimg_for_out3((img)._width,(img)._height,(img)._spectrum,x0,y0,c0,x1,y1,c1,x,y,c)
  941 +#define cimg_for_outXZC(img,x0,z0,c0,x1,z1,c1,x,z,c) \
  942 + cimg_for_out3((img)._width,(img)._depth,(img)._spectrum,x0,z0,c0,x1,z1,c1,x,z,c)
  943 +#define cimg_for_outYZC(img,y0,z0,c0,y1,z1,c1,y,z,c) \
  944 + cimg_for_out3((img)._height,(img)._depth,(img)._spectrum,y0,z0,c0,y1,z1,c1,y,z,c)
  945 +#define cimg_for_outXYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  946 + cimg_for_out4((img)._width,(img)._height,(img)._depth,(img)._spectrum,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c)
  947 +#define cimg_for_borderX(img,x,n) cimg_for_outX(img,n,(img)._width - 1 - (n),x)
  948 +#define cimg_for_borderY(img,y,n) cimg_for_outY(img,n,(img)._height - 1 - (n),y)
  949 +#define cimg_for_borderZ(img,z,n) cimg_for_outZ(img,n,(img)._depth - 1 - (n),z)
  950 +#define cimg_for_borderC(img,c,n) cimg_for_outC(img,n,(img)._spectrum - 1 - (n),c)
  951 +#define cimg_for_borderXY(img,x,y,n) cimg_for_outXY(img,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n),x,y)
  952 +#define cimg_for_borderXYZ(img,x,y,z,n) \
  953 + cimg_for_outXYZ(img,n,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n),(img)._depth - 1 - (n),x,y,z)
  954 +#define cimg_for_borderXYZC(img,x,y,z,c,n) \
  955 + cimg_for_outXYZC(img,n,n,n,n,(img)._width - 1 - (n),(img)._height - 1 - (n), \
  956 + (img)._depth - 1 - (n),(img)._spectrum - 1 - (n),x,y,z,c)
  957 +
  958 +#define cimg_for_spiralXY(img,x,y) \
  959 + for (int x = 0, y = 0, _n1##x = 1, _n1##y = (img).width()*(img).height(); _n1##y; \
  960 + --_n1##y, _n1##x+=(_n1##x>>2) - ((!(_n1##x&3)?--y:((_n1##x&3)==1?(img)._width - 1 - ++x:\
  961 + ((_n1##x&3)==2?(img)._height - 1 - ++y:--x))))?0:1)
  962 +
  963 +#define cimg_for_lineXY(x,y,x0,y0,x1,y1) \
  964 + for (int x = (int)(x0), y = (int)(y0), _sx = 1, _sy = 1, _steep = 0, \
  965 + _dx=(x1)>(x0)?(int)(x1) - (int)(x0):(_sx=-1,(int)(x0) - (int)(x1)), \
  966 + _dy=(y1)>(y0)?(int)(y1) - (int)(y0):(_sy=-1,(int)(y0) - (int)(y1)), \
  967 + _counter = _dx, \
  968 + _err = _dx>_dy?(_dy>>1):((_steep=1),(_counter=_dy),(_dx>>1)); \
  969 + _counter>=0; \
  970 + --_counter, x+=_steep? \
  971 + (y+=_sy,(_err-=_dx)<0?_err+=_dy,_sx:0): \
  972 + (y+=(_err-=_dy)<0?_err+=_dx,_sy:0,_sx))
  973 +
  974 +#define cimg_for2(bound,i) \
  975 + for (int i = 0, _n1##i = 1>=(bound)?(int)(bound) - 1:1; \
  976 + _n1##i<(int)(bound) || i==--_n1##i; \
  977 + ++i, ++_n1##i)
  978 +#define cimg_for2X(img,x) cimg_for2((img)._width,x)
  979 +#define cimg_for2Y(img,y) cimg_for2((img)._height,y)
  980 +#define cimg_for2Z(img,z) cimg_for2((img)._depth,z)
  981 +#define cimg_for2C(img,c) cimg_for2((img)._spectrum,c)
  982 +#define cimg_for2XY(img,x,y) cimg_for2Y(img,y) cimg_for2X(img,x)
  983 +#define cimg_for2XZ(img,x,z) cimg_for2Z(img,z) cimg_for2X(img,x)
  984 +#define cimg_for2XC(img,x,c) cimg_for2C(img,c) cimg_for2X(img,x)
  985 +#define cimg_for2YZ(img,y,z) cimg_for2Z(img,z) cimg_for2Y(img,y)
  986 +#define cimg_for2YC(img,y,c) cimg_for2C(img,c) cimg_for2Y(img,y)
  987 +#define cimg_for2ZC(img,z,c) cimg_for2C(img,c) cimg_for2Z(img,z)
  988 +#define cimg_for2XYZ(img,x,y,z) cimg_for2Z(img,z) cimg_for2XY(img,x,y)
  989 +#define cimg_for2XZC(img,x,z,c) cimg_for2C(img,c) cimg_for2XZ(img,x,z)
  990 +#define cimg_for2YZC(img,y,z,c) cimg_for2C(img,c) cimg_for2YZ(img,y,z)
  991 +#define cimg_for2XYZC(img,x,y,z,c) cimg_for2C(img,c) cimg_for2XYZ(img,x,y,z)
  992 +
  993 +#define cimg_for_in2(bound,i0,i1,i) \
  994 + for (int i = (int)(i0)<0?0:(int)(i0), \
  995 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1; \
  996 + i<=(int)(i1) && (_n1##i<(int)(bound) || i==--_n1##i); \
  997 + ++i, ++_n1##i)
  998 +#define cimg_for_in2X(img,x0,x1,x) cimg_for_in2((img)._width,x0,x1,x)
  999 +#define cimg_for_in2Y(img,y0,y1,y) cimg_for_in2((img)._height,y0,y1,y)
  1000 +#define cimg_for_in2Z(img,z0,z1,z) cimg_for_in2((img)._depth,z0,z1,z)
  1001 +#define cimg_for_in2C(img,c0,c1,c) cimg_for_in2((img)._spectrum,c0,c1,c)
  1002 +#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)
  1003 +#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)
  1004 +#define cimg_for_in2XC(img,x0,c0,x1,c1,x,c) cimg_for_in2C(img,c0,c1,c) cimg_for_in2X(img,x0,x1,x)
  1005 +#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)
  1006 +#define cimg_for_in2YC(img,y0,c0,y1,c1,y,c) cimg_for_in2C(img,c0,c1,c) cimg_for_in2Y(img,y0,y1,y)
  1007 +#define cimg_for_in2ZC(img,z0,c0,z1,c1,z,c) cimg_for_in2C(img,c0,c1,c) cimg_for_in2Z(img,z0,z1,z)
  1008 +#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)
  1009 +#define cimg_for_in2XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in2C(img,c0,c1,c) cimg_for_in2XZ(img,x0,y0,x1,y1,x,z)
  1010 +#define cimg_for_in2YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in2C(img,c0,c1,c) cimg_for_in2YZ(img,y0,z0,y1,z1,y,z)
  1011 +#define cimg_for_in2XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1012 + cimg_for_in2C(img,c0,c1,c) cimg_for_in2XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1013 +
  1014 +#define cimg_for3(bound,i) \
  1015 + for (int i = 0, _p1##i = 0, \
  1016 + _n1##i = 1>=(bound)?(int)(bound) - 1:1; \
  1017 + _n1##i<(int)(bound) || i==--_n1##i; \
  1018 + _p1##i = i++, ++_n1##i)
  1019 +#define cimg_for3X(img,x) cimg_for3((img)._width,x)
  1020 +#define cimg_for3Y(img,y) cimg_for3((img)._height,y)
  1021 +#define cimg_for3Z(img,z) cimg_for3((img)._depth,z)
  1022 +#define cimg_for3C(img,c) cimg_for3((img)._spectrum,c)
  1023 +#define cimg_for3XY(img,x,y) cimg_for3Y(img,y) cimg_for3X(img,x)
  1024 +#define cimg_for3XZ(img,x,z) cimg_for3Z(img,z) cimg_for3X(img,x)
  1025 +#define cimg_for3XC(img,x,c) cimg_for3C(img,c) cimg_for3X(img,x)
  1026 +#define cimg_for3YZ(img,y,z) cimg_for3Z(img,z) cimg_for3Y(img,y)
  1027 +#define cimg_for3YC(img,y,c) cimg_for3C(img,c) cimg_for3Y(img,y)
  1028 +#define cimg_for3ZC(img,z,c) cimg_for3C(img,c) cimg_for3Z(img,z)
  1029 +#define cimg_for3XYZ(img,x,y,z) cimg_for3Z(img,z) cimg_for3XY(img,x,y)
  1030 +#define cimg_for3XZC(img,x,z,c) cimg_for3C(img,c) cimg_for3XZ(img,x,z)
  1031 +#define cimg_for3YZC(img,y,z,c) cimg_for3C(img,c) cimg_for3YZ(img,y,z)
  1032 +#define cimg_for3XYZC(img,x,y,z,c) cimg_for3C(img,c) cimg_for3XYZ(img,x,y,z)
  1033 +
  1034 +#define cimg_for_in3(bound,i0,i1,i) \
  1035 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1036 + _p1##i = i - 1<0?0:i - 1, \
  1037 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1; \
  1038 + i<=(int)(i1) && (_n1##i<(int)(bound) || i==--_n1##i); \
  1039 + _p1##i = i++, ++_n1##i)
  1040 +#define cimg_for_in3X(img,x0,x1,x) cimg_for_in3((img)._width,x0,x1,x)
  1041 +#define cimg_for_in3Y(img,y0,y1,y) cimg_for_in3((img)._height,y0,y1,y)
  1042 +#define cimg_for_in3Z(img,z0,z1,z) cimg_for_in3((img)._depth,z0,z1,z)
  1043 +#define cimg_for_in3C(img,c0,c1,c) cimg_for_in3((img)._spectrum,c0,c1,c)
  1044 +#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)
  1045 +#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)
  1046 +#define cimg_for_in3XC(img,x0,c0,x1,c1,x,c) cimg_for_in3C(img,c0,c1,c) cimg_for_in3X(img,x0,x1,x)
  1047 +#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)
  1048 +#define cimg_for_in3YC(img,y0,c0,y1,c1,y,c) cimg_for_in3C(img,c0,c1,c) cimg_for_in3Y(img,y0,y1,y)
  1049 +#define cimg_for_in3ZC(img,z0,c0,z1,c1,z,c) cimg_for_in3C(img,c0,c1,c) cimg_for_in3Z(img,z0,z1,z)
  1050 +#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)
  1051 +#define cimg_for_in3XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in3C(img,c0,c1,c) cimg_for_in3XZ(img,x0,y0,x1,y1,x,z)
  1052 +#define cimg_for_in3YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in3C(img,c0,c1,c) cimg_for_in3YZ(img,y0,z0,y1,z1,y,z)
  1053 +#define cimg_for_in3XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1054 + cimg_for_in3C(img,c0,c1,c) cimg_for_in3XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1055 +
  1056 +#define cimg_for4(bound,i) \
  1057 + for (int i = 0, _p1##i = 0, _n1##i = 1>=(bound)?(int)(bound) - 1:1, \
  1058 + _n2##i = 2>=(bound)?(int)(bound) - 1:2; \
  1059 + _n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i); \
  1060 + _p1##i = i++, ++_n1##i, ++_n2##i)
  1061 +#define cimg_for4X(img,x) cimg_for4((img)._width,x)
  1062 +#define cimg_for4Y(img,y) cimg_for4((img)._height,y)
  1063 +#define cimg_for4Z(img,z) cimg_for4((img)._depth,z)
  1064 +#define cimg_for4C(img,c) cimg_for4((img)._spectrum,c)
  1065 +#define cimg_for4XY(img,x,y) cimg_for4Y(img,y) cimg_for4X(img,x)
  1066 +#define cimg_for4XZ(img,x,z) cimg_for4Z(img,z) cimg_for4X(img,x)
  1067 +#define cimg_for4XC(img,x,c) cimg_for4C(img,c) cimg_for4X(img,x)
  1068 +#define cimg_for4YZ(img,y,z) cimg_for4Z(img,z) cimg_for4Y(img,y)
  1069 +#define cimg_for4YC(img,y,c) cimg_for4C(img,c) cimg_for4Y(img,y)
  1070 +#define cimg_for4ZC(img,z,c) cimg_for4C(img,c) cimg_for4Z(img,z)
  1071 +#define cimg_for4XYZ(img,x,y,z) cimg_for4Z(img,z) cimg_for4XY(img,x,y)
  1072 +#define cimg_for4XZC(img,x,z,c) cimg_for4C(img,c) cimg_for4XZ(img,x,z)
  1073 +#define cimg_for4YZC(img,y,z,c) cimg_for4C(img,c) cimg_for4YZ(img,y,z)
  1074 +#define cimg_for4XYZC(img,x,y,z,c) cimg_for4C(img,c) cimg_for4XYZ(img,x,y,z)
  1075 +
  1076 +#define cimg_for_in4(bound,i0,i1,i) \
  1077 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1078 + _p1##i = i - 1<0?0:i - 1, \
  1079 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1080 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2; \
  1081 + i<=(int)(i1) && (_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i)); \
  1082 + _p1##i = i++, ++_n1##i, ++_n2##i)
  1083 +#define cimg_for_in4X(img,x0,x1,x) cimg_for_in4((img)._width,x0,x1,x)
  1084 +#define cimg_for_in4Y(img,y0,y1,y) cimg_for_in4((img)._height,y0,y1,y)
  1085 +#define cimg_for_in4Z(img,z0,z1,z) cimg_for_in4((img)._depth,z0,z1,z)
  1086 +#define cimg_for_in4C(img,c0,c1,c) cimg_for_in4((img)._spectrum,c0,c1,c)
  1087 +#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)
  1088 +#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)
  1089 +#define cimg_for_in4XC(img,x0,c0,x1,c1,x,c) cimg_for_in4C(img,c0,c1,c) cimg_for_in4X(img,x0,x1,x)
  1090 +#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)
  1091 +#define cimg_for_in4YC(img,y0,c0,y1,c1,y,c) cimg_for_in4C(img,c0,c1,c) cimg_for_in4Y(img,y0,y1,y)
  1092 +#define cimg_for_in4ZC(img,z0,c0,z1,c1,z,c) cimg_for_in4C(img,c0,c1,c) cimg_for_in4Z(img,z0,z1,z)
  1093 +#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)
  1094 +#define cimg_for_in4XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in4C(img,c0,c1,c) cimg_for_in4XZ(img,x0,y0,x1,y1,x,z)
  1095 +#define cimg_for_in4YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in4C(img,c0,c1,c) cimg_for_in4YZ(img,y0,z0,y1,z1,y,z)
  1096 +#define cimg_for_in4XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1097 + cimg_for_in4C(img,c0,c1,c) cimg_for_in4XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1098 +
  1099 +#define cimg_for5(bound,i) \
  1100 + for (int i = 0, _p2##i = 0, _p1##i = 0, \
  1101 + _n1##i = 1>=(bound)?(int)(bound) - 1:1, \
  1102 + _n2##i = 2>=(bound)?(int)(bound) - 1:2; \
  1103 + _n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i); \
  1104 + _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i)
  1105 +#define cimg_for5X(img,x) cimg_for5((img)._width,x)
  1106 +#define cimg_for5Y(img,y) cimg_for5((img)._height,y)
  1107 +#define cimg_for5Z(img,z) cimg_for5((img)._depth,z)
  1108 +#define cimg_for5C(img,c) cimg_for5((img)._spectrum,c)
  1109 +#define cimg_for5XY(img,x,y) cimg_for5Y(img,y) cimg_for5X(img,x)
  1110 +#define cimg_for5XZ(img,x,z) cimg_for5Z(img,z) cimg_for5X(img,x)
  1111 +#define cimg_for5XC(img,x,c) cimg_for5C(img,c) cimg_for5X(img,x)
  1112 +#define cimg_for5YZ(img,y,z) cimg_for5Z(img,z) cimg_for5Y(img,y)
  1113 +#define cimg_for5YC(img,y,c) cimg_for5C(img,c) cimg_for5Y(img,y)
  1114 +#define cimg_for5ZC(img,z,c) cimg_for5C(img,c) cimg_for5Z(img,z)
  1115 +#define cimg_for5XYZ(img,x,y,z) cimg_for5Z(img,z) cimg_for5XY(img,x,y)
  1116 +#define cimg_for5XZC(img,x,z,c) cimg_for5C(img,c) cimg_for5XZ(img,x,z)
  1117 +#define cimg_for5YZC(img,y,z,c) cimg_for5C(img,c) cimg_for5YZ(img,y,z)
  1118 +#define cimg_for5XYZC(img,x,y,z,c) cimg_for5C(img,c) cimg_for5XYZ(img,x,y,z)
  1119 +
  1120 +#define cimg_for_in5(bound,i0,i1,i) \
  1121 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1122 + _p2##i = i - 2<0?0:i - 2, \
  1123 + _p1##i = i - 1<0?0:i - 1, \
  1124 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1125 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2; \
  1126 + i<=(int)(i1) && (_n2##i<(int)(bound) || _n1##i==--_n2##i || i==(_n2##i = --_n1##i)); \
  1127 + _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i)
  1128 +#define cimg_for_in5X(img,x0,x1,x) cimg_for_in5((img)._width,x0,x1,x)
  1129 +#define cimg_for_in5Y(img,y0,y1,y) cimg_for_in5((img)._height,y0,y1,y)
  1130 +#define cimg_for_in5Z(img,z0,z1,z) cimg_for_in5((img)._depth,z0,z1,z)
  1131 +#define cimg_for_in5C(img,c0,c1,c) cimg_for_in5((img)._spectrum,c0,c1,c)
  1132 +#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)
  1133 +#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)
  1134 +#define cimg_for_in5XC(img,x0,c0,x1,c1,x,c) cimg_for_in5C(img,c0,c1,c) cimg_for_in5X(img,x0,x1,x)
  1135 +#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)
  1136 +#define cimg_for_in5YC(img,y0,c0,y1,c1,y,c) cimg_for_in5C(img,c0,c1,c) cimg_for_in5Y(img,y0,y1,y)
  1137 +#define cimg_for_in5ZC(img,z0,c0,z1,c1,z,c) cimg_for_in5C(img,c0,c1,c) cimg_for_in5Z(img,z0,z1,z)
  1138 +#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)
  1139 +#define cimg_for_in5XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in5C(img,c0,c1,c) cimg_for_in5XZ(img,x0,y0,x1,y1,x,z)
  1140 +#define cimg_for_in5YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in5C(img,c0,c1,c) cimg_for_in5YZ(img,y0,z0,y1,z1,y,z)
  1141 +#define cimg_for_in5XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1142 + cimg_for_in5C(img,c0,c1,c) cimg_for_in5XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1143 +
  1144 +#define cimg_for6(bound,i) \
  1145 + for (int i = 0, _p2##i = 0, _p1##i = 0, \
  1146 + _n1##i = 1>=(bound)?(int)(bound) - 1:1, \
  1147 + _n2##i = 2>=(bound)?(int)(bound) - 1:2, \
  1148 + _n3##i = 3>=(bound)?(int)(bound) - 1:3; \
  1149 + _n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i); \
  1150 + _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
  1151 +#define cimg_for6X(img,x) cimg_for6((img)._width,x)
  1152 +#define cimg_for6Y(img,y) cimg_for6((img)._height,y)
  1153 +#define cimg_for6Z(img,z) cimg_for6((img)._depth,z)
  1154 +#define cimg_for6C(img,c) cimg_for6((img)._spectrum,c)
  1155 +#define cimg_for6XY(img,x,y) cimg_for6Y(img,y) cimg_for6X(img,x)
  1156 +#define cimg_for6XZ(img,x,z) cimg_for6Z(img,z) cimg_for6X(img,x)
  1157 +#define cimg_for6XC(img,x,c) cimg_for6C(img,c) cimg_for6X(img,x)
  1158 +#define cimg_for6YZ(img,y,z) cimg_for6Z(img,z) cimg_for6Y(img,y)
  1159 +#define cimg_for6YC(img,y,c) cimg_for6C(img,c) cimg_for6Y(img,y)
  1160 +#define cimg_for6ZC(img,z,c) cimg_for6C(img,c) cimg_for6Z(img,z)
  1161 +#define cimg_for6XYZ(img,x,y,z) cimg_for6Z(img,z) cimg_for6XY(img,x,y)
  1162 +#define cimg_for6XZC(img,x,z,c) cimg_for6C(img,c) cimg_for6XZ(img,x,z)
  1163 +#define cimg_for6YZC(img,y,z,c) cimg_for6C(img,c) cimg_for6YZ(img,y,z)
  1164 +#define cimg_for6XYZC(img,x,y,z,c) cimg_for6C(img,c) cimg_for6XYZ(img,x,y,z)
  1165 +
  1166 +#define cimg_for_in6(bound,i0,i1,i) \
  1167 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1168 + _p2##i = i - 2<0?0:i - 2, \
  1169 + _p1##i = i - 1<0?0:i - 1, \
  1170 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1171 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2, \
  1172 + _n3##i = i + 3>=(int)(bound)?(int)(bound) - 1:i + 3; \
  1173 + i<=(int)(i1) && \
  1174 + (_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i)); \
  1175 + _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
  1176 +#define cimg_for_in6X(img,x0,x1,x) cimg_for_in6((img)._width,x0,x1,x)
  1177 +#define cimg_for_in6Y(img,y0,y1,y) cimg_for_in6((img)._height,y0,y1,y)
  1178 +#define cimg_for_in6Z(img,z0,z1,z) cimg_for_in6((img)._depth,z0,z1,z)
  1179 +#define cimg_for_in6C(img,c0,c1,c) cimg_for_in6((img)._spectrum,c0,c1,c)
  1180 +#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)
  1181 +#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)
  1182 +#define cimg_for_in6XC(img,x0,c0,x1,c1,x,c) cimg_for_in6C(img,c0,c1,c) cimg_for_in6X(img,x0,x1,x)
  1183 +#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)
  1184 +#define cimg_for_in6YC(img,y0,c0,y1,c1,y,c) cimg_for_in6C(img,c0,c1,c) cimg_for_in6Y(img,y0,y1,y)
  1185 +#define cimg_for_in6ZC(img,z0,c0,z1,c1,z,c) cimg_for_in6C(img,c0,c1,c) cimg_for_in6Z(img,z0,z1,z)
  1186 +#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)
  1187 +#define cimg_for_in6XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in6C(img,c0,c1,c) cimg_for_in6XZ(img,x0,y0,x1,y1,x,z)
  1188 +#define cimg_for_in6YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in6C(img,c0,c1,c) cimg_for_in6YZ(img,y0,z0,y1,z1,y,z)
  1189 +#define cimg_for_in6XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1190 + cimg_for_in6C(img,c0,c1,c) cimg_for_in6XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1191 +
  1192 +#define cimg_for7(bound,i) \
  1193 + for (int i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
  1194 + _n1##i = 1>=(bound)?(int)(bound) - 1:1, \
  1195 + _n2##i = 2>=(bound)?(int)(bound) - 1:2, \
  1196 + _n3##i = 3>=(bound)?(int)(bound) - 1:3; \
  1197 + _n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i); \
  1198 + _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
  1199 +#define cimg_for7X(img,x) cimg_for7((img)._width,x)
  1200 +#define cimg_for7Y(img,y) cimg_for7((img)._height,y)
  1201 +#define cimg_for7Z(img,z) cimg_for7((img)._depth,z)
  1202 +#define cimg_for7C(img,c) cimg_for7((img)._spectrum,c)
  1203 +#define cimg_for7XY(img,x,y) cimg_for7Y(img,y) cimg_for7X(img,x)
  1204 +#define cimg_for7XZ(img,x,z) cimg_for7Z(img,z) cimg_for7X(img,x)
  1205 +#define cimg_for7XC(img,x,c) cimg_for7C(img,c) cimg_for7X(img,x)
  1206 +#define cimg_for7YZ(img,y,z) cimg_for7Z(img,z) cimg_for7Y(img,y)
  1207 +#define cimg_for7YC(img,y,c) cimg_for7C(img,c) cimg_for7Y(img,y)
  1208 +#define cimg_for7ZC(img,z,c) cimg_for7C(img,c) cimg_for7Z(img,z)
  1209 +#define cimg_for7XYZ(img,x,y,z) cimg_for7Z(img,z) cimg_for7XY(img,x,y)
  1210 +#define cimg_for7XZC(img,x,z,c) cimg_for7C(img,c) cimg_for7XZ(img,x,z)
  1211 +#define cimg_for7YZC(img,y,z,c) cimg_for7C(img,c) cimg_for7YZ(img,y,z)
  1212 +#define cimg_for7XYZC(img,x,y,z,c) cimg_for7C(img,c) cimg_for7XYZ(img,x,y,z)
  1213 +
  1214 +#define cimg_for_in7(bound,i0,i1,i) \
  1215 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1216 + _p3##i = i - 3<0?0:i - 3, \
  1217 + _p2##i = i - 2<0?0:i - 2, \
  1218 + _p1##i = i - 1<0?0:i - 1, \
  1219 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1220 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2, \
  1221 + _n3##i = i + 3>=(int)(bound)?(int)(bound) - 1:i + 3; \
  1222 + i<=(int)(i1) && \
  1223 + (_n3##i<(int)(bound) || _n2##i==--_n3##i || _n1##i==--_n2##i || i==(_n3##i = _n2##i = --_n1##i)); \
  1224 + _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i)
  1225 +#define cimg_for_in7X(img,x0,x1,x) cimg_for_in7((img)._width,x0,x1,x)
  1226 +#define cimg_for_in7Y(img,y0,y1,y) cimg_for_in7((img)._height,y0,y1,y)
  1227 +#define cimg_for_in7Z(img,z0,z1,z) cimg_for_in7((img)._depth,z0,z1,z)
  1228 +#define cimg_for_in7C(img,c0,c1,c) cimg_for_in7((img)._spectrum,c0,c1,c)
  1229 +#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)
  1230 +#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)
  1231 +#define cimg_for_in7XC(img,x0,c0,x1,c1,x,c) cimg_for_in7C(img,c0,c1,c) cimg_for_in7X(img,x0,x1,x)
  1232 +#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)
  1233 +#define cimg_for_in7YC(img,y0,c0,y1,c1,y,c) cimg_for_in7C(img,c0,c1,c) cimg_for_in7Y(img,y0,y1,y)
  1234 +#define cimg_for_in7ZC(img,z0,c0,z1,c1,z,c) cimg_for_in7C(img,c0,c1,c) cimg_for_in7Z(img,z0,z1,z)
  1235 +#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)
  1236 +#define cimg_for_in7XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in7C(img,c0,c1,c) cimg_for_in7XZ(img,x0,y0,x1,y1,x,z)
  1237 +#define cimg_for_in7YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in7C(img,c0,c1,c) cimg_for_in7YZ(img,y0,z0,y1,z1,y,z)
  1238 +#define cimg_for_in7XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1239 + cimg_for_in7C(img,c0,c1,c) cimg_for_in7XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1240 +
  1241 +#define cimg_for8(bound,i) \
  1242 + for (int i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
  1243 + _n1##i = 1>=(bound)?(int)(bound) - 1:1, \
  1244 + _n2##i = 2>=(bound)?(int)(bound) - 1:2, \
  1245 + _n3##i = 3>=(bound)?(int)(bound) - 1:3, \
  1246 + _n4##i = 4>=(bound)?(int)(bound) - 1:4; \
  1247 + _n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
  1248 + i==(_n4##i = _n3##i = _n2##i = --_n1##i); \
  1249 + _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
  1250 +#define cimg_for8X(img,x) cimg_for8((img)._width,x)
  1251 +#define cimg_for8Y(img,y) cimg_for8((img)._height,y)
  1252 +#define cimg_for8Z(img,z) cimg_for8((img)._depth,z)
  1253 +#define cimg_for8C(img,c) cimg_for8((img)._spectrum,c)
  1254 +#define cimg_for8XY(img,x,y) cimg_for8Y(img,y) cimg_for8X(img,x)
  1255 +#define cimg_for8XZ(img,x,z) cimg_for8Z(img,z) cimg_for8X(img,x)
  1256 +#define cimg_for8XC(img,x,c) cimg_for8C(img,c) cimg_for8X(img,x)
  1257 +#define cimg_for8YZ(img,y,z) cimg_for8Z(img,z) cimg_for8Y(img,y)
  1258 +#define cimg_for8YC(img,y,c) cimg_for8C(img,c) cimg_for8Y(img,y)
  1259 +#define cimg_for8ZC(img,z,c) cimg_for8C(img,c) cimg_for8Z(img,z)
  1260 +#define cimg_for8XYZ(img,x,y,z) cimg_for8Z(img,z) cimg_for8XY(img,x,y)
  1261 +#define cimg_for8XZC(img,x,z,c) cimg_for8C(img,c) cimg_for8XZ(img,x,z)
  1262 +#define cimg_for8YZC(img,y,z,c) cimg_for8C(img,c) cimg_for8YZ(img,y,z)
  1263 +#define cimg_for8XYZC(img,x,y,z,c) cimg_for8C(img,c) cimg_for8XYZ(img,x,y,z)
  1264 +
  1265 +#define cimg_for_in8(bound,i0,i1,i) \
  1266 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1267 + _p3##i = i - 3<0?0:i - 3, \
  1268 + _p2##i = i - 2<0?0:i - 2, \
  1269 + _p1##i = i - 1<0?0:i - 1, \
  1270 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1271 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2, \
  1272 + _n3##i = i + 3>=(int)(bound)?(int)(bound) - 1:i + 3, \
  1273 + _n4##i = i + 4>=(int)(bound)?(int)(bound) - 1:i + 4; \
  1274 + i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
  1275 + i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \
  1276 + _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
  1277 +#define cimg_for_in8X(img,x0,x1,x) cimg_for_in8((img)._width,x0,x1,x)
  1278 +#define cimg_for_in8Y(img,y0,y1,y) cimg_for_in8((img)._height,y0,y1,y)
  1279 +#define cimg_for_in8Z(img,z0,z1,z) cimg_for_in8((img)._depth,z0,z1,z)
  1280 +#define cimg_for_in8C(img,c0,c1,c) cimg_for_in8((img)._spectrum,c0,c1,c)
  1281 +#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)
  1282 +#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)
  1283 +#define cimg_for_in8XC(img,x0,c0,x1,c1,x,c) cimg_for_in8C(img,c0,c1,c) cimg_for_in8X(img,x0,x1,x)
  1284 +#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)
  1285 +#define cimg_for_in8YC(img,y0,c0,y1,c1,y,c) cimg_for_in8C(img,c0,c1,c) cimg_for_in8Y(img,y0,y1,y)
  1286 +#define cimg_for_in8ZC(img,z0,c0,z1,c1,z,c) cimg_for_in8C(img,c0,c1,c) cimg_for_in8Z(img,z0,z1,z)
  1287 +#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)
  1288 +#define cimg_for_in8XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in8C(img,c0,c1,c) cimg_for_in8XZ(img,x0,y0,x1,y1,x,z)
  1289 +#define cimg_for_in8YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in8C(img,c0,c1,c) cimg_for_in8YZ(img,y0,z0,y1,z1,y,z)
  1290 +#define cimg_for_in8XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1291 + cimg_for_in8C(img,c0,c1,c) cimg_for_in8XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1292 +
  1293 +#define cimg_for9(bound,i) \
  1294 + for (int i = 0, _p4##i = 0, _p3##i = 0, _p2##i = 0, _p1##i = 0, \
  1295 + _n1##i = 1>=(int)(bound)?(int)(bound) - 1:1, \
  1296 + _n2##i = 2>=(int)(bound)?(int)(bound) - 1:2, \
  1297 + _n3##i = 3>=(int)(bound)?(int)(bound) - 1:3, \
  1298 + _n4##i = 4>=(int)(bound)?(int)(bound) - 1:4; \
  1299 + _n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
  1300 + i==(_n4##i = _n3##i = _n2##i = --_n1##i); \
  1301 + _p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
  1302 +#define cimg_for9X(img,x) cimg_for9((img)._width,x)
  1303 +#define cimg_for9Y(img,y) cimg_for9((img)._height,y)
  1304 +#define cimg_for9Z(img,z) cimg_for9((img)._depth,z)
  1305 +#define cimg_for9C(img,c) cimg_for9((img)._spectrum,c)
  1306 +#define cimg_for9XY(img,x,y) cimg_for9Y(img,y) cimg_for9X(img,x)
  1307 +#define cimg_for9XZ(img,x,z) cimg_for9Z(img,z) cimg_for9X(img,x)
  1308 +#define cimg_for9XC(img,x,c) cimg_for9C(img,c) cimg_for9X(img,x)
  1309 +#define cimg_for9YZ(img,y,z) cimg_for9Z(img,z) cimg_for9Y(img,y)
  1310 +#define cimg_for9YC(img,y,c) cimg_for9C(img,c) cimg_for9Y(img,y)
  1311 +#define cimg_for9ZC(img,z,c) cimg_for9C(img,c) cimg_for9Z(img,z)
  1312 +#define cimg_for9XYZ(img,x,y,z) cimg_for9Z(img,z) cimg_for9XY(img,x,y)
  1313 +#define cimg_for9XZC(img,x,z,c) cimg_for9C(img,c) cimg_for9XZ(img,x,z)
  1314 +#define cimg_for9YZC(img,y,z,c) cimg_for9C(img,c) cimg_for9YZ(img,y,z)
  1315 +#define cimg_for9XYZC(img,x,y,z,c) cimg_for9C(img,c) cimg_for9XYZ(img,x,y,z)
  1316 +
  1317 +#define cimg_for_in9(bound,i0,i1,i) \
  1318 + for (int i = (int)(i0)<0?0:(int)(i0), \
  1319 + _p4##i = i - 4<0?0:i - 4, \
  1320 + _p3##i = i - 3<0?0:i - 3, \
  1321 + _p2##i = i - 2<0?0:i - 2, \
  1322 + _p1##i = i - 1<0?0:i - 1, \
  1323 + _n1##i = i + 1>=(int)(bound)?(int)(bound) - 1:i + 1, \
  1324 + _n2##i = i + 2>=(int)(bound)?(int)(bound) - 1:i + 2, \
  1325 + _n3##i = i + 3>=(int)(bound)?(int)(bound) - 1:i + 3, \
  1326 + _n4##i = i + 4>=(int)(bound)?(int)(bound) - 1:i + 4; \
  1327 + i<=(int)(i1) && (_n4##i<(int)(bound) || _n3##i==--_n4##i || _n2##i==--_n3##i || _n1##i==--_n2##i || \
  1328 + i==(_n4##i = _n3##i = _n2##i = --_n1##i)); \
  1329 + _p4##i = _p3##i, _p3##i = _p2##i, _p2##i = _p1##i, _p1##i = i++, ++_n1##i, ++_n2##i, ++_n3##i, ++_n4##i)
  1330 +#define cimg_for_in9X(img,x0,x1,x) cimg_for_in9((img)._width,x0,x1,x)
  1331 +#define cimg_for_in9Y(img,y0,y1,y) cimg_for_in9((img)._height,y0,y1,y)
  1332 +#define cimg_for_in9Z(img,z0,z1,z) cimg_for_in9((img)._depth,z0,z1,z)
  1333 +#define cimg_for_in9C(img,c0,c1,c) cimg_for_in9((img)._spectrum,c0,c1,c)
  1334 +#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)
  1335 +#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)
  1336 +#define cimg_for_in9XC(img,x0,c0,x1,c1,x,c) cimg_for_in9C(img,c0,c1,c) cimg_for_in9X(img,x0,x1,x)
  1337 +#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)
  1338 +#define cimg_for_in9YC(img,y0,c0,y1,c1,y,c) cimg_for_in9C(img,c0,c1,c) cimg_for_in9Y(img,y0,y1,y)
  1339 +#define cimg_for_in9ZC(img,z0,c0,z1,c1,z,c) cimg_for_in9C(img,c0,c1,c) cimg_for_in9Z(img,z0,z1,z)
  1340 +#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)
  1341 +#define cimg_for_in9XZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in9C(img,c0,c1,c) cimg_for_in9XZ(img,x0,y0,x1,y1,x,z)
  1342 +#define cimg_for_in9YZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in9C(img,c0,c1,c) cimg_for_in9YZ(img,y0,z0,y1,z1,y,z)
  1343 +#define cimg_for_in9XYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) \
  1344 + cimg_for_in9C(img,c0,c1,c) cimg_for_in9XYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)
  1345 +
  1346 +#define cimg_for2x2(img,x,y,z,c,I,T) \
  1347 + cimg_for2((img)._height,y) for (int x = 0, \
  1348 + _n1##x = (int)( \
  1349 + (I[0] = (T)(img)(0,y,z,c)), \
  1350 + (I[2] = (T)(img)(0,_n1##y,z,c)), \
  1351 + 1>=(img)._width?(img).width() - 1:1); \
  1352 + (_n1##x<(img).width() && ( \
  1353 + (I[1] = (T)(img)(_n1##x,y,z,c)), \
  1354 + (I[3] = (T)(img)(_n1##x,_n1##y,z,c)),1)) || \
  1355 + x==--_n1##x; \
  1356 + I[0] = I[1], \
  1357 + I[2] = I[3], \
  1358 + ++x, ++_n1##x)
  1359 +
  1360 +#define cimg_for_in2x2(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1361 + cimg_for_in2((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
  1362 + _n1##x = (int)( \
  1363 + (I[0] = (T)(img)(x,y,z,c)), \
  1364 + (I[2] = (T)(img)(x,_n1##y,z,c)), \
  1365 + x + 1>=(int)(img)._width?(img).width() - 1:x + 1); \
  1366 + x<=(int)(x1) && ((_n1##x<(img).width() && ( \
  1367 + (I[1] = (T)(img)(_n1##x,y,z,c)), \
  1368 + (I[3] = (T)(img)(_n1##x,_n1##y,z,c)),1)) || \
  1369 + x==--_n1##x); \
  1370 + I[0] = I[1], \
  1371 + I[2] = I[3], \
  1372 + ++x, ++_n1##x)
  1373 +
  1374 +#define cimg_for3x3(img,x,y,z,c,I,T) \
  1375 + cimg_for3((img)._height,y) for (int x = 0, \
  1376 + _p1##x = 0, \
  1377 + _n1##x = (int)( \
  1378 + (I[0] = I[1] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1379 + (I[3] = I[4] = (T)(img)(0,y,z,c)), \
  1380 + (I[6] = I[7] = (T)(img)(0,_n1##y,z,c)), \
  1381 + 1>=(img)._width?(img).width() - 1:1); \
  1382 + (_n1##x<(img).width() && ( \
  1383 + (I[2] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1384 + (I[5] = (T)(img)(_n1##x,y,z,c)), \
  1385 + (I[8] = (T)(img)(_n1##x,_n1##y,z,c)),1)) || \
  1386 + x==--_n1##x; \
  1387 + I[0] = I[1], I[1] = I[2], \
  1388 + I[3] = I[4], I[4] = I[5], \
  1389 + I[6] = I[7], I[7] = I[8], \
  1390 + _p1##x = x++, ++_n1##x)
  1391 +
  1392 +#define cimg_for_in3x3(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1393 + cimg_for_in3((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
  1394 + _p1##x = x - 1<0?0:x - 1, \
  1395 + _n1##x = (int)( \
  1396 + (I[0] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1397 + (I[3] = (T)(img)(_p1##x,y,z,c)), \
  1398 + (I[6] = (T)(img)(_p1##x,_n1##y,z,c)), \
  1399 + (I[1] = (T)(img)(x,_p1##y,z,c)), \
  1400 + (I[4] = (T)(img)(x,y,z,c)), \
  1401 + (I[7] = (T)(img)(x,_n1##y,z,c)), \
  1402 + x + 1>=(int)(img)._width?(img).width() - 1:x + 1); \
  1403 + x<=(int)(x1) && ((_n1##x<(img).width() && ( \
  1404 + (I[2] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1405 + (I[5] = (T)(img)(_n1##x,y,z,c)), \
  1406 + (I[8] = (T)(img)(_n1##x,_n1##y,z,c)),1)) || \
  1407 + x==--_n1##x); \
  1408 + I[0] = I[1], I[1] = I[2], \
  1409 + I[3] = I[4], I[4] = I[5], \
  1410 + I[6] = I[7], I[7] = I[8], \
  1411 + _p1##x = x++, ++_n1##x)
  1412 +
  1413 +#define cimg_for4x4(img,x,y,z,c,I,T) \
  1414 + cimg_for4((img)._height,y) for (int x = 0, \
  1415 + _p1##x = 0, \
  1416 + _n1##x = 1>=(img)._width?(img).width() - 1:1, \
  1417 + _n2##x = (int)( \
  1418 + (I[0] = I[1] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1419 + (I[4] = I[5] = (T)(img)(0,y,z,c)), \
  1420 + (I[8] = I[9] = (T)(img)(0,_n1##y,z,c)), \
  1421 + (I[12] = I[13] = (T)(img)(0,_n2##y,z,c)), \
  1422 + (I[2] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1423 + (I[6] = (T)(img)(_n1##x,y,z,c)), \
  1424 + (I[10] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1425 + (I[14] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1426 + 2>=(img)._width?(img).width() - 1:2); \
  1427 + (_n2##x<(img).width() && ( \
  1428 + (I[3] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1429 + (I[7] = (T)(img)(_n2##x,y,z,c)), \
  1430 + (I[11] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1431 + (I[15] = (T)(img)(_n2##x,_n2##y,z,c)),1)) || \
  1432 + _n1##x==--_n2##x || x==(_n2##x = --_n1##x); \
  1433 + I[0] = I[1], I[1] = I[2], I[2] = I[3], \
  1434 + I[4] = I[5], I[5] = I[6], I[6] = I[7], \
  1435 + I[8] = I[9], I[9] = I[10], I[10] = I[11], \
  1436 + I[12] = I[13], I[13] = I[14], I[14] = I[15], \
  1437 + _p1##x = x++, ++_n1##x, ++_n2##x)
  1438 +
  1439 +#define cimg_for_in4x4(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1440 + cimg_for_in4((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
  1441 + _p1##x = x - 1<0?0:x - 1, \
  1442 + _n1##x = x + 1>=(int)(img)._width?(img).width() - 1:x + 1, \
  1443 + _n2##x = (int)( \
  1444 + (I[0] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1445 + (I[4] = (T)(img)(_p1##x,y,z,c)), \
  1446 + (I[8] = (T)(img)(_p1##x,_n1##y,z,c)), \
  1447 + (I[12] = (T)(img)(_p1##x,_n2##y,z,c)), \
  1448 + (I[1] = (T)(img)(x,_p1##y,z,c)), \
  1449 + (I[5] = (T)(img)(x,y,z,c)), \
  1450 + (I[9] = (T)(img)(x,_n1##y,z,c)), \
  1451 + (I[13] = (T)(img)(x,_n2##y,z,c)), \
  1452 + (I[2] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1453 + (I[6] = (T)(img)(_n1##x,y,z,c)), \
  1454 + (I[10] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1455 + (I[14] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1456 + x + 2>=(int)(img)._width?(img).width() - 1:x + 2); \
  1457 + x<=(int)(x1) && ((_n2##x<(img).width() && ( \
  1458 + (I[3] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1459 + (I[7] = (T)(img)(_n2##x,y,z,c)), \
  1460 + (I[11] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1461 + (I[15] = (T)(img)(_n2##x,_n2##y,z,c)),1)) || \
  1462 + _n1##x==--_n2##x || x==(_n2##x = --_n1##x)); \
  1463 + I[0] = I[1], I[1] = I[2], I[2] = I[3], \
  1464 + I[4] = I[5], I[5] = I[6], I[6] = I[7], \
  1465 + I[8] = I[9], I[9] = I[10], I[10] = I[11], \
  1466 + I[12] = I[13], I[13] = I[14], I[14] = I[15], \
  1467 + _p1##x = x++, ++_n1##x, ++_n2##x)
  1468 +
  1469 +#define cimg_for5x5(img,x,y,z,c,I,T) \
  1470 + cimg_for5((img)._height,y) for (int x = 0, \
  1471 + _p2##x = 0, _p1##x = 0, \
  1472 + _n1##x = 1>=(img)._width?(img).width() - 1:1, \
  1473 + _n2##x = (int)( \
  1474 + (I[0] = I[1] = I[2] = (T)(img)(_p2##x,_p2##y,z,c)), \
  1475 + (I[5] = I[6] = I[7] = (T)(img)(0,_p1##y,z,c)), \
  1476 + (I[10] = I[11] = I[12] = (T)(img)(0,y,z,c)), \
  1477 + (I[15] = I[16] = I[17] = (T)(img)(0,_n1##y,z,c)), \
  1478 + (I[20] = I[21] = I[22] = (T)(img)(0,_n2##y,z,c)), \
  1479 + (I[3] = (T)(img)(_n1##x,_p2##y,z,c)), \
  1480 + (I[8] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1481 + (I[13] = (T)(img)(_n1##x,y,z,c)), \
  1482 + (I[18] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1483 + (I[23] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1484 + 2>=(img)._width?(img).width() - 1:2); \
  1485 + (_n2##x<(img).width() && ( \
  1486 + (I[4] = (T)(img)(_n2##x,_p2##y,z,c)), \
  1487 + (I[9] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1488 + (I[14] = (T)(img)(_n2##x,y,z,c)), \
  1489 + (I[19] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1490 + (I[24] = (T)(img)(_n2##x,_n2##y,z,c)),1)) || \
  1491 + _n1##x==--_n2##x || x==(_n2##x = --_n1##x); \
  1492 + I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], \
  1493 + I[5] = I[6], I[6] = I[7], I[7] = I[8], I[8] = I[9], \
  1494 + I[10] = I[11], I[11] = I[12], I[12] = I[13], I[13] = I[14], \
  1495 + I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], \
  1496 + I[20] = I[21], I[21] = I[22], I[22] = I[23], I[23] = I[24], \
  1497 + _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x)
  1498 +
  1499 +#define cimg_for_in5x5(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1500 + cimg_for_in5((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
  1501 + _p2##x = x - 2<0?0:x - 2, \
  1502 + _p1##x = x - 1<0?0:x - 1, \
  1503 + _n1##x = x + 1>=(int)(img)._width?(img).width() - 1:x + 1, \
  1504 + _n2##x = (int)( \
  1505 + (I[0] = (T)(img)(_p2##x,_p2##y,z,c)), \
  1506 + (I[5] = (T)(img)(_p2##x,_p1##y,z,c)), \
  1507 + (I[10] = (T)(img)(_p2##x,y,z,c)), \
  1508 + (I[15] = (T)(img)(_p2##x,_n1##y,z,c)), \
  1509 + (I[20] = (T)(img)(_p2##x,_n2##y,z,c)), \
  1510 + (I[1] = (T)(img)(_p1##x,_p2##y,z,c)), \
  1511 + (I[6] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1512 + (I[11] = (T)(img)(_p1##x,y,z,c)), \
  1513 + (I[16] = (T)(img)(_p1##x,_n1##y,z,c)), \
  1514 + (I[21] = (T)(img)(_p1##x,_n2##y,z,c)), \
  1515 + (I[2] = (T)(img)(x,_p2##y,z,c)), \
  1516 + (I[7] = (T)(img)(x,_p1##y,z,c)), \
  1517 + (I[12] = (T)(img)(x,y,z,c)), \
  1518 + (I[17] = (T)(img)(x,_n1##y,z,c)), \
  1519 + (I[22] = (T)(img)(x,_n2##y,z,c)), \
  1520 + (I[3] = (T)(img)(_n1##x,_p2##y,z,c)), \
  1521 + (I[8] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1522 + (I[13] = (T)(img)(_n1##x,y,z,c)), \
  1523 + (I[18] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1524 + (I[23] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1525 + x + 2>=(int)(img)._width?(img).width() - 1:x + 2); \
  1526 + x<=(int)(x1) && ((_n2##x<(img).width() && ( \
  1527 + (I[4] = (T)(img)(_n2##x,_p2##y,z,c)), \
  1528 + (I[9] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1529 + (I[14] = (T)(img)(_n2##x,y,z,c)), \
  1530 + (I[19] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1531 + (I[24] = (T)(img)(_n2##x,_n2##y,z,c)),1)) || \
  1532 + _n1##x==--_n2##x || x==(_n2##x = --_n1##x)); \
  1533 + I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], \
  1534 + I[5] = I[6], I[6] = I[7], I[7] = I[8], I[8] = I[9], \
  1535 + I[10] = I[11], I[11] = I[12], I[12] = I[13], I[13] = I[14], \
  1536 + I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], \
  1537 + I[20] = I[21], I[21] = I[22], I[22] = I[23], I[23] = I[24], \
  1538 + _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x)
  1539 +
  1540 +#define cimg_for6x6(img,x,y,z,c,I,T) \
  1541 + cimg_for6((img)._height,y) for (int x = 0, \
  1542 + _p2##x = 0, _p1##x = 0, \
  1543 + _n1##x = 1>=(img)._width?(img).width() - 1:1, \
  1544 + _n2##x = 2>=(img)._width?(img).width() - 1:2, \
  1545 + _n3##x = (int)( \
  1546 + (I[0] = I[1] = I[2] = (T)(img)(_p2##x,_p2##y,z,c)), \
  1547 + (I[6] = I[7] = I[8] = (T)(img)(0,_p1##y,z,c)), \
  1548 + (I[12] = I[13] = I[14] = (T)(img)(0,y,z,c)), \
  1549 + (I[18] = I[19] = I[20] = (T)(img)(0,_n1##y,z,c)), \
  1550 + (I[24] = I[25] = I[26] = (T)(img)(0,_n2##y,z,c)), \
  1551 + (I[30] = I[31] = I[32] = (T)(img)(0,_n3##y,z,c)), \
  1552 + (I[3] = (T)(img)(_n1##x,_p2##y,z,c)), \
  1553 + (I[9] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1554 + (I[15] = (T)(img)(_n1##x,y,z,c)), \
  1555 + (I[21] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1556 + (I[27] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1557 + (I[33] = (T)(img)(_n1##x,_n3##y,z,c)), \
  1558 + (I[4] = (T)(img)(_n2##x,_p2##y,z,c)), \
  1559 + (I[10] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1560 + (I[16] = (T)(img)(_n2##x,y,z,c)), \
  1561 + (I[22] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1562 + (I[28] = (T)(img)(_n2##x,_n2##y,z,c)), \
  1563 + (I[34] = (T)(img)(_n2##x,_n3##y,z,c)), \
  1564 + 3>=(img)._width?(img).width() - 1:3); \
  1565 + (_n3##x<(img).width() && ( \
  1566 + (I[5] = (T)(img)(_n3##x,_p2##y,z,c)), \
  1567 + (I[11] = (T)(img)(_n3##x,_p1##y,z,c)), \
  1568 + (I[17] = (T)(img)(_n3##x,y,z,c)), \
  1569 + (I[23] = (T)(img)(_n3##x,_n1##y,z,c)), \
  1570 + (I[29] = (T)(img)(_n3##x,_n2##y,z,c)), \
  1571 + (I[35] = (T)(img)(_n3##x,_n3##y,z,c)),1)) || \
  1572 + _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3## x = _n2##x = --_n1##x); \
  1573 + I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], \
  1574 + I[6] = I[7], I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], \
  1575 + I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \
  1576 + I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \
  1577 + I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], \
  1578 + I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \
  1579 + _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)
  1580 +
  1581 +#define cimg_for_in6x6(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1582 + cimg_for_in6((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)x0, \
  1583 + _p2##x = x - 2<0?0:x - 2, \
  1584 + _p1##x = x - 1<0?0:x - 1, \
  1585 + _n1##x = x + 1>=(int)(img)._width?(img).width() - 1:x + 1, \
  1586 + _n2##x = x + 2>=(int)(img)._width?(img).width() - 1:x + 2, \
  1587 + _n3##x = (int)( \
  1588 + (I[0] = (T)(img)(_p2##x,_p2##y,z,c)), \
  1589 + (I[6] = (T)(img)(_p2##x,_p1##y,z,c)), \
  1590 + (I[12] = (T)(img)(_p2##x,y,z,c)), \
  1591 + (I[18] = (T)(img)(_p2##x,_n1##y,z,c)), \
  1592 + (I[24] = (T)(img)(_p2##x,_n2##y,z,c)), \
  1593 + (I[30] = (T)(img)(_p2##x,_n3##y,z,c)), \
  1594 + (I[1] = (T)(img)(_p1##x,_p2##y,z,c)), \
  1595 + (I[7] = (T)(img)(_p1##x,_p1##y,z,c)), \
  1596 + (I[13] = (T)(img)(_p1##x,y,z,c)), \
  1597 + (I[19] = (T)(img)(_p1##x,_n1##y,z,c)), \
  1598 + (I[25] = (T)(img)(_p1##x,_n2##y,z,c)), \
  1599 + (I[31] = (T)(img)(_p1##x,_n3##y,z,c)), \
  1600 + (I[2] = (T)(img)(x,_p2##y,z,c)), \
  1601 + (I[8] = (T)(img)(x,_p1##y,z,c)), \
  1602 + (I[14] = (T)(img)(x,y,z,c)), \
  1603 + (I[20] = (T)(img)(x,_n1##y,z,c)), \
  1604 + (I[26] = (T)(img)(x,_n2##y,z,c)), \
  1605 + (I[32] = (T)(img)(x,_n3##y,z,c)), \
  1606 + (I[3] = (T)(img)(_n1##x,_p2##y,z,c)), \
  1607 + (I[9] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1608 + (I[15] = (T)(img)(_n1##x,y,z,c)), \
  1609 + (I[21] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1610 + (I[27] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1611 + (I[33] = (T)(img)(_n1##x,_n3##y,z,c)), \
  1612 + (I[4] = (T)(img)(_n2##x,_p2##y,z,c)), \
  1613 + (I[10] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1614 + (I[16] = (T)(img)(_n2##x,y,z,c)), \
  1615 + (I[22] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1616 + (I[28] = (T)(img)(_n2##x,_n2##y,z,c)), \
  1617 + (I[34] = (T)(img)(_n2##x,_n3##y,z,c)), \
  1618 + x + 3>=(int)(img)._width?(img).width() - 1:x + 3); \
  1619 + x<=(int)(x1) && ((_n3##x<(img).width() && ( \
  1620 + (I[5] = (T)(img)(_n3##x,_p2##y,z,c)), \
  1621 + (I[11] = (T)(img)(_n3##x,_p1##y,z,c)), \
  1622 + (I[17] = (T)(img)(_n3##x,y,z,c)), \
  1623 + (I[23] = (T)(img)(_n3##x,_n1##y,z,c)), \
  1624 + (I[29] = (T)(img)(_n3##x,_n2##y,z,c)), \
  1625 + (I[35] = (T)(img)(_n3##x,_n3##y,z,c)),1)) || \
  1626 + _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3## x = _n2##x = --_n1##x)); \
  1627 + I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], \
  1628 + I[6] = I[7], I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], \
  1629 + I[12] = I[13], I[13] = I[14], I[14] = I[15], I[15] = I[16], I[16] = I[17], \
  1630 + I[18] = I[19], I[19] = I[20], I[20] = I[21], I[21] = I[22], I[22] = I[23], \
  1631 + I[24] = I[25], I[25] = I[26], I[26] = I[27], I[27] = I[28], I[28] = I[29], \
  1632 + I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], I[34] = I[35], \
  1633 + _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)
  1634 +
  1635 +#define cimg_for7x7(img,x,y,z,c,I,T) \
  1636 + cimg_for7((img)._height,y) for (int x = 0, \
  1637 + _p3##x = 0, _p2##x = 0, _p1##x = 0, \
  1638 + _n1##x = 1>=(img)._width?(img).width() - 1:1, \
  1639 + _n2##x = 2>=(img)._width?(img).width() - 1:2, \
  1640 + _n3##x = (int)( \
  1641 + (I[0] = I[1] = I[2] = I[3] = (T)(img)(_p3##x,_p3##y,z,c)), \
  1642 + (I[7] = I[8] = I[9] = I[10] = (T)(img)(0,_p2##y,z,c)), \
  1643 + (I[14] = I[15] = I[16] = I[17] = (T)(img)(0,_p1##y,z,c)), \
  1644 + (I[21] = I[22] = I[23] = I[24] = (T)(img)(0,y,z,c)), \
  1645 + (I[28] = I[29] = I[30] = I[31] = (T)(img)(0,_n1##y,z,c)), \
  1646 + (I[35] = I[36] = I[37] = I[38] = (T)(img)(0,_n2##y,z,c)), \
  1647 + (I[42] = I[43] = I[44] = I[45] = (T)(img)(0,_n3##y,z,c)), \
  1648 + (I[4] = (T)(img)(_n1##x,_p3##y,z,c)), \
  1649 + (I[11] = (T)(img)(_n1##x,_p2##y,z,c)), \
  1650 + (I[18] = (T)(img)(_n1##x,_p1##y,z,c)), \
  1651 + (I[25] = (T)(img)(_n1##x,y,z,c)), \
  1652 + (I[32] = (T)(img)(_n1##x,_n1##y,z,c)), \
  1653 + (I[39] = (T)(img)(_n1##x,_n2##y,z,c)), \
  1654 + (I[46] = (T)(img)(_n1##x,_n3##y,z,c)), \
  1655 + (I[5] = (T)(img)(_n2##x,_p3##y,z,c)), \
  1656 + (I[12] = (T)(img)(_n2##x,_p2##y,z,c)), \
  1657 + (I[19] = (T)(img)(_n2##x,_p1##y,z,c)), \
  1658 + (I[26] = (T)(img)(_n2##x,y,z,c)), \
  1659 + (I[33] = (T)(img)(_n2##x,_n1##y,z,c)), \
  1660 + (I[40] = (T)(img)(_n2##x,_n2##y,z,c)), \
  1661 + (I[47] = (T)(img)(_n2##x,_n3##y,z,c)), \
  1662 + 3>=(img)._width?(img).width() - 1:3); \
  1663 + (_n3##x<(img).width() && ( \
  1664 + (I[6] = (T)(img)(_n3##x,_p3##y,z,c)), \
  1665 + (I[13] = (T)(img)(_n3##x,_p2##y,z,c)), \
  1666 + (I[20] = (T)(img)(_n3##x,_p1##y,z,c)), \
  1667 + (I[27] = (T)(img)(_n3##x,y,z,c)), \
  1668 + (I[34] = (T)(img)(_n3##x,_n1##y,z,c)), \
  1669 + (I[41] = (T)(img)(_n3##x,_n2##y,z,c)), \
  1670 + (I[48] = (T)(img)(_n3##x,_n3##y,z,c)),1)) || \
  1671 + _n2##x==--_n3##x || _n1##x==--_n2##x || x==(_n3##x = _n2##x = --_n1##x); \
  1672 + I[0] = I[1], I[1] = I[2], I[2] = I[3], I[3] = I[4], I[4] = I[5], I[5] = I[6], \
  1673 + I[7] = I[8], I[8] = I[9], I[9] = I[10], I[10] = I[11], I[11] = I[12], I[12] = I[13], \
  1674 + I[14] = I[15], I[15] = I[16], I[16] = I[17], I[17] = I[18], I[18] = I[19], I[19] = I[20], \
  1675 + I[21] = I[22], I[22] = I[23], I[23] = I[24], I[24] = I[25], I[25] = I[26], I[26] = I[27], \
  1676 + I[28] = I[29], I[29] = I[30], I[30] = I[31], I[31] = I[32], I[32] = I[33], I[33] = I[34], \
  1677 + I[35] = I[36], I[36] = I[37], I[37] = I[38], I[38] = I[39], I[39] = I[40], I[40] = I[41], \
  1678 + I[42] = I[43], I[43] = I[44], I[44] = I[45], I[45] = I[46], I[46] = I[47], I[47] = I[48], \
  1679 + _p3##x = _p2##x, _p2##x = _p1##x, _p1##x = x++, ++_n1##x, ++_n2##x, ++_n3##x)
  1680 +
  1681 +#define cimg_for_in7x7(img,x0,y0,x1,y1,x,y,z,c,I,T) \
  1682 + cimg_for_in7((img)._height,y0,y1,y) for (int x = (int)(x0)<0?0:(int)(x0), \
  1683 + _p3##x = x - 3<0?0:x - 3, \
  1684 + _p2##x = x - 2<0?0:x - 2, \
  1685 + _p1##x = x - 1<0?0:x - 1, \
  1686 + _n1##x = x + 1>=(int)(img)._width?(img).width() - 1:x + 1, \
  1687 + _n2##x = x + 2>=(int)(img)._width?(img).width() - 1:x + 2, \
  1688 + _n3##x = (int)( \
  1689 + (I[0] = (T)(img)(_p3##x,_p3##y,z,c)), \
  1690 + (I[7] = (T)(img)(_p3##x,_p2##y,z,c)), \
  1691 + (I[14] = (T)(img)(_p3##x,_p1##y,z,c)), \
  1692 + (I[21] = (T)(img)(_p3##x,y,z,c)), \
  1693 + (I[28] = (T)(img)(_p3##x,_n1##y,z,c)), \
  1694 + (I[35] = (T)(img)(_p3##x,_n2##y,z,c)), \
  1695