Xargon/ES-DE
1
0
Fork 0
mirror of https://github.com/RetroDECK/ES-DE.git synced 2024-11-24 23:25:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ES-DE/external/CImg/examples/generate_loop_macros.cpp

354 lines
17 KiB
C++
Raw Permalink Blame History

/*
#
# File : generate_loop_macros.cpp
# ( C++ source file )
#
# Description : Generate C++ macros to deal with MxN[xP] neighborhood
# loops within the CImg Library.
# This file is a part of the CImg Library project.
# ( http://cimg.eu )
#
# Copyright : David Tschumperlé
# ( http://tschumperle.users.greyc.fr/ )
#
# License : CeCILL v2.0
# ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )
#
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
#
*/
#include "CImg.h"
using namespace cimg_library;
// Generate macro(s) 'cimg_forN(i,bound)'
//----------------------------------------
void generate_forN(const unsigned int N) {
if (N>=2) {
const unsigned int Nn = N/2, Np = Nn - ((N + 1)%2);
std::printf("#define cimg_for%u(bound,i) for (int i = 0, \\\n",N);
for (unsigned int k = 0; k<Np; ++k) std::printf(" _p%u##i = 0,",Np - k);
std::printf(" \\\n");
for (unsigned int k = 1; k<=Nn; ++k)
std::printf(" _n%u##i = %u>=(int)(bound)?(int)(bound) - 1:%u%c \\\n",k,k,k,k==Nn?';':',');
std::printf(" _n%u##i<(int)(bound) || ",Nn);
for (unsigned int k = Nn - 1; k>=1; --k) std::printf("_n%u##i==--_n%u##i || ",k,k + 1);
std::printf("\\\n i==(");
for (unsigned int k = Nn; k>=2; --k) std::printf("_n%u##i = ",k);
std::printf("--_n1##i); \\\n ");
for (unsigned int k = Np; k>=2; --k) std::printf("_p%u##i = _p%u##i, ",k,k - 1);
if (Np) std::printf("_p1##i = i++, \\\n ");
else std::printf(" ++i, ");
for (unsigned int k = 1; k<Nn; ++k) std::printf("++_n%u##i, ",k);
std::printf("++_n%u##i)\n\n",Nn);
std::printf("#define cimg_for%uX(img,x) cimg_for%u((img)._width,x)\n",N,N);
std::printf("#define cimg_for%uY(img,y) cimg_for%u((img)._height,y)\n",N,N);
std::printf("#define cimg_for%uZ(img,z) cimg_for%u((img)._depth,z)\n",N,N);
std::printf("#define cimg_for%uC(img,c) cimg_for%u((img)._spectrum,c)\n",N,N);
std::printf("#define cimg_for%uXY(img,x,y) cimg_for%uY(img,y) cimg_for%uX(img,x)\n",N,N,N);
std::printf("#define cimg_for%uXZ(img,x,z) cimg_for%uZ(img,z) cimg_for%uX(img,x)\n",N,N,N);
std::printf("#define cimg_for%uXC(img,x,c) cimg_for%uC(img,c) cimg_for%uX(img,x)\n",N,N,N);
std::printf("#define cimg_for%uYZ(img,y,z) cimg_for%uZ(img,z) cimg_for%uY(img,y)\n",N,N,N);
std::printf("#define cimg_for%uYC(img,y,c) cimg_for%uC(img,c) cimg_for%uY(img,y)\n",N,N,N);
std::printf("#define cimg_for%uZC(img,z,c) cimg_for%uC(img,c) cimg_for%uZ(img,z)\n",N,N,N);
std::printf("#define cimg_for%uXYZ(img,x,y,z) cimg_for%uZ(img,z) cimg_for%uXY(img,x,y)\n",N,N,N);
std::printf("#define cimg_for%uXZC(img,x,z,c) cimg_for%uC(img,c) cimg_for%uXZ(img,x,z)\n",N,N,N);
std::printf("#define cimg_for%uYZC(img,y,z,c) cimg_for%uC(img,c) cimg_for%uYZ(img,y,z)\n",N,N,N);
std::printf("#define cimg_for%uXYZC(img,x,y,z,c) cimg_for%uC(img,c) cimg_for%uXYZ(img,x,y,z)\n\n",N,N,N);
}
}
// Generate macro(s) 'cimg_for_inN(i,bound)'
//------------------------------------------
void generate_for_inN(const unsigned int N) {
if (N>=2) {
const unsigned int Nn = N/2, Np = Nn - ((N + 1)%2);
std::printf("#define cimg_for_in%u(bound,i0,i1,i) for (int i = (int)(i0)<0?0:(int)(i0), \\\n",N);
for (unsigned int k = 0; k<Np; ++k)
std::printf(" _p%u##i = i - %u<0?0:i-%u, \\\n",Np - k,Np - k,Np - k);
for (unsigned int k = 1; k<=Nn; ++k)
std::printf(" _n%u##i = i + %u>=(int)(bound)?(int)(bound) - 1:i + %u%c \\\n",k,k,k,k==Nn?';':',');
std::printf(" i<=(int)(i1) && (_n%u##i<(int)(bound) || ",Nn);
for (unsigned int k = Nn - 1; k>=1; --k) std::printf("_n%u##i==--_n%u##i || ",k,k + 1);
std::printf("\\\n i==(");
for (unsigned int k = Nn; k>=2; --k) std::printf("_n%u##i = ",k);
std::printf("--_n1##i)); \\\n ");
for (unsigned int k = Np; k>=2; --k) std::printf("_p%u##i = _p%u##i, ",k,k - 1);
if (Np) std::printf("_p1##i = i++, \\\n ");
else std::printf(" ++i, ");
for (unsigned int k = 1; k<Nn; ++k) std::printf("++_n%u##i, ",k);
std::printf("++_n%u##i)\n\n",Nn);
}
std::printf("#define cimg_for_in%uX(img,x0,x1,x) cimg_for_in%u((img)._width,x0,x1,x)\n",N,N);
std::printf("#define cimg_for_in%uY(img,y0,y1,y) cimg_for_in%u((img)._height,y0,y1,y)\n",N,N);
std::printf("#define cimg_for_in%uZ(img,z0,z1,z) cimg_for_in%u((img)._depth,z0,z1,z)\n",N,N);
std::printf("#define cimg_for_in%uC(img,c0,c1,c) cimg_for_in%u((img)._spectrum,c0,c1,c)\n",N,N);
std::printf("#define cimg_for_in%uXY(img,x0,y0,x1,y1,x,y) cimg_for_in%uY(img,y0,y1,y) "
"cimg_for_in%uX(img,x0,x1,x)\n",N,N,N);
std::printf("#define cimg_for_in%uXZ(img,x0,z0,x1,z1,x,z) cimg_for_in%uZ(img,z0,z1,z) "
"cimg_for_in%uX(img,x0,x1,x)\n",N,N,N);
std::printf("#define cimg_for_in%uXC(img,x0,c0,x1,c1,x,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uX(img,x0,x1,x)\n",N,N,N);
std::printf("#define cimg_for_in%uYZ(img,y0,z0,y1,z1,y,z) cimg_for_in%uZ(img,z0,z1,z) "
"cimg_for_in%uY(img,y0,y1,y)\n",N,N,N);
std::printf("#define cimg_for_in%uYC(img,y0,c0,y1,c1,y,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uY(img,y0,y1,y)\n",N,N,N);
std::printf("#define cimg_for_in%uZC(img,z0,c0,z1,c1,z,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uZ(img,z0,z1,z)\n",N,N,N);
std::printf("#define cimg_for_in%uXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z) cimg_for_in%uZ(img,z0,z1,z) "
"cimg_for_in%uXY(img,x0,y0,x1,y1,x,y)\n",N,N,N);
std::printf("#define cimg_for_in%uXZC(img,x0,z0,c0,x1,y1,c1,x,z,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uXZ(img,x0,y0,x1,y1,x,z)\n",N,N,N);
std::printf("#define cimg_for_in%uYZC(img,y0,z0,c0,y1,z1,c1,y,z,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uYZ(img,y0,z0,y1,z1,y,z)\n",N,N,N);
std::printf("#define cimg_for_in%uXYZC(img,x0,y0,z0,c0,x1,y1,z1,c1,x,y,z,c) cimg_for_in%uC(img,c0,c1,c) "
"cimg_for_in%uXYZ(img,x0,y0,z0,x1,y1,z1,x,y,z)\n\n",N,N,N);
}
// Generate macro 'cimg_forMxN[xP](img,x,y,z,c,I,T)'
//--------------------------------------------------
void generate_forMxNxP(const unsigned int M, const unsigned int N, const unsigned int P) {
char indx[16], indy[16], indz[16];
const int
Mn = (int)(M/2), Mp = (int)(Mn - ((M + 1)%2)),
Nn = (int)(N/2), Np = (int)(Nn - ((N + 1)%2)),
Pn = (int)(P/2), Pp = (int)(Pn - ((P + 1)%2)),
last = (int)(M*N*P);
if (P>1) std::printf("#define cimg_for%ux%ux%u(img,x,y,z,c,I,T) \\\n cimg_for%u((img)._depth,z)",M,N,P,P);
else std::printf("#define cimg_for%ux%u(img,x,y,z,c,I,T) \\\n",M,N);
if (N>1) std::printf(" cimg_for%u((img)._height,y) ",N);
else std::printf(" cimg_forY(img,y) ");
std::printf("for (int x = 0%c \\\n",M>1?',':';');
for (int k = Mp; k>=1; --k) std::printf(" _p%u##x = 0%s",k,k==1?", \\\n":",");
for (int k = 1; k<Mn; ++k) std::printf(" _n%u##x = %u>=((img)._width)?(img).width() - 1:%u, \\\n",k,k,k);
if (M>1) {
std::printf(" _n%u##x = (int)( \\\n ",Mn);
for (int k = 0, z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y) {
for (int x = -Mp; x<=0; ++x) { std::printf("%sI[%d] =",k && x==-Mp?" (":(x==-Mp?"(":" "),k); ++k; }
k+=Mn;
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" (T)(img)(0,%sy,%sz,c))%s",indy,indz,k>=last?",":", \\\n");
}
std::printf(" \\\n");
for (int x = 1; x<Mn; ++x)
for (int z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y) {
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" (I[%d] = (T)(img)(_n%d##x,%sy,%sz,c)), \\\n",(Mp + x) + (y + Np)*M + (z + Pp)*M*N,x,indy,indz);
}
std::printf(" %u>=((img)._width)?(img).width() - 1:%u); \\\n",Mn,Mn);
}
if (M>1) std::printf(" (_n%u##x",Mn); else std::printf(" (x");
std::printf("<(img).width() && ( \\\n");
for (int z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y) {
if (M>1) std::sprintf(indx,"_n%d##",Mn); else indx[0]='\0';
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" (I[%d] = (T)(img)(%sx,%sy,%sz,c))%s",M - 1 + (y + Np)*M + (z + Pp)*M*N,indx,indy,indz,
z==Pn && y==Nn?",1))":", \\\n");
}
if (M>1) {
std::printf(" || \\\n ");
for (int k = Mn - 1; k>=1; --k) std::printf("_n%d##x==--_n%u##x || ",k,k + 1);
std::printf("x==(");
for (int k = Mn; k>=2; --k) std::printf("_n%d##x = ",k);
std::printf("--_n1##x); \\\n");
} else std::printf("; \\\n");
if (M>1) {
for (unsigned int k = 0, z = 0; z<P; ++z)
for (unsigned int y = 0; y<N; ++y) {
for (unsigned int x = 0; x<M - 1; ++x) {
std::printf(" I[%d] = I[%d],",k,k + 1);
++k;
}
std::printf(" \\\n");
++k;
}
std::printf(" ");
for (int k = Mp; k>=2; --k) std::printf("_p%d##x = _p%d##x, ",k,k - 1);
if (M>2) std::printf("_p1##x = x++, "); else std::printf("++x, ");
for (int k = 1; k<=Mn - 1; ++k) std::printf("++_n%d##x, ",k);
std::printf("++_n%d##x)\n\n",Mn);
} else std::printf(" ++x)\n\n");
}
// Generate macro 'cimg_for_inMxN[xP](img,x,y,z,c,I,T)'
//-----------------------------------------------------
void generate_for_inMxNxP(const unsigned int M, const unsigned int N, const unsigned int P) {
char indx[16], indy[16], indz[16];
const int
Mn = (int)(M/2), Mp = (int)(Mn - ((M + 1)%2)),
Nn = (int)(N/2), Np = (int)(Nn - ((N + 1)%2)),
Pn = (int)(P/2), Pp = (int)(Pn - ((P + 1)%2));
if (P>1)
std::printf("#define cimg_for_in%ux%ux%u(img,x0,y0,z0,x1,y1,z1,x,y,z,c,I,T) \\\n "
"cimg_for_in%u((img)._depth,z0,z1,z)",M,N,P,P);
else std::printf("#define cimg_for_in%ux%u(img,x0,y0,x1,y1,x,y,z,c,I,T) \\\n",M,N);
if (N>1) std::printf(" cimg_for_in%u((img)._height,y0,y1,y) ",N);
else std::printf(" cimg_for_inY(img,y0,y1,y) ");
std::printf("for (int x = (int)(x0)<0?0:(int)(x0)%c \\\n",M>1?',':';');
for (int k = Mp; k>=1; --k) std::printf(" _p%u##x = x - %u<0?0:x - %u, \\\n",k,k,k);
for (int k = 1; k<Mn; ++k) std::printf(" _n%u##x = x + %u>=(img).width()?(img).width() - 1:x + %u, \\\n",k,k,k);
if (M>1) {
std::printf(" _n%u##x = (int)( \\\n",Mn);
for (int x = -Mp; x<Mn; ++x)
for (int z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y) {
if (x<0) std::sprintf(indx,"_p%d##",-x); else if (x>0) std::sprintf(indx,"_n%d##",x); else indx[0]='\0';
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" (I[%d] = (T)(img)(%sx,%sy,%sz,c)), \\\n",(Mp + x) + (y + Np)*M + (z + Pp)*M*N,indx,indy,indz);
}
std::printf(" x + %u>=(img).width()?(img).width() - 1:x + %u); \\\n",Mn,Mn);
}
std::printf(" x<=(int)(x1) && (");
if (M>1) std::printf("(_n%u##x",Mn); else std::printf("(x");
std::printf("<(img).width() && ( \\\n");
for (int z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y) {
if (M>1) std::sprintf(indx,"_n%d##",Mn); else indx[0]='\0';
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" (I[%d] = (T)(img)(%sx,%sy,%sz,c))%s",M - 1 + (y + Np)*M + (z + Pp)*M*N,indx,indy,indz,
z==Pn && y==Nn?",1))":", \\\n");
}
if (M>1) {
std::printf(" || \\\n ");
for (int k = Mn - 1; k>=1; --k) std::printf("_n%d##x==--_n%u##x || ",k,k + 1);
std::printf("x==(");
for (int k = Mn; k>=2; --k) std::printf("_n%d##x = ",k);
std::printf("--_n1##x)); \\\n");
} else std::printf("); \\\n");
if (M>1) {
for (unsigned int k = 0, z = 0; z<P; ++z)
for (unsigned int y = 0; y<N; ++y) {
for (unsigned int x = 0; x<M - 1; ++x) {
std::printf(" I[%d] = I[%d],",k,k + 1);
++k;
}
std::printf(" \\\n");
++k;
}
std::printf(" ");
for (int k = Mp; k>=2; --k) std::printf("_p%d##x = _p%d##x, ",k,k - 1);
if (M>2) std::printf("_p1##x = x++, "); else std::printf("++x, ");
for (int k = 1; k<=Mn - 1; ++k) std::printf("++_n%d##x, ",k);
std::printf("++_n%d##x)\n\n",Mn);
} else std::printf(" ++x)\n\n");
}
// Generate macro 'cimg_getMxN[xP](img,x,y,z,c,I,T)'
//--------------------------------------------------
void generate_getMxNxP(const unsigned int M, const unsigned int N, const unsigned int P) {
const int
Mn = (int)(M/2), Mp = (int)(Mn - ((M + 1)%2)),
Nn = (int)(N/2), Np = (int)(Nn - ((N + 1)%2)),
Pn = (int)(P/2), Pp = (int)(Pn - ((P + 1)%2)),
last = M*N*P - 1;
if (P>1) std::printf("#define cimg_get%ux%ux%u(img,x,y,z,c,I,T) \\\n",M,N,P);
else std::printf("#define cimg_get%ux%u(img,x,y,z,c,I,T) \\\n",M,N);
char indx[16], indy[16], indz[16];
for (int k = 0, z = -Pp; z<=Pn; ++z)
for (int y = -Np; y<=Nn; ++y)
for (int x = -Mp; x<=Mn; ++x) {
if (x<0) std::sprintf(indx,"_p%d##",-x); else if (x>0) std::sprintf(indx,"_n%d##",x); else indx[0]='\0';
if (y<0) std::sprintf(indy,"_p%d##",-y); else if (y>0) std::sprintf(indy,"_n%d##",y); else indy[0]='\0';
if (z<0) std::sprintf(indz,"_p%d##",-z); else if (z>0) std::sprintf(indz,"_n%d##",z); else indz[0]='\0';
std::printf(" I[%u] = (T)(img)(%sx,%sy,%sz,c)%s",k,indx,indy,indz,
k==last?";\n\n":(x==Mn?", \\\n":","));
++k;
}
}
//-----------------
// Main Procedure
//-----------------
int main(int argc, char **argv) {
cimg_usage("Generate C++ macros to deal with MxN[xP] neighborhood loops within the CImg Library");
// Read command line arguments
//----------------------------
const char *const size = cimg_option("-s","5x4","Size of the neighborhood");
const bool do_forN = cimg_option("-forN",true,"Generate 'cimg_forN()'");
const bool do_for_inN = cimg_option("-for_inN",true,"Generate 'cimg_for_inN()'");
const bool do_for = cimg_option("-for",true,"Generate 'cimg_forMxNxP()'");
const bool do_for_in = cimg_option("-for_in",true,"Generate 'cimg_for_inMxNxP()'");
const bool do_get = cimg_option("-get",true,"Generate 'cimg_getMxNxP()'");
if (cimg_option("-h",false,0)) std::exit(0);
unsigned int M = 1, N = 1 , P = 1;
std::sscanf(size,"%u%*c%u%*c%u",&M,&N,&P);
if (!M || !N || !P || (M==1 && N==1 && P==1)) {
std::fprintf(stderr,"\n%s : Error, bad neighborhood size '%s'\n",argv[0],size);
std::exit(0);
}
if (!do_forN && !do_get && !do_for) return 0;
if (P>1)
std::printf("// Define %ux%ux%u loop macros\n"
"//----------------------------\n",M,N,P);
else
std::printf("// Define %ux%u loop macros\n"
"//-------------------------\n",M,N);
if (do_forN) {
if (N>1) generate_forN(N);
if (P>1 && P!=N) generate_forN(P);
}
if (do_for_inN) {
if (N>1) generate_for_inN(N);
if (P>1 && P!=N) generate_for_inN(P);
}
if (do_for) generate_forMxNxP(M,N,P);
if (do_for_in) generate_for_inMxNxP(M,N,P);
if (do_get) generate_getMxNxP(M,N,P);
return 0;
}
Reference in a new issue View git blame Copy permalink