1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/PTdecode/CImg-1.3.0/examples/CImg_demo.cpp Mon Aug 03 14:09:20 2009 +0100 1.3 @@ -0,0 +1,1668 @@ 1.4 +/* 1.5 + # 1.6 + # File : CImg_demo.cpp 1.7 + # ( C++ source file ) 1.8 + # 1.9 + # Description : A multi-part demo demonstrating some of the CImg capabilities. 1.10 + # This file is a part of the CImg Library project. 1.11 + # ( http://cimg.sourceforge.net ) 1.12 + # 1.13 + # Copyright : David Tschumperle 1.14 + # ( http://www.greyc.ensicaen.fr/~dtschump/ ) 1.15 + # 1.16 + # License : CeCILL v2.0 1.17 + # ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html ) 1.18 + # 1.19 + # This software is governed by the CeCILL license under French law and 1.20 + # abiding by the rules of distribution of free software. You can use, 1.21 + # modify and/ or redistribute the software under the terms of the CeCILL 1.22 + # license as circulated by CEA, CNRS and INRIA at the following URL 1.23 + # "http://www.cecill.info". 1.24 + # 1.25 + # As a counterpart to the access to the source code and rights to copy, 1.26 + # modify and redistribute granted by the license, users are provided only 1.27 + # with a limited warranty and the software's author, the holder of the 1.28 + # economic rights, and the successive licensors have only limited 1.29 + # liability. 1.30 + # 1.31 + # In this respect, the user's attention is drawn to the risks associated 1.32 + # with loading, using, modifying and/or developing or reproducing the 1.33 + # software by the user in light of its specific status of free software, 1.34 + # that may mean that it is complicated to manipulate, and that also 1.35 + # therefore means that it is reserved for developers and experienced 1.36 + # professionals having in-depth computer knowledge. Users are therefore 1.37 + # encouraged to load and test the software's suitability as regards their 1.38 + # requirements in conditions enabling the security of their systems and/or 1.39 + # data to be ensured and, more generally, to use and operate it in the 1.40 + # same conditions as regards security. 1.41 + # 1.42 + # The fact that you are presently reading this means that you have had 1.43 + # knowledge of the CeCILL license and that you accept its terms. 1.44 + # 1.45 +*/ 1.46 + 1.47 +// Include static image data, so that the exe does not depend on external image files. 1.48 +#include "img/CImg_demo.h" 1.49 + 1.50 +// Include CImg library header. 1.51 +#include "CImg.h" 1.52 +using namespace cimg_library; 1.53 + 1.54 +// The lines below are necessary when using a non-standard compiler such as visualcpp6. 1.55 +#ifdef cimg_use_visualcpp6 1.56 +#define std 1.57 +#endif 1.58 +#ifdef min 1.59 +#undef min 1.60 +#undef max 1.61 +#endif 1.62 + 1.63 +// Item : Blurring Gradient 1.64 +//---------------------------- 1.65 +void* item_blurring_gradient() { 1.66 + 1.67 + // Create color image 'milla'. 1.68 + const CImg<> src(data_milla,211,242,1,3); 1.69 + 1.70 + // Compute 2D gradient (spatial derivatives). 1.71 + CImgList<> grad = src.get_gradient(); 1.72 + 1.73 + // Create visualization list with three images, the second one being 1.74 + // a normalized version of the gradient norm. 1.75 + CImgList<unsigned char> visu = src<<(grad[0].pow(2) + grad[1].pow(2)).sqrt().normalize(0,255)<<src; 1.76 + 1.77 + // Create and Pop-up display window. 1.78 + CImgDisplay disp(visu,"[#1] - Color Image, Gradient Norm and Blurring Gradient",0); 1.79 + 1.80 + // Start animation loop (until ESC or Q key is pressed, or display window closed). 1.81 + for (double sigma = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; sigma+=0.05) { 1.82 + 1.83 + // Compute blurred version of the gradient norm. 1.84 + visu[2] = visu[1].get_blur((float)cimg::abs(30*std::cos(sigma))).normalize(0,255); 1.85 + 1.86 + // Refresh display window. 1.87 + disp.resize(false).display(visu).wait(20); 1.88 + } 1.89 + return 0; 1.90 +} 1.91 + 1.92 +// Item : Rotozoom 1.93 +//----------------- 1.94 +void* item_rotozoom() { 1.95 + 1.96 + // Create color image 'milla' and resize it to 400x300. 1.97 + CImg<unsigned char> src = CImg<unsigned char>(data_milla,211,242,1,3,false).resize(400,300,1,3,3), img(src); 1.98 + 1.99 + // Create display window. 1.100 + CImgDisplay disp(img.dimx(),img.dimy(),"[#2] - Rotozoom",0); 1.101 + 1.102 + float alpha = 0, t = 0, angle = 0, zoom0 = -0.9f; 1.103 + const unsigned char color[] = { 16,32,64 }; 1.104 + 1.105 + // Start animation loop. 1.106 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.107 + 1.108 + // Add weird color effect on the image. 1.109 + cimg_forYV(src,y,k) { 1.110 + const int xc = 4*src.dimx() + (int)(60*std::sin((float)y*3/src.dimy()+10*t)); 1.111 + cimg_forX(src,x) { 1.112 + const float val = (float)(src((xc+x)%src.dimx(),y,0,k)* 1.113 + (1.3f+0.20*std::sin(alpha+k*k*((float)src.dimx()/2-x)* 1.114 + ((float)src.dimy()/2-y)*std::cos(t)/300.0))); 1.115 + img(x,y,0,k) = (unsigned char)(val>255.0f?255:val); 1.116 + } 1.117 + } 1.118 + 1.119 + // Rotate/zoom the resulting image, and display it. 1.120 + const float zoom = (float)(zoom0 + 0.3f*(1+std::cos(3*t))); 1.121 + img.get_rotate(angle,0.5f*img.dimx(),0.5f*img.dimy(),1+zoom,2,0). 1.122 + draw_text(3,3,"Mouse buttons\nto zoom in/out",color,0,0.8f,24).display(disp.resize(false).wait(20)); 1.123 + 1.124 + // Smoothly move angle and zoom parameters 1.125 + alpha+=0.7f; t+=0.01f; angle+=0.8f; 1.126 + zoom0+=disp.button&1?0.1f:(disp.button&2?-0.1f:0); 1.127 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(400,400,false).toggle_fullscreen(false); 1.128 + } 1.129 + return 0; 1.130 +} 1.131 + 1.132 +// Item : Anisotropic Smoothing (Total variation PDE, explicit scheme) 1.133 +//-------------------------------------------------------------------- 1.134 +void* item_anisotropic_smoothing() { 1.135 + 1.136 + // Create color image 'milla' and noise it quite heavily with uniform noise. 1.137 + const CImg<> src = CImg<>(data_milla,211,242,1,3).noise(-30,1); 1.138 + 1.139 + // Create visualization list and corresponding display window. 1.140 + CImgList<> images(src,src); 1.141 + CImgDisplay disp(images,"[#3] - Anisotropic smoothing"); 1.142 + const float white[] = { 255,255,255 }, black[] = { 0,0,0 }; 1.143 + 1.144 + // Start PDE iterations 1.145 + for (unsigned int iter = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; ++iter) { 1.146 + 1.147 + // Compute PDE velocity field. 1.148 + CImg_3x3(I,float); 1.149 + CImg<> veloc(src); 1.150 + cimg_forV(src,k) cimg_for3x3(images[1],x,y,0,k,I) { 1.151 + const float 1.152 + ix = (Inc - Ipc)/2, 1.153 + iy = (Icn - Icp)/2, 1.154 + ng = (float)std::sqrt(1e-10f + ix*ix + iy*iy), 1.155 + ixx = Inc + Ipc - 2*Icc, 1.156 + iyy = Icn + Icp - 2*Icc, 1.157 + ixy = 0.25f*(Inn + Ipp - Ipn - Inp), 1.158 + iee = (ix*ix*iyy + iy*iy*ixx - 2*ix*iy*ixy)/(ng*ng); 1.159 + veloc(x,y,k) = iee/(0.1f+ng); 1.160 + } 1.161 + 1.162 + // Find adaptive time step and update current image. 1.163 + float m = 0, M = veloc.maxmin(m); 1.164 + veloc*=40.0f/cimg::max(cimg::abs(m),cimg::abs(M)); 1.165 + images[1]+=veloc; 1.166 + images[0].draw_text(0,0,"iter %u",white,black,1,11,iter); 1.167 + 1.168 + // Refresh display window (and resize it if necessary). 1.169 + disp.resize(false).display(images); 1.170 + } 1.171 + return 0; 1.172 +} 1.173 + 1.174 +// Item : Fractal Animation 1.175 +//-------------------------- 1.176 +void* item_fractal_animation() { 1.177 + 1.178 + // Create black 400x400 color image, and small 'noise' sprite. 1.179 + CImg<unsigned char> img(400,400,1,3,0), noise(3,2,1,3); 1.180 + 1.181 + // Create display window. 1.182 + CImgDisplay disp(img,"[#4] - Fractal Animation"); 1.183 + 1.184 + // Start animation loop. 1.185 + float zoom = 0; 1.186 + for (unsigned int iter = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; ++iter, zoom+=0.2f) { 1.187 + 1.188 + // Put a noisy sprite on the center, then rotate and zoom the whole image, to make the 'fractal' effect. 1.189 + img.draw_image((img.dimx() - noise.dimx())/2, 1.190 + (img.dimy() - noise.dimy())/2, 1.191 + noise.fill(0).noise(255,1)). 1.192 + rotate((float)(10*std::sin(iter/25.0)),0.5f*img.dimx(),0.5f*img.dimy(),(float)(1.04+0.02*std::sin(zoom/10)),0,0). 1.193 + resize(disp.resize(false)).display(disp.wait(25)); 1.194 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(400,400,false).toggle_fullscreen(false); 1.195 + } 1.196 + return 0; 1.197 +} 1.198 + 1.199 +// Item : Gamma Correction and Histogram Visualization 1.200 +//----------------------------------------------------- 1.201 +void* item_gamma_correction() { 1.202 + 1.203 + // Create color image 'milla' and normalize it in [0,1]. 1.204 + CImg<> img = CImg<>(data_milla,211,242,1,3).normalize(0,1); 1.205 + 1.206 + // Create visualization list (2 images). 1.207 + CImgList<unsigned char> visu(img*255.0, CImg<unsigned char>(512,300,1,3,0)); 1.208 + 1.209 + // Define graph and text colors. 1.210 + const unsigned char 1.211 + yellow[] = { 255,255,0 }, blue[] = { 0,155,255 }, blue2[] = { 0,0,255 }, 1.212 + blue3[] = { 0,0,155 }, white[] = { 255,255,255 }, green[] = { 100,255,100 }; 1.213 + 1.214 + // Create display window. 1.215 + CImgDisplay disp(visu,"[#5] - Gamma Corrected Image and Histogram (Click to set Gamma)"); 1.216 + 1.217 + // Enter event loop. 1.218 + for (double gamma = 1; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; ) { 1.219 + 1.220 + // Compute gamma-corrected version of the original image. 1.221 + cimg_forXYZV(visu[0],x,y,z,k) visu[0](x,y,z,k) = (unsigned char)(std::pow((double)img(x,y,z,k),1.0/gamma)*256); 1.222 + 1.223 + // Compute corresponding image histogram. 1.224 + const CImg<> hist = visu[0].get_histogram(50,0,255); 1.225 + 1.226 + // Draw image histogram as a bar graph in the visualization list (2nd image). 1.227 + visu[1].fill(0).draw_text(50,5,"Gamma = %.3g",white,0,1,24,gamma). 1.228 + draw_graph(hist,green,1,3,0,20000,0).draw_graph(hist,yellow,1,2,0,20000,0). 1.229 + draw_axis(0,256,20000,0,white,0.7f); 1.230 + const int xb = (int)(50+gamma*150); 1.231 + visu[1].draw_grid(20,20,0,0,false,false,white,0.3f,0xCCCCCCCC,0xCCCCCCCC). 1.232 + draw_rectangle(51,31,xb-1,39,blue2).draw_rectangle(50,30,xb,30,blue).draw_rectangle(xb,30,xb,40,blue). 1.233 + draw_rectangle(xb,40,50,39,blue3).draw_rectangle(50,30,51,40,blue3); 1.234 + 1.235 + // Check for button press from the user's mouse. 1.236 + if (disp.button && disp.mouse_x>=img.dimx()+50 && disp.mouse_x<=img.dimx()+450) 1.237 + gamma = (disp.mouse_x - img.dimx()-50)/150.0; 1.238 + 1.239 + // Refresh display window, and wait for a user event. 1.240 + disp.resize(disp,false).display(visu).wait(); 1.241 + } 1.242 + return 0; 1.243 +} 1.244 + 1.245 +// Item : Filled Triangles 1.246 +//------------------------- 1.247 +void* item_filled_triangles() { 1.248 + 1.249 + // Create a colored 640x480 background image which consists of different color shades. 1.250 + CImg<> background(640,480,1,3); 1.251 + cimg_forXY(background,x,y) background.fillV(x,y,0, 1.252 + x*std::cos(6.0*y/background.dimy())+y*std::sin(9.0*x/background.dimx()), 1.253 + x*std::sin(8.0*y/background.dimy())-y*std::cos(11.0*x/background.dimx()), 1.254 + x*std::cos(13.0*y/background.dimy())-y*std::sin(8.0*x/background.dimx())); 1.255 + background.normalize(0,180); 1.256 + 1.257 + // Init images and create display window. 1.258 + CImg<unsigned char> img0(background), img; 1.259 + unsigned char white[] = { 255,255,255 }, color[100][3]; 1.260 + CImgDisplay disp(img0,"[#6] - Filled Triangles (Click to shrink)"); 1.261 + 1.262 + // Define random properties (pos, size, colors, ..) for all triangles that will be displayed. 1.263 + float posx[100], posy[100], rayon[100], angle[100], veloc[100], opacity[100]; 1.264 + int num = 1; 1.265 + std::srand((unsigned int)time(NULL)); 1.266 + for (int k = 0; k<100; ++k) { 1.267 + posx[k] = (float)(cimg::rand()*img0.dimx()); 1.268 + posy[k] = (float)(cimg::rand()*img0.dimy()); 1.269 + rayon[k] = (float)(10+cimg::rand()*50); 1.270 + angle[k] = (float)(cimg::rand()*360); 1.271 + veloc[k] = (float)(cimg::rand()*20-10); 1.272 + color[k][0] = (unsigned char)(cimg::rand()*255); 1.273 + color[k][1] = (unsigned char)(cimg::rand()*255); 1.274 + color[k][2] = (unsigned char)(cimg::rand()*255); 1.275 + opacity[k] = (float)(0.3+1.5*cimg::rand()); 1.276 + } 1.277 + 1.278 + // Start animation loop. 1.279 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.280 + img = img0; 1.281 + 1.282 + // Draw each triangle on the background image. 1.283 + for (int k = 0; k<num; ++k) { 1.284 + const int 1.285 + x0 = (int)(posx[k] + rayon[k]*std::cos(angle[k]*cimg::valuePI/180)), 1.286 + y0 = (int)(posy[k] + rayon[k]*std::sin(angle[k]*cimg::valuePI/180)), 1.287 + x1 = (int)(posx[k] + rayon[k]*std::cos((angle[k]+120)*cimg::valuePI/180)), 1.288 + y1 = (int)(posy[k] + rayon[k]*std::sin((angle[k]+120)*cimg::valuePI/180)), 1.289 + x2 = (int)(posx[k] + rayon[k]*std::cos((angle[k]+240)*cimg::valuePI/180)), 1.290 + y2 = (int)(posy[k] + rayon[k]*std::sin((angle[k]+240)*cimg::valuePI/180)); 1.291 + if (k%10) img.draw_triangle(x0,y0,x1,y1,x2,y2,color[k],opacity[k]); 1.292 + else img.draw_triangle(x0,y0,x1,y1,x2,y2,img0,0,0,img0.dimx()-1,0,0,img.dimy()-1,opacity[k]); 1.293 + img.draw_triangle(x0,y0,x1,y1,x2,y2,white,opacity[k],~0U); 1.294 + 1.295 + // Make the triangles rotate, and check for mouse click event. 1.296 + // (to make triangles collapse or join). 1.297 + angle[k]+=veloc[k]; 1.298 + if (disp.mouse_x>0 && disp.mouse_y>0) { 1.299 + float u = disp.mouse_x - posx[k], v = disp.mouse_y - posy[k]; 1.300 + if (disp.button) { u=-u; v=-v; } 1.301 + posx[k]-=0.03f*u, posy[k]-=0.03f*v; 1.302 + if (posx[k]<0 || posx[k]>=img.dimx()) posx[k]=(float)(cimg::rand()*img.dimx()); 1.303 + if (posy[k]<0 || posy[k]>=img.dimy()) posy[k]=(float)(cimg::rand()*img.dimy()); 1.304 + } 1.305 + } 1.306 + 1.307 + // Display current animation framerate, and refresh display window. 1.308 + img.draw_text(5,5,"%u frames/s",white,0,0.5f,11,(unsigned int)disp.frames_per_second()); 1.309 + img0.resize(disp.display(img).resize(false).wait(20)); 1.310 + if (++num>100) num = 100; 1.311 + 1.312 + // Allow the user to toggle fullscreen mode, by pressing CTRL+F. 1.313 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(640,480,false).toggle_fullscreen(false); 1.314 + } 1.315 + return 0; 1.316 +} 1.317 + 1.318 +// Item : Mandelbrot/Julia Explorer 1.319 +//---------------------------------- 1.320 +void* item_mandelbrot_explorer() { 1.321 + 1.322 + // Define image canvas and corresponding display window. 1.323 + CImg<unsigned char> img(800,600,1,3,0); 1.324 + CImgDisplay disp(img); 1.325 + 1.326 + // Start main explorer loop. 1.327 + double juliar = 0, juliai = 0; 1.328 + for (bool endflag = false, fractal_type = false, smooth = false, show_help = true; !endflag;) { 1.329 + bool stopflag = false; 1.330 + double xmin, xmax, ymin, ymax; 1.331 + 1.332 + // Init default upper-left/lower-right coordinates of the fractal set. 1.333 + if (fractal_type) { xmin = -1.5; xmax = 1.5; ymin = -1.5; ymax = 1.5; juliar = 0.317; juliai = 0.029; } 1.334 + else { xmin = -2.25; xmax = 1.0; ymin = -1.5; ymax = 1.5; juliar = juliai = 0; } 1.335 + 1.336 + // Create random palette for displaying the fractal set. 1.337 + const CImg<unsigned char> palette = 1.338 + CImg<unsigned char>(256,1,1,3,16+120).noise(119,1).resize(1024,1,1,3,3).fillV(0,0,0,0,0,0); 1.339 + unsigned int maxiter = 64; 1.340 + 1.341 + // Enter event loop for the current fractal set. 1.342 + while (!stopflag) { 1.343 + 1.344 + // Draw Mandelbrot or Julia fractal set on the image. 1.345 + img.resize(disp.resize().set_title("[#7] - %s Set : (%g,%g)-(%g,%g), %s = (%g,%g) (%u iter.)", 1.346 + fractal_type?"Julia":"Mandelbrot",xmin,ymin,xmax,ymax, 1.347 + fractal_type?"c":"z0",juliar,juliai,maxiter)). 1.348 + fill(0).draw_mandelbrot(palette,1,xmin,ymin,xmax,ymax,maxiter,smooth,fractal_type,juliar,juliai); 1.349 + 1.350 + // Display help if necessary. 1.351 + if (show_help) { 1.352 + const unsigned char white[] = { 255,255,255 }; 1.353 + static CImg<unsigned char> 1.354 + help = CImg<unsigned char>().draw_text(0,0,"\n" 1.355 + " Use mouse to zoom on desired region. \n" 1.356 + " H Show/Hide help \n" 1.357 + " PAD 1...9 Fractal navigation \n" 1.358 + " PAD +/- Zoom/Unzoom \n" 1.359 + " SPACE Set/Disable color smoothing \n" 1.360 + " ENTER Switch Mandelbrot/Julia sets \n" 1.361 + " Arrows Change set parameterization \n" 1.362 + " Page UP/DOWN Add/Reduce iteration numbers \n\n", 1.363 + white); 1.364 + help.draw_rectangle(2,2,help.dimx()-3,help.dimy()-3,white,1,~0U); 1.365 + img.draw_image(img.dimx()-help.dimx(),help,0.7f); 1.366 + } 1.367 + 1.368 + // Get rectangular shape from the user to define the zoomed region. 1.369 + const CImg<int> selection = img.get_select(disp,2,0); 1.370 + const int xs0 = selection[0], ys0 = selection[1], xs1 = selection[3], ys1 = selection[4]; 1.371 + 1.372 + // If the user has selected a region with the mouse, then zoom-in ! 1.373 + if (xs0>=0 && ys0>=0 && xs1>=0 && ys1>=0) { 1.374 + const double dx =(xmax-xmin)/img.dimx(), dy =(ymax-ymin)/img.dimy(); 1.375 + const int dsmax = (ys1-ys0)/2, xs = (xs0+xs1)/2, ys = (ys0+ys1)/2; 1.376 + 1.377 + // If the region is too small (point) then reset the fractal set position and zoom. 1.378 + if (dsmax<5) stopflag = true; 1.379 + xmin += (xs-dsmax*dy/dx)*dx; 1.380 + ymin += (ys-dsmax)*dy; 1.381 + xmax -= (img.dimx()-xs-dsmax*dy/dx)*dx; 1.382 + ymax -= (img.dimy()-ys-dsmax)*dy; 1.383 + } 1.384 + 1.385 + // Also, test if a key has been pressed. 1.386 + // (moving in the fractal set can be done, using keyboard). 1.387 + switch (disp.key) { 1.388 + 1.389 + // Show/hide help. 1.390 + case cimg::keyH: show_help = !show_help; break; 1.391 + 1.392 + // Switch between Julia/Mandelbrot sets. 1.393 + case cimg::keyENTER: fractal_type = !fractal_type; stopflag = true; break; 1.394 + 1.395 + // Enable/disable smoothed colors. 1.396 + case cimg::keySPACE: smooth = !smooth; break; 1.397 + 1.398 + // Change fractal set parameters. 1.399 + case cimg::keyARROWLEFT: juliar-=fractal_type?0.001f:0.05f; break; 1.400 + case cimg::keyARROWRIGHT: juliar+=fractal_type?0.001f:0.05f; break; 1.401 + case cimg::keyARROWUP: juliai+=fractal_type?0.001f:0.05f; break; 1.402 + case cimg::keyARROWDOWN: juliai-=fractal_type?0.001f:0.05f; break; 1.403 + 1.404 + // Add/remove iterations. 1.405 + case cimg::keyPAGEDOWN: maxiter-=32; break; 1.406 + case cimg::keyPAGEUP: maxiter+=16; break; 1.407 + 1.408 + // Move left, right, up and down in the fractal set. 1.409 + case cimg::keyPAD4: { const double delta = (xmax-xmin)/10; xmin-=delta; xmax-=delta; } break; 1.410 + case cimg::keyPAD6: { const double delta = (xmax-xmin)/10; xmin+=delta; xmax+=delta; } break; 1.411 + case cimg::keyPAD8: { const double delta = (ymax-ymin)/10; ymin-=delta; ymax-=delta; } break; 1.412 + case cimg::keyPAD2: { const double delta = (ymax-ymin)/10; ymin+=delta; ymax+=delta; } break; 1.413 + 1.414 + // Allow to zoom in/out in the fractal set. 1.415 + case cimg::keyPADADD: { 1.416 + const double xc = 0.5*(xmin+xmax), yc = 0.5*(ymin+ymax), dx = (xmax-xmin)*0.85/2, dy = (ymax-ymin)*0.85/2; 1.417 + xmin = xc - dx; ymin = yc - dy; xmax = xc + dx; ymax = yc + dy; 1.418 + } break; 1.419 + case cimg::keyPADSUB: 1.420 + const double xc = 0.5*(xmin+xmax), yc = 0.5*(ymin+ymax), dx = (xmax-xmin)*1.15/2, dy = (ymax-ymin)*1.15/2; 1.421 + xmin = xc - dx; ymin = yc - dy; xmax = xc + dx; ymax = yc + dy; 1.422 + break; 1.423 + } 1.424 + 1.425 + // Do a simple test to check if more/less iterations are necessary for the next step. 1.426 + const float value = img.get_pointwise_norm().get_histogram(256,0,255)(0)*3; 1.427 + if (value>img.size()/6.0f) maxiter+=16; 1.428 + if (maxiter>1024) maxiter = 1024; 1.429 + if (value<img.size()/10.0f) maxiter-=4; 1.430 + if (maxiter<32) maxiter = 32; 1.431 + 1.432 + // Check if the user want to quit the explorer. 1.433 + if (disp.is_closed || disp.key==cimg::keyQ || disp.key==cimg::keyESC) stopflag = endflag = true; 1.434 + } 1.435 + } 1.436 + return 0; 1.437 +} 1.438 + 1.439 +// Item : Mini-Paint 1.440 +//------------------ 1.441 +void* item_mini_paint() { 1.442 + int xo = -1, yo = -1, x = -1, y = -1; 1.443 + bool redraw = true; 1.444 + CImg<unsigned char> img(256,256+64,1,3,0); 1.445 + unsigned char color[] = { 255,255,255 }; 1.446 + cimg_for_inY(img,256,img.dimy()-1,yy) cimg_forX(img,xx) img.fillV(xx,yy,0,xx,(yy-256)*4,(3*xx)%256); 1.447 + CImgDisplay disp(img.draw_text(5,5," ",color,color),"[#8] - Mini-Paint"); 1.448 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.449 + const unsigned int but = disp.button; 1.450 + redraw = false; 1.451 + xo = x; yo = y; x = disp.mouse_x; y = disp.mouse_y; 1.452 + if (xo>=0 && yo>=0 && x>=0 && y>=0) { 1.453 + if (but&1 || but&4) { 1.454 + if (y<253) { 1.455 + const float tmax = (float)cimg::max(cimg::abs(xo-x),cimg::abs(yo-y)) + 0.1f; 1.456 + const int radius = (but&1?3:0) + (but&4?6:0); 1.457 + for (float t=0; t<=tmax; ++t) img.draw_circle((int)(x+t*(xo-x)/tmax),(int)(y+t*(yo-y)/tmax),radius,color); 1.458 + } 1.459 + if (y>=256) { color[0]=img(x,y,0); color[1]=img(x,y,1); color[2]=img(x,y,2); img.draw_text(5,5," ",color,color); } 1.460 + redraw = true; 1.461 + } 1.462 + if (y>=253) y = 252; 1.463 + if (disp.button&2) { img.draw_fill(x,y,color); redraw = true; } 1.464 + } 1.465 + if (redraw) disp.display(img); 1.466 + disp.resize(disp).wait(); 1.467 + if (disp.key) cimg_forV(img,k) { img.get_shared_lines(0,255,0,k).fill(0); img.display(disp); } 1.468 + } 1.469 + return 0; 1.470 +} 1.471 + 1.472 +// Item : Soccer Bobs 1.473 +//------------------- 1.474 +void* item_soccer_bobs() { 1.475 + CImg<unsigned char> foot(data_foot,200,200,1,3,false), canvas0(640,480,1,3,0); 1.476 + const unsigned char color[] = { 255,255,0 }; 1.477 + float zoom = 0.2f; 1.478 + cimg_forXY(canvas0,x,y) canvas0(x,y,1) = (unsigned char)(20+(y*215/canvas0.dimy()) + cimg::crand()*19); 1.479 + canvas0.draw_text(5,5,"Left/Right Mouse Button = Zoom In/Out\nMiddle Button = Reset Screen",color); 1.480 + CImgList<unsigned char> canvas(16, canvas0); 1.481 + CImg<float> mask(foot.dimx(),foot.dimy()); 1.482 + { cimg_forXY(mask,x,y) mask(x,y) = (foot(x,y,0)==255 && !foot(x,y,1) && !foot(x,y,2))?0:0.8f; } 1.483 + CImgDisplay disp(canvas0,"[#9] - Unlimited Soccer Bobs"); 1.484 + for (unsigned int curr_canvas=0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; (++curr_canvas)%=16) { 1.485 + if (disp.mouse_x>=0 && disp.mouse_y>=0) 1.486 + canvas[curr_canvas].draw_image((int)(disp.mouse_x - zoom*foot.dimx()/2), 1.487 + (int)(disp.mouse_y - zoom*foot.dimy()/2), 1.488 + foot.get_resize((int)(foot.dimx()*zoom),(int)(foot.dimy()*zoom)), 1.489 + mask.get_resize((int)(foot.dimx()*zoom),(int)(foot.dimy()*zoom))); 1.490 + zoom+=disp.button&1?0.03f:(disp.button&2?-0.03f:0); 1.491 + zoom = zoom<0.1f?0.1f:(zoom>1?1.0f:zoom); 1.492 + if (disp.button&4) cimglist_for(canvas,l) canvas[l] = canvas0; 1.493 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.toggle_fullscreen(false); 1.494 + disp.display(canvas[curr_canvas]).resize(disp,false).wait(20); 1.495 + } 1.496 + return 0; 1.497 +} 1.498 + 1.499 +// Item : Bump Effect 1.500 +//-------------------- 1.501 +void* item_bump() { 1.502 + CImg<> logo = CImg<>(56,32,1,1,0).draw_text(9,5,"I Love\n CImg!",CImg<>::vector(255).ptr()).resize(-800,-800,1,1,3).blur(6).normalize(0,255); 1.503 + logo += CImg<>(logo.dimx(),logo.dimy(),1,1,0).noise(80,1).deriche(2,0,'y',false).deriche(10,0,'x',false); 1.504 + CImgList<> grad = logo.get_gradient(); 1.505 + cimglist_apply(grad,normalize)(-140,140); 1.506 + logo.normalize(0,255); 1.507 + CImg<> light = CImg<>(300+2*logo.dimx(),300+2*logo.dimy()); 1.508 + light.draw_gaussian(0.5f*light.dimx(),0.5f*light.dimy(),80,CImg<>::vector(255)); 1.509 + CImg<unsigned char> img(logo.dimx(),logo.dimy(),1,3,0); 1.510 + CImgDisplay disp(img,"[#10] - Bump Effect (Move lightsource with mouse)"); 1.511 + for (float t = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; t+=0.03f) { 1.512 + const int 1.513 + mouse_x = (disp.mouse_x>=0 && disp.button)?disp.mouse_x*img.dimx()/disp.dimx():(int)(img.dimx()/2 + img.dimx()*std::cos(1*t)/2), 1.514 + mouse_y = (disp.mouse_y>=0 && disp.button)?disp.mouse_y*img.dimy()/disp.dimy():(int)(img.dimy()/2 + img.dimy()*std::sin(3*t)/2); 1.515 + cimg_forXY(img,x,y) { 1.516 + const int gx = (int)grad[0](x,y), gy = (int)grad[1](x,y); 1.517 + const float val = 40+(gx+gy)/2+light(light.dimx()/2+mouse_x-x+gx,light.dimy()/2+mouse_y-y+gy); 1.518 + img(x,y,0) = img(x,y,1) = img(x,y,2) = (unsigned char)(val>255?255:(val<0?0:val)); 1.519 + } 1.520 + disp.resize(false).display(img.draw_image(0,0,0,1,logo,0.1f)).wait(25); 1.521 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(640,480,false).toggle_fullscreen(false); 1.522 + } 1.523 + return 0; 1.524 +} 1.525 + 1.526 +// Item : Bouncing Bubble 1.527 +//------------------------ 1.528 +void* item_bouncing_bubble() { 1.529 + CImg<unsigned char> back(420,256,1,3,0), img; 1.530 + cimg_forXY(back,x,y) back(x,y,2) = (unsigned char)((y<2*back.dimy()/3)?30:(255-2*(y+back.dimy()/2))); 1.531 + CImgDisplay disp(back,"[#11] - Bouncing bubble"); 1.532 + const unsigned char col1[] = { 40,100,10 }, col2[] = { 20,70,0 }, col3[] = { 40,150,10 }, 1.533 + col4[] = { 200,255,100 }, white[] = { 255,255,255 }; 1.534 + float u = (float)std::sqrt(2.0f), cx = back.dimx()/2.0f, t = 0, vt = 0.05f, vx = 2; 1.535 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.536 + img = back; 1.537 + int xm = (int)cx, ym = (int)(img.dimy()/2-70 + (img.dimy()/2+10)* (1-cimg::abs(std::cos((t+=vt))))); 1.538 + float r1 = 50, r2 = 50; 1.539 + vt = 0.05f; 1.540 + if (xm+r1>=img.dimx()) { const float delta = (xm+r1)-img.dimx(); r1-=delta; r2+=delta; } 1.541 + if (xm-r1<0) { const float delta = -(xm-r1); r1-=delta; r2+=delta; } 1.542 + if (ym+r2>=img.dimy()-40) { const float delta = (ym+r2)-img.dimy()+40; r2-=delta; r1+=delta; vt=0.05f - 0.0015f*(50-r2); } 1.543 + if (ym-r2<0) { const float delta = -(ym-r2); r2-=delta; r1+=delta; } 1.544 + img.draw_ellipse(xm,ym,r1,r2,1,0,col1). 1.545 + draw_ellipse((int)(xm+0.03*r1*u),(int)(ym-0.03*r2*u),0.85f*r1,0.85f*r2,1,0,col2). 1.546 + draw_ellipse((int)(xm+0.1*r1*u),(int)(ym-0.1*r2*u),0.8f*r1,0.8f*r2,1,0,col1). 1.547 + draw_ellipse((int)(xm+0.2*r1*u),(int)(ym-0.2*r2*u),r1/2,r2/2,1,0,col3). 1.548 + draw_ellipse((int)(xm+0.3*r1*u),(int)(ym-0.3*r2*u),r1/4,r2/4,1,0,col4). 1.549 + draw_image(0,img.dimy()-40,img.get_crop(0,img.dimy()-80,img.dimx()-1,img.dimy()-40).mirror('y'),0.45f). 1.550 + draw_text(xm-60,(int)(ym-r2-25),"Bubble (%d,%d)",white,0,1,17,xm,ym); 1.551 + if ((cx+=20*vt*vx)>=img.dimx()-30 || cx<30) vx = -vx; 1.552 + disp.display(img).wait(20); 1.553 + if (disp.is_resized) { 1.554 + back.resize(disp.resize(disp.window_dimx()>200?disp.window_dimx():200,disp.dimy(),false)); 1.555 + cx = back.dimx()/2.0f; 1.556 + } 1.557 + } 1.558 + return 0; 1.559 +} 1.560 + 1.561 +// Item : Virtual Landscape 1.562 +//-------------------------- 1.563 +void* item_virtual_landscape() { 1.564 + CImg<int> background(400,300,1,3,0), visu(background); 1.565 + cimg_forXY(background,x,y) { 1.566 + if (y>background.dimy()/2) { background(x,y,2) = 255; background(x,y,0) = (y-background.dimy()/2)*512/background.dimy(); } 1.567 + else background(x,y,2) = y*512/background.dimy(); 1.568 + } 1.569 + const int white[] = { 255,255,255 }; 1.570 + CImgDisplay disp(visu.draw_text(10,10,"Please wait, generating landscape...",white). 1.571 + normalize(0,255),"[#12] - Virtual Landscape",0); 1.572 + CImg<> map = 5.0*(CImg<>(700,700,1,1,300).noise(300).draw_plasma(0.2f,300).normalize(-140,150).blur(5).cut(0,150)), cmap(map.dimx(),map.dimy()); 1.573 + CImg_3x3(I,float); Ipp = Inp = Icc = Ipn = Inn = 0; 1.574 + { cimg_for3x3(map,x,y,0,0,I) { const float nox = 0.5f*(Inc - Ipc), noy = 0.5f*(Icn - Icp); cmap(x,y) = cimg::max(0.0f,0.5f*nox+noy); }} 1.575 + cmap.normalize(0,255); 1.576 + 1.577 + for (float t = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; t+=0.0025f) { 1.578 + visu = background; 1.579 + const int 1.580 + xm = (int)(map.dimx()/2 + (map.dimx()/3)*std::cos(4.2f*t)), 1.581 + ym = (int)(map.dimy()/2 + (map.dimy()/3)*std::sin(5.6f*t)); 1.582 + const CImg<> 1.583 + smap = map.get_crop(xm,ym,xm+100,ym+90), 1.584 + scmap = cmap.get_crop(xm,ym,xm+100,ym+90); 1.585 + CImg<int> ymin(visu.dimx(),1,1,1,visu.dimy()), ymax(ymin.dimx(),1,1,1,0); 1.586 + cimg_forY(smap,z) { 1.587 + const int y0 = (int)(visu.dimy()-1-10*std::pow((double)z,0.63) + 80); 1.588 + cimg_forX(visu,x) { 1.589 + const int nz = smap.dimy()-z; 1.590 + float mx = x*(smap.dimx()-2.0f*nz*0.2f)/visu.dimx() + nz*0.2f; 1.591 + const int y = (int)(y0-smap.linear_atX(mx,z)/(1+0.02*z)); 1.592 + const float cc = (float)scmap.linear_atX(mx,z); 1.593 + if (y<visu.dimy() && y<ymin(x)) { 1.594 + const float cz = (smap.dimy()-(float)z)/smap.dimy(), czz = cz>0.25?1:4*cz; 1.595 + if (y!=y0) for (int l=y>0?y:0; l<ymin(x); ++l) { 1.596 + visu(x,l,0) = (int)((1-czz)*visu(x,l,0)+4*cc*czz); 1.597 + visu(x,l,1) = (int)((1-czz)*visu(x,l,1)+3*cc*czz); 1.598 + visu(x,l,2) = (int)((1-czz)*visu(x,l,2)+ cc*czz); 1.599 + } else for (int l=y>0?y:0; l<ymin(x); ++l) { int cl = l-visu.dimy()/2; 1.600 + visu(x,l,0) = 10; visu(x,l,1) = 200-cl; visu(x,l,2) = 255-cl; 1.601 + } 1.602 + } 1.603 + ymin(x) = cimg::min(ymin(x),y); ymax(x) = cimg::max(ymax(x),y); 1.604 + } 1.605 + } 1.606 + visu.draw_text(5,5,"%u frames/s",white,0,0.5f,11,(unsigned int)disp.frames_per_second()); 1.607 + disp.resize(false).display(visu.cut(0,255)).wait(25); 1.608 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(400,300,false).toggle_fullscreen(false); 1.609 + } 1.610 + return 0; 1.611 +} 1.612 + 1.613 +// Item : Plasma Effect with Sinus Scrolling. 1.614 +//------------------------------------------- 1.615 +void* item_plasma() { 1.616 + CImg<> plasma, camp(3), cfreq(3), namp(3), nfreq(3); 1.617 + CImgList<unsigned char> font = CImgList<unsigned char>::font(57); 1.618 + CImg<unsigned char> visu(400,300,1,3,0), letter, scroll(visu.dimx()+2*font['W'].dimx(),font['W'].dimy(),1,1,0); 1.619 + const char *text = " * The CImg Library : C++ Template Image Processing Toolkit *"; 1.620 + CImgDisplay disp(visu,"[#13] - Plasma Effect"); 1.621 + const unsigned char white[] = { 255, 255, 255 }; 1.622 + unsigned int cplasma = 0, pos = 0, tpos = 0, lwidth = 0; 1.623 + float tx = 0, ts = 0, alpha = 2, beta = 0; 1.624 + namp.fill(0).noise(visu.dimy()/4,0); 1.625 + nfreq.fill(0).noise(0.1); 1.626 + 1.627 + visu.draw_text(10,10,"Please wait, generating plasma...",white).display(disp); 1.628 + const unsigned int nb_plasmas = 5; 1.629 + plasma.assign(5*visu.dimx()/3,visu.dimy(),1,nb_plasmas,0).noise(100).draw_plasma(); 1.630 + cimg_forV(plasma,k) plasma.get_shared_channel(k).blur((float)(cimg::rand()*6)).normalize(0,255); 1.631 + 1.632 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.633 + if (alpha>1) { 1.634 + alpha-=1; 1.635 + cplasma = (cplasma+1)%plasma.dimv(); 1.636 + camp = namp; 1.637 + cfreq = nfreq; 1.638 + namp.fill(0).noise(100).normalize(0,visu.dimy()/4.0f); 1.639 + nfreq.fill(0).noise(0.2); 1.640 + } 1.641 + const unsigned int 1.642 + v0 = cplasma, v1 = (cplasma+1)%plasma.dimv(), 1.643 + v2 = (cplasma+2)%plasma.dimv(), v3 = (cplasma+3)%plasma.dimv(); 1.644 + const float umalpha = 1-alpha; 1.645 + unsigned char *pR = visu.ptr(0,0,0,0), *pG = visu.ptr(0,0,0,1), *pB = visu.ptr(0,0,0,2); 1.646 + cimg_forY(visu,y) { 1.647 + const float 1.648 + *pR1 = plasma.ptr((unsigned int)(camp(0)*(1+std::sin(tx+cfreq(0)*y))),y,v0), 1.649 + *pG1 = plasma.ptr((unsigned int)(camp(1)*(1+std::sin(tx+cfreq(1)*y))),y,v1), 1.650 + *pB1 = plasma.ptr((unsigned int)(camp(2)*(2+std::sin(tx+cfreq(2)*y))),y,v2), 1.651 + *pR2 = plasma.ptr((unsigned int)(namp(0)*(1+std::sin(tx+nfreq(0)*y))),y,v1), 1.652 + *pG2 = plasma.ptr((unsigned int)(namp(1)*(1+std::sin(tx+nfreq(1)*y))),y,v2), 1.653 + *pB2 = plasma.ptr((unsigned int)(namp(2)*(2+std::sin(tx+nfreq(2)*y))),y,v3); 1.654 + cimg_forX(visu,x) { 1.655 + *(pR++) = (unsigned char)(umalpha*(*(pR1++))+alpha*(*(pR2++))); 1.656 + *(pG++) = (unsigned char)(umalpha*(*(pG1++))+alpha*(*(pG2++))); 1.657 + *(pB++) = (unsigned char)(umalpha*(*(pB1++))+alpha*(*(pB2++))); 1.658 + } 1.659 + } 1.660 + if (!pos) { 1.661 + const CImg<unsigned char>& letter = font(text[tpos]); 1.662 + lwidth = (unsigned int)letter.dimx(); 1.663 + scroll.draw_image(visu.dimx(),letter); 1.664 + (++tpos)%=strlen(text); 1.665 + } 1.666 + scroll.translate(2); 1.667 + pos+=2; if (pos>lwidth+2) pos = 0; 1.668 + cimg_forX(visu,x) { 1.669 + const int y0 = (int)(visu.dimy()/2+visu.dimy()/4*std::sin(ts+x/(70+30*std::cos(beta)))); 1.670 + cimg_forY(scroll,y) { 1.671 + if (scroll(x,y)) { 1.672 + const unsigned int y1 = y0+y+2; visu(x,y1,0)/=2; visu(x,y1,1)/=2; visu(x,y1,2)/=2; 1.673 + const unsigned int y2 = y1-6; visu(x,y2,0)=visu(x,y2,1)=visu(x,y2,2)=255; 1.674 + } 1.675 + } 1.676 + } 1.677 + alpha+=0.007f; beta+=0.04f; tx+=0.09f; ts+=0.04f; 1.678 + disp.resize(false).display(visu).wait(20); 1.679 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(640,480,false).toggle_fullscreen(false); 1.680 + } 1.681 + return 0; 1.682 +} 1.683 + 1.684 +// Item : Oriented Convolutions 1.685 +//------------------------------ 1.686 +void* item_oriented_convolutions() { 1.687 + const CImg<unsigned char> img = CImg<unsigned char>(data_lena,256,256,1,1,false).noise(50,2); 1.688 + CImgList<unsigned char> visu = img<<img<<img; 1.689 + CImg<float> mask(16,16); 1.690 + const float value = 255; 1.691 + CImgDisplay disp(visu,"[#14] - Original image, Oriented kernel and Convolved image"); 1.692 + for (float angle = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; angle+=0.1f) { 1.693 + const float ca = (float)std::cos(angle), sa = (float)std::sin(angle); 1.694 + const CImg<> u = CImg<>::vector(ca,sa), v = CImg<>::vector(-sa,ca), 1.695 + tensor = 30.0*u*u.get_transpose() + 2.0*v*v.get_transpose(); 1.696 + mask.draw_gaussian(0.5f*mask.dimx(),0.5f*mask.dimy(),tensor,&value); 1.697 + mask/=mask.sum(); 1.698 + visu[1] = mask.get_resize(img).normalize(0,255). 1.699 + draw_text(2,2,"Angle = %d deg",&value,0,1,11,cimg::mod((int)(angle*180/cimg::valuePI),360)); 1.700 + visu[2] = img.get_convolve(mask); 1.701 + disp.resize(disp.window_dimx(),(int)(disp.dimy()*disp.window_dimx()/disp.dimx()),false). 1.702 + display(visu).wait(25); 1.703 + } 1.704 + return 0; 1.705 +} 1.706 + 1.707 +// Item : Shade Bobs 1.708 +//------------------- 1.709 +void* item_shade_bobs() { 1.710 + float t = 100, rx = 0, ry = 0, rz = 0, rt = 0, rcx = 0; 1.711 + CImg<unsigned char> img(512,512,1,1,0), palette; 1.712 + CImgDisplay disp(img,"[#15] - Shade Bobs"); 1.713 + const unsigned char one = 1; 1.714 + int nbbobs = 0, rybobs = 0; 1.715 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.716 + if ((t+=0.015f)>4*cimg::valuePI) { 1.717 + img.fill(0); 1.718 + rx = (float)(cimg::crand()); 1.719 + ry = (float)(cimg::crand()); 1.720 + rz = (float)(cimg::crand()); 1.721 + rt = (float)(cimg::crand()); 1.722 + rcx = 0.6f*(float)(cimg::crand()); 1.723 + t = 0; 1.724 + palette = CImg<unsigned char>(3,4+(int)(12*cimg::rand()),1,1,0).noise(255,2).resize(3,256,1,1,3); 1.725 + palette(0) = palette(1) = palette(2) = 0; 1.726 + nbbobs = 20+(int)(cimg::rand()*80); 1.727 + rybobs = (10+(int)(cimg::rand()*50))*cimg::min(img.dimx(),img.dimy())/300; 1.728 + disp.key = disp.button = 0; 1.729 + } 1.730 + for (int i = 0; i<nbbobs; ++i) { 1.731 + const float 1.732 + r = (float)(ry + rx*std::cos(6*rz*t) + (1-rx)*std::sin(6*rt*t)), 1.733 + a = (float)((360*std::sin(rz*t)+30*ry*i)*cimg::valuePI/180), 1.734 + ax = (float)(i*2*cimg::valuePI/nbbobs+t); 1.735 + const int 1.736 + cx = (int)((1+rcx*std::cos(ax)+r*std::cos(a))*img.dimx()/2), 1.737 + cy = (int)((1+rcx*std::sin(ax)+r*std::sin(a))*img.dimy()/2); 1.738 + img.draw_circle(cx,cy,rybobs,&one,-1.0f); 1.739 + } 1.740 + CImg_3x3(I,unsigned char); Ipp = Inp = Ipn = Inn = 0; 1.741 + CImg<unsigned char> tmp(img); 1.742 + cimg_for3x3(tmp,x,y,0,0,I) img(x,y) = (Inc+Ipc+Icn+Icp+(Icc<<2))>>3; 1.743 + CImg<unsigned char> visu(img.dimx(),img.dimy(),1,3); 1.744 + cimg_forXY(visu,xx,yy) { 1.745 + const unsigned char *col = palette.ptr(0,img(xx,yy)); 1.746 + visu(xx,yy,0) = *(col++); 1.747 + visu(xx,yy,1) = *(col++); 1.748 + visu(xx,yy,2) = *(col++); 1.749 + } 1.750 + disp.display(visu).wait(25); 1.751 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(640,480,false).toggle_fullscreen(false); 1.752 + if (disp.is_resized) img.resize(disp.resize(false),3); 1.753 + if ((disp.key && disp.key!=cimg::keyCTRLLEFT) || disp.button) t=70; 1.754 + } 1.755 + return 0; 1.756 +} 1.757 + 1.758 +// Item : Fourier Filtering 1.759 +//------------------------- 1.760 +void* item_fourier_filtering() { 1.761 + const CImg<unsigned char> img = CImg<unsigned char>(data_lena,256,256,1,1,false).resize(256,256); 1.762 + CImgList<> F = img.get_FFT(); 1.763 + cimglist_apply(F,translate)(img.dimx()/2,img.dimy()/2,0,0,2); 1.764 + const CImg<unsigned char> mag = ((F[0].get_pow(2) + F[1].get_pow(2)).sqrt()+1.0f).log().normalize(0,255); 1.765 + CImgList<unsigned char> visu(img,mag); 1.766 + CImgDisplay disp(visu,"[#16] - Fourier Filtering (Click to set filter)"); 1.767 + CImg<unsigned char> mask(img.dimx(),img.dimy(),1,1,1); 1.768 + unsigned char one[] = { 1 }, zero[] = { 0 }, white[] = { 255 }; 1.769 + int rmin = 0, rmax = 256; 1.770 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.771 + disp.wait(); 1.772 + const int 1.773 + xm = disp.mouse_x*2*img.dimx()/disp.dimx()-img.dimx(), 1.774 + ym = disp.mouse_y*img.dimy()/disp.dimy(), 1.775 + x = xm-img.dimx()/2, 1.776 + y = ym-img.dimy()/2; 1.777 + if (disp.button && xm>=0 && ym>=0) { 1.778 + const int r = (int)cimg::max(0.0f,(float)std::sqrt((float)x*x+y*y)-3.0f); 1.779 + if (disp.button&1) rmax = r; 1.780 + if (disp.button&2) rmin = r; 1.781 + if (rmin>=rmax) rmin = cimg::max(rmax-1,0); 1.782 + mask.fill(0).draw_circle(mag.dimx()/2,mag.dimy()/2,rmax,one). 1.783 + draw_circle(mag.dimx()/2,mag.dimy()/2,rmin,zero); 1.784 + CImgList<> nF(F); 1.785 + cimglist_for(F,l) nF[l].mul(mask).translate(-img.dimx()/2,-img.dimy()/2,0,0,2); 1.786 + visu[0] = nF.FFT(true)[0].normalize(0,255); 1.787 + } 1.788 + if (disp.is_resized) disp.resize(disp.window_dimx(),disp.window_dimx()/2).display(visu); 1.789 + visu[1] = mag.get_mul(mask).draw_text(5,5,"Freq Min/Max = %d / %d",white,zero,0.6f,11,(int)rmin,(int)rmax); 1.790 + visu.display(disp); 1.791 + } 1.792 + return 0; 1.793 +} 1.794 + 1.795 +// Item : Image Zoomer 1.796 +//--------------------- 1.797 +void* item_image_zoomer() { 1.798 + const CImg<unsigned char> img = CImg<unsigned char>(data_logo,555,103,1,3,false); 1.799 + CImgDisplay disp(img,"[#17] - Original Image"), dispz(500,500,"[#17] - Zoomed Image",0); 1.800 + disp.move((CImgDisplay::screen_dimx()-dispz.dimx())/2,(CImgDisplay::screen_dimy()-dispz.dimy()-disp.dimy())/2); 1.801 + dispz.move(disp.window_posx(),disp.window_posy() + disp.window_dimy() + 40); 1.802 + int factor = 20, x = 0, y = 0; 1.803 + bool grid = false, redraw = false; 1.804 + while (!disp.is_closed && !dispz.is_closed && !disp.is_keyQ && !dispz.is_keyQ && !disp.is_keyESC && !dispz.is_keyESC ) { 1.805 + if (disp.mouse_x>=0) { x = disp.mouse_x; y = disp.mouse_y; redraw = true; } 1.806 + if (redraw) { 1.807 + const int 1.808 + x0 = x-factor, y0 = y-factor, 1.809 + x1 = x+factor, y1 = y+factor; 1.810 + const unsigned char red[] = { 255,0,0 }, black[] = { 0,0,0 }, white[] = { 255,255,255 }; 1.811 + (+img).draw_rectangle(x0,y0,x1,y1,red,1.0f,~0U).display(disp); 1.812 + CImg<unsigned char> visu = img.get_crop(x0,y0,x1,y1).draw_point(x-x0,y-y0,red,0.2f).resize(dispz); 1.813 + if (grid) { 1.814 + const int bfac = 2*factor+1; 1.815 + for (int i = 0; i<bfac; ++i) { 1.816 + const int X = i*dispz.dimx()/bfac, Y = i*dispz.dimy()/bfac; 1.817 + visu.draw_line(X,0,X,dispz.dimy()-1,black).draw_line(0,Y,dispz.dimx()-1,Y,black); 1.818 + } 1.819 + } 1.820 + visu.draw_text(2,2,"Coords (%d,%d)",white,0,1,11,x,y).display(dispz); 1.821 + } 1.822 + if (disp.button&1) { factor=(int)(factor/1.5f); if (factor<3) factor = 3; disp.button=0; redraw = true; } 1.823 + if (disp.button&2) { factor=(int)(factor*1.5f); if (factor>100) factor = 100; disp.button=0; redraw = true; } 1.824 + if (disp.button&4 || dispz.button) { grid = !grid; disp.button = dispz.button = 0; redraw = true; } 1.825 + if (disp.is_resized) disp.resize(disp); 1.826 + if (dispz.is_resized) { dispz.resize(); redraw = true; } 1.827 + CImgDisplay::wait(disp,dispz); 1.828 + } 1.829 + return 0; 1.830 +} 1.831 + 1.832 +// Item : Blobs Editor 1.833 +//-------------------- 1.834 +void* item_blobs_editor() { 1.835 + CImg<unsigned int> img(300,300,1,3); 1.836 + CImgList<unsigned int> colors; 1.837 + CImgList<> blobs; 1.838 + CImgDisplay disp(img,"[#18] - Blobs Editor",0); 1.839 + bool moving = false; 1.840 + unsigned int white[] = { 255,255,255 }; 1.841 + 1.842 + for (float alpha = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; alpha+=0.1f) { 1.843 + const int xm = disp.mouse_x*img.dimx()/disp.dimx(), ym = disp.mouse_y*img.dimy()/disp.dimy(); 1.844 + int selected = -1; 1.845 + img.fill(0); 1.846 + 1.847 + if (blobs) { 1.848 + float dist = 0, dist_min = (float)img.dimx()*img.dimx() + img.dimy()*img.dimy(); 1.849 + cimglist_for(blobs,l) { 1.850 + const CImg<>& blob = blobs[l]; 1.851 + const float 1.852 + xb = blob[0], yb = blob[1], rb = blob[2], 1.853 + sigma = (float)(rb*(1+0.05f*std::cos(blob[3]*alpha))), 1.854 + sigma2 = 2*sigma*sigma, precision = 4.5f*sigma2; 1.855 + const int tx0 = (int)(xb-3*sigma), ty0 = (int)(yb-3*sigma), tx1 = (int)(xb+3*sigma), ty1 = (int)(yb+3*sigma); 1.856 + const unsigned int 1.857 + col1 = colors[l](0), col2 = colors[l](1), col3 = colors[l](2), wh = img.dimx()*img.dimy(), 1.858 + x0 = tx0<0?0:tx0, y0 = ty0<0?0:ty0, 1.859 + x1 = tx1>=img.dimx()?(img.dimx()-1):tx1, y1 = ty1>=img.dimy()?(img.dimy()-1):ty1; 1.860 + float dy = y0-yb; 1.861 + unsigned int *ptr = img.ptr(x0,y0); 1.862 + for (unsigned int y = y0; y<=y1; ++y) { 1.863 + float dx = x0-xb; 1.864 + for (unsigned int x = x0; x<=x1; ++x) { 1.865 + float dist = dx*dx + dy*dy; 1.866 + if (dist<precision) { 1.867 + const float val = (float)exp(-dist/sigma2); 1.868 + *ptr += (unsigned int)(val*col1); 1.869 + *(ptr+wh) += (unsigned int)(val*col2); 1.870 + *(ptr+2*wh) += (unsigned int)(val*col3); 1.871 + } 1.872 + ++dx; ++ptr; 1.873 + } 1.874 + ptr+=img.dimx()-(x1-x0)-1; 1.875 + ++dy; 1.876 + } 1.877 + if ((dist=(xb-xm)*(xb-xm)+(yb-ym)*(yb-ym))<dist_min) { dist_min = dist; selected = l; } 1.878 + } 1.879 + 1.880 + for (unsigned int *ptr1 = img.ptr(0,0,0,1), *ptr2 = img.ptr(0,0,0,2), *ptr3 = img.ptr(img.size()-1)+1, 1.881 + off = 0, wh = img.dimx()*img.dimy(); ptr1>img.data; ++off) { 1.882 + unsigned int val1 = *(--ptr1), val2 = *(--ptr2), val3 = *(--ptr3); 1.883 + const unsigned int pot = val1*val1 + val2*val2 + val3*val3; 1.884 + if (pot<128*128) { *ptr1=*ptr3=255*off/wh; *ptr2=180*off/wh; } 1.885 + else { 1.886 + if (pot<140*140) { *ptr1>>=1; *ptr2>>=1; *ptr3>>=1; } 1.887 + else { 1.888 + *ptr1 = val1<255?val1:255; 1.889 + *ptr2 = val2<255?val2:255; 1.890 + *ptr3 = val3<255?val3:255; 1.891 + } 1.892 + } 1.893 + } 1.894 + cimglist_for(blobs,ll) { 1.895 + const CImg<>& blob = blobs[ll]; 1.896 + const int rb = (int)(blob[2]*(1+0.05f*std::cos(blob[3]*alpha))), 1.897 + xb = (int)(blob[0]+rb/2.5f), yb = (int)(blob[1]-rb/2.5f); 1.898 + img.draw_circle(xb,yb,rb>>1,white,0.2f).draw_circle(xb,yb,rb/3,white,0.2f). 1.899 + draw_circle(xb,yb,rb/5,white,0.2f); 1.900 + } 1.901 + } else { 1.902 + CImg<unsigned int> text; 1.903 + text.draw_text(0,0, 1.904 + "CImg Blobs Editor\n" 1.905 + "-----------------\n\n" 1.906 + "* Left mouse button :\n Create and Move Blob.\n\n" 1.907 + "* Right mouse button :\n Remove nearest Blob.\n\n" 1.908 + "* Colors and size of Appearing Blobs\n" 1.909 + " are randomly chosen.\n\n\n" 1.910 + " >> Press mouse button to start ! <<", 1.911 + white); 1.912 + img.fill(100).draw_image((img.dimx()-text.dimx())/2, 1.913 + (img.dimy()-text.dimy())/2, 1.914 + text,text,1,255U); 1.915 + } 1.916 + 1.917 + if (disp.mouse_x>=0 && disp.mouse_y>=0) { 1.918 + if (disp.button&1) { 1.919 + float dist_selected = 0; 1.920 + if (selected>=0) { 1.921 + const float a = xm-blobs[selected](0), b = ym-blobs[selected](1), c = blobs[selected](2); 1.922 + dist_selected = a*a+b*b-c*c; 1.923 + } 1.924 + if (moving || dist_selected<0) { blobs[selected](0) = (float)xm; blobs[selected](1) = (float)ym; } 1.925 + else { 1.926 + blobs.insert(CImg<>::vector((float)xm,(float)ym,(float)(10+30*cimg::rand()),(float)(3*cimg::rand()))); 1.927 + colors.insert(CImg<>(3).fill(0).noise(255,1).normalize(0,255)); 1.928 + } 1.929 + moving = true; 1.930 + } else moving = false; 1.931 + if (selected>=0 && disp.button&2) { blobs.remove(selected); colors.remove(selected); disp.button = 0; } 1.932 + } 1.933 + 1.934 + img.display(disp.wait(25)); 1.935 + if (disp.is_resized) { 1.936 + img.resize(disp.resize(false)); 1.937 + cimglist_for(blobs,l) if (blobs[l](0)>=img.dimx() || blobs[l](1)>=img.dimy()) { blobs.remove(l); colors.remove(l--); } 1.938 + } 1.939 + } 1.940 + return 0; 1.941 +} 1.942 + 1.943 +// Item : Double Torus 1.944 +//--------------------- 1.945 +void* item_double_torus() { 1.946 + CImg<unsigned char> visu(300,256,1,3,0); 1.947 + CImgDisplay disp(300,256,"[#19] - Double 3D Torus"); 1.948 + CImgList<unsigned int> primitives; 1.949 + CImg<> points = CImg<>::torus3d(primitives,60,20), points2 = CImg<>::rotation_matrix(1,0,0,(float)cimg::valuePI/2.0f)*points; 1.950 + CImgList<> opacities = CImgList<>(primitives.size,1,1,1,1,1).insert(CImgList<>(primitives.size,1,1,1,1,0.4f)); 1.951 + CImgList<unsigned char> colors(2*primitives.size,CImg<unsigned char>(1,3,1,1,255,255,0)); 1.952 + cimglist_for(primitives,ll) colors[ll++].fill(100,255,100); 1.953 + cimglist_for(primitives,l) if (l%2) colors[primitives.size+l].fill(255,200,255); else colors[primitives.size+l].fill(200,150,255); 1.954 + points.translate_object3d(-30,0,0).append_object3d(primitives,points2.translate_object3d(30,0,0),primitives); 1.955 + float alpha = 0, beta = 0, gamma = 0, theta = 0; 1.956 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.957 + visu.get_shared_channels(1,2).fill(0); 1.958 + visu.get_shared_line(visu.dimy()-1,0,0).noise(200,1); 1.959 + CImg_3x3(I,unsigned char); Ipp = Icp = Inp = Ipc = Inc = 0; 1.960 + cimg_for3x3(visu,x,y,0,0,I) visu(x,y,0) = (Icc+Ipn+Icn+Inn)>>2; 1.961 + { for (unsigned int y = 0; y<100; ++y) std::memset(visu.ptr(0,y,0,2),255-y*255/100,visu.dimx()); } 1.962 + const CImg<> 1.963 + rpoints = CImg<>::rotation_matrix(1,1,0,(alpha+=0.01f))*CImg<>::rotation_matrix(1,0,1,(beta-=0.02f))* 1.964 + CImg<>::rotation_matrix(0,1,1,(gamma+=0.03f))*points; 1.965 + if (disp.is_resized) disp.resize(false); 1.966 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(300,256,false).toggle_fullscreen(false); 1.967 + visu.draw_object3d(visu.dimx()/2.0f,visu.dimy()/2.0f,0, 1.968 + rpoints,primitives,colors,opacities,4, 1.969 + true,500.0f,(float)(std::cos(theta+=0.01f)+1)*visu.dimx()/2.0f, 1.970 + (float)visu.dimy(),-100.0f,0.1f,1.5f). 1.971 + display(disp.wait(25)); 1.972 + } 1.973 + return 0; 1.974 +} 1.975 + 1.976 +// Item : 3D Metaballs 1.977 +//--------------------- 1.978 +struct metaballs3d { 1.979 + float cx1, cy1, cz1, cx2, cy2, cz2, cx3, cy3, cz3; 1.980 + inline float operator()(const float x, const float y, const float z) const { 1.981 + const float 1.982 + x1 = x - cx1, y1 = y - cy1, z1 = z - cz1, 1.983 + x2 = x - cx2, y2 = y - cy2, z2 = z - cz2, 1.984 + x3 = x - cx3, y3 = y - cy3, z3 = z - cz3, 1.985 + r1 = 0.3f*(x1*x1 + y1*y1 + z1*z1), 1.986 + r2 = 0.4f*(x2*x2 + y2*y2 + z2*z2), 1.987 + r3 = 0.5f*(x3*x3 + y3*y3 + z3*z3); 1.988 + float potential = 0; 1.989 + if (r1<1.3f) potential+= 1.0f - r1*(r1*(4*r1+17)-22)/9; 1.990 + if (r2<1.3f) potential+= 1.0f - r2*(r2*(4*r2+17)-22)/9; 1.991 + if (r3<1.3f) potential+= 1.0f - r3*(r3*(4*r3+17)-22)/9; 1.992 + return potential; 1.993 + } 1.994 +}; 1.995 + 1.996 +void* item_3d_metaballs() { 1.997 + CImg<unsigned char> img = CImg<unsigned char>(100,100,1,3,0).noise(100,2).draw_plasma(0,0,99,99).resize(512,320,1,3).blur(4); 1.998 + img.get_shared_channel(2)/=4; img.get_shared_channel(1)/=2; 1.999 + metaballs3d met; 1.1000 + CImgList<unsigned int> primitives; 1.1001 + CImgList<unsigned char> colors(8000,3,1,1,1,255); 1.1002 + unsigned char white[] = { 255,255,255 }; 1.1003 + 1.1004 + float alpha = 0, beta = 0, delta = 0, theta = 0, gamma = 0; 1.1005 + CImgDisplay disp(img,"[#20] - 3D Metaballs"); 1.1006 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.1007 + met.cx2 = 1.5f*(float)std::cos(theta); met.cy2 = 2.5f*(float)std::sin(3*(theta+=0.017f)); met.cz2 = 0; 1.1008 + met.cx1 = 0; met.cy1 = 2.0f*(float)std::sin(4*gamma); met.cz1 = 1.2f*(float)std::cos(2*(gamma-=0.0083f)); 1.1009 + met.cx3 = 2.5f*(float)std::cos(2.5*delta); met.cy3 = 0; met.cz3 = 1.5f*(float)std::sin(2*(delta+=0.0125f)); 1.1010 + const CImg<> 1.1011 + points = CImg<>::marching_cubes(primitives,met,0.8f,-4.5f,-4.5f,-3.5f,4.5f,4.5f,3.5f,0.29f,0.29f,0.29f,true), 1.1012 + rot = 50.0*CImg<>::rotation_matrix(0,0,1,(alpha+=0.02f))*CImg<>::rotation_matrix(1,1,0,(beta+=0.076f)), 1.1013 + rpoints = rot*points; 1.1014 + cimglist_for(primitives,ll) { 1.1015 + colors(ll,0) = -60+191+64*ll/primitives.size; 1.1016 + colors(ll,1) = -30+191+64*ll/primitives.size; 1.1017 + colors(ll,2) = 255*ll/primitives.size; 1.1018 + } 1.1019 + if (primitives.size) { 1.1020 + (+img).draw_object3d(img.dimx()/2.0f,img.dimy()/2.0f,0.0f, 1.1021 + rpoints,primitives, 1.1022 + colors.get_crop(0,primitives.size-1,true), 1.1023 + 4,false,500, 0,0,-500, 0.1f,1.5f). 1.1024 + draw_text(5,5,"%u frames/s",white,0,0.5f,11,(unsigned int)disp.frames_per_second()).display(disp.wait(20)); 1.1025 + } 1.1026 + if (disp.is_resized) disp.resize(false); 1.1027 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(512,320,false).toggle_fullscreen(false); 1.1028 + } 1.1029 + return 0; 1.1030 +} 1.1031 + 1.1032 +// Item : Fireworks 1.1033 +//------------------ 1.1034 +void* item_fireworks() { 1.1035 + CImg<unsigned char> img(640,480,1,3,0); 1.1036 + CImgDisplay disp(img,"[#21] - Fireworks (Click to add/explode rockets)"); 1.1037 + CImgList<unsigned char> colors; 1.1038 + unsigned char white[] = { 255,255,255 }, black[] = { 128,0,0 }; 1.1039 + CImgList<> particles; 1.1040 + float time = 0, speed = 100.0f; 1.1041 + 1.1042 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.1043 + 1.1044 + if (disp.button&1 || !particles.size || (--time)<0) { 1.1045 + particles.insert(CImg<>::vector((float)cimg::rand()*img.dimx(),(float)img.dimy(), 1.1046 + (float)cimg::crand()*4,-6-(float)cimg::rand()*3, 1.1047 + 30+60*(float)cimg::rand(),3)); 1.1048 + colors.insert(CImg<unsigned char>::vector(255,255,255)); 1.1049 + time = (float)(cimg::rand()*speed); 1.1050 + } 1.1051 + img*=0.92f; 1.1052 + 1.1053 + cimglist_for(particles,l) { 1.1054 + bool remove_particle = false; 1.1055 + float &x = particles(l,0), &y = particles(l,1), &vx = particles(l,2), &vy = particles(l,3), 1.1056 + &t = particles(l,4), &r = particles(l,5); 1.1057 + const float n = (float)std::sqrt(1e-5f+vx*vx+vy*vy), nvx = vx/n, nvy = vy/n, 1.1058 + r2 = (t>0 || t<-42)?r/3:r*(1-2*(-(t+2)/40.0f)/3); 1.1059 + img.draw_ellipse((int)x,(int)y,r,r2,nvx,nvy,colors[l],0.6f); 1.1060 + x+=vx; y+=vy; vy+=0.09f; t--; 1.1061 + if (y>img.dimy()+10 || x<0 || x>=img.dimx()+10) remove_particle = true; 1.1062 + 1.1063 + if (t<0 && t>=-1) { 1.1064 + if ((speed*=0.9f)<10) speed=10.0f; 1.1065 + const unsigned char 1.1066 + r = cimg::min(50+3*(unsigned char)(100*cimg::rand()), 255), 1.1067 + g = cimg::min(50+3*(unsigned char)(100*cimg::rand()), 255), 1.1068 + b = cimg::min(50+3*(unsigned char)(100*cimg::rand()), 255); 1.1069 + const float di = 10+(float)cimg::rand()*60, nr = (float)cimg::rand()*30; 1.1070 + for (float i=0; i<360; i+=di) { 1.1071 + const float rad = i*(float)cimg::valuePI/180, c = (float)std::cos(rad), s = (float)std::sin(rad); 1.1072 + particles.insert(CImg<>::vector(x,y,2*c+vx/1.5f,2*s+vy/1.5f,-2.0f,nr)); 1.1073 + colors.insert(CImg<unsigned char>::vector(r,g,b)); 1.1074 + } 1.1075 + remove_particle = true; 1.1076 + } else if (t<-1) { r*=0.95f; if (r<0.5f) remove_particle=true; } 1.1077 + if (remove_particle) { particles.remove(l); colors.remove(l); l--; } 1.1078 + } 1.1079 + if (disp.button&2) cimglist_for(particles,l) if (particles(l,4)>0) particles(l,4)=0.5f; 1.1080 + img.draw_text(5,5,"%u frames/s",white,black,0.5f,11,(unsigned int)disp.frames_per_second()); 1.1081 + disp.display(img).wait(25); 1.1082 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(640,480,false).toggle_fullscreen(false); 1.1083 + if (disp.is_resized) disp.resize(disp,false); 1.1084 + } 1.1085 + return 0; 1.1086 +} 1.1087 + 1.1088 +// Item : Rubber Logo 1.1089 +//-------------------- 1.1090 +void* item_rubber_logo() { 1.1091 + const unsigned char white[] = { 255,255,255 }; 1.1092 + CImg<unsigned char> background = CImg<unsigned char>(300,300).noise(100,2); 1.1093 + background(0,0) = background(299,0) = background(299,299) = background(0,299) = 0; 1.1094 + background.draw_plasma(0,0,299,299).blur(1.0f,14.0f,0.0f,0).resize(-100,-100,1,3); 1.1095 + CImgDisplay disp(CImg<unsigned char>(background). 1.1096 + draw_text(10,10,"Please wait, generating rubber object...",white),"[#22] - 3D Rubber Logo"); 1.1097 + 1.1098 + CImg<unsigned char> vol = CImg<unsigned char>().draw_text(30,30,"CImg",white,0,1,48).resize(-100,-100,15,1); 1.1099 + for (unsigned int k = 0; k<5; ++k) { vol.get_shared_plane(k).fill(0); vol.get_shared_plane(vol.dimz()-1-k).fill(0); } 1.1100 + vol.resize(vol.dimx()+30,vol.dimy()+30,-100,1,0).blur(2).resize(-50,-50); 1.1101 + CImgList<unsigned int> faces; 1.1102 + CImg<> points = vol.get_isovalue3d(faces,45,1,1,1,true); 1.1103 + CImgList<unsigned char> colors; 1.1104 + colors.insert(faces.size,CImg<unsigned char>::vector(100,100,255)); 1.1105 + cimglist_for(colors,l) { 1.1106 + const float x = (points(faces(l,0),0) + points(faces(l,1),0) + points(faces(l,2),0))/3; 1.1107 + if (x<27) colors[l] = CImg<unsigned char>::vector(255,100,100); 1.1108 + else { if (x<38) colors[l] = CImg<unsigned char>::vector(200,155,100); 1.1109 + else { if (x<53) colors[l] = CImg<unsigned char>::vector(100,255,155); 1.1110 + }}} 1.1111 + { cimg_forX(points,l) { points(l,0)-=vol.dimx()/2; points(l,1)-=vol.dimy()/2; points(l,2)-=vol.dimz()/2; }} 1.1112 + points*=5.5; 1.1113 + 1.1114 + CImgList<unsigned char> frames(100,background); 1.1115 + bool ok_visu = false; 1.1116 + unsigned int nb_frame = 0; 1.1117 + float alpha = 0, beta = 0, gamma = 0; 1.1118 + 1.1119 + while (!disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.1120 + CImg<unsigned char>& frame = frames[nb_frame++]; 1.1121 + if (nb_frame>=frames.size) { ok_visu = true; nb_frame = 0; } 1.1122 + const CImg<> 1.1123 + rot = CImg<>::rotation_matrix(0,1,0.2f,alpha+=0.011f)* 1.1124 + CImg<>::rotation_matrix(1,0.4f,1,beta+=0.015f)* 1.1125 + (1+0.1f*std::cos((double)(gamma+=0.1f))); 1.1126 + (frame=background).draw_object3d(frame.dimx()/2.0f,frame.dimy()/2.0f,frame.dimz()/2.0f,rot*points,faces,colors,5, 1.1127 + false,500,0,0,-5000,0.1f,1.0f); 1.1128 + 1.1129 + if (ok_visu) { 1.1130 + CImg<unsigned char> visu(frame); 1.1131 + cimglist_for(frames,l) { 1.1132 + const unsigned int 1.1133 + y0 = l*visu.dimy()/frames.size, 1.1134 + y1 = (l+1)*visu.dimy()/frames.size-1; 1.1135 + cimg_forV(visu,k) visu.get_shared_lines(y0,y1,0,k) = frames[(nb_frame+l)%frames.size].get_shared_lines(y0,y1,0,k); 1.1136 + } 1.1137 + visu.get_resize(disp,1).draw_text(5,5,"%u frames/s",white,0,0.5f,11,(unsigned int)disp.frames_per_second()).display(disp.wait(20)); 1.1138 + } 1.1139 + 1.1140 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(300,300,false).toggle_fullscreen(false); 1.1141 + if (disp.is_resized) disp.resize(); 1.1142 + } 1.1143 + return 0; 1.1144 +} 1.1145 + 1.1146 +// Item : Image Waves 1.1147 +//-------------------- 1.1148 +void* item_image_waves() { 1.1149 + const CImg<unsigned char> img = CImg<unsigned char>(data_milla,211,242,1,3,false).get_resize(128,128,1,3); 1.1150 + const unsigned int w = img.dimx()+1, h = img.dimy()+1; 1.1151 + CImgList<> points0; 1.1152 + CImgList<unsigned int> faces0; 1.1153 + CImgList<unsigned char> colors0; 1.1154 + { for (unsigned int y = 0; y<h; ++y) for (unsigned int x=0; x<w; ++x) 1.1155 + points0.insert(CImg<>::vector(3*(x-w/2.0f),3*(y-w/2.0f),0)); } 1.1156 + cimg_forXY(img,x,y) { 1.1157 + faces0.insert(CImg<unsigned int>::vector(x+y*w,x+(y+1)*w,x+1+(y+1)*w,x+1+y*w)); 1.1158 + colors0.insert(CImg<unsigned char>::vector(img(x,y,0),img(x,y,1),img(x,y,2))); 1.1159 + } 1.1160 + CImgList<> opacities0(faces0.size,CImg<>::vector(1.0f)); 1.1161 + 1.1162 + CImg<unsigned char> 1.1163 + back = CImg<unsigned char>(400,300,1,3).sequence(0,130), 1.1164 + ball = CImg<unsigned char>(12,12,1,3,0).draw_circle(6,6,5,CImg<unsigned char>::vector(0,128,64)); 1.1165 + const CImg<> mball = CImg<>(12,12,1,1,0).draw_circle(6,6,5,CImg<>::vector(1.0f)); 1.1166 + ball.draw_circle(7,5,4,CImg<unsigned char>::vector(16,96,52)). 1.1167 + draw_circle(8,4,2,CImg<unsigned char>::vector(0,128,64)). 1.1168 + draw_circle(8,4,1,CImg<unsigned char>::vector(64,196,128)); 1.1169 + 1.1170 + CImg<> uc(img.dimx()/2,img.dimy()/2,1,1,0), up(uc), upp(uc); 1.1171 + CImgDisplay disp(back,"[#23] - Image Waves (Try mouse buttons!)"); 1.1172 + CImgList<int> particles; 1.1173 + 1.1174 + for (float alpha = 0.0f, count=10.0f; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; ) { 1.1175 + if ((disp.button&1 && disp.mouse_x>=0) || --count<0) { 1.1176 + particles.insert(CImg<int>::vector((int)(cimg::rand()*(img.dimx()-1)),(int)(cimg::rand()*(img.dimy()-1)),-200,0)); 1.1177 + count = (float)(cimg::rand()*15); 1.1178 + } 1.1179 + alpha = (disp.mouse_x>=0 && disp.button&2)?(float)(disp.mouse_x*2*cimg::valuePI/disp.dimx()):(alpha+0.04f); 1.1180 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(400,300,false).toggle_fullscreen(false); 1.1181 + 1.1182 + cimglist_for(particles,l) { // Handle particles 1.1183 + float& z = up(particles(l,0)>>1,particles(l,1)>>1); 1.1184 + if ((particles(l,2)+=(particles(l,3)++))>z-10) { z = 250.0f; particles.remove(l--); } 1.1185 + } 1.1186 + 1.1187 + CImg_3x3(U,float); Upp = Unp = Ucc = Upn = Unn = 0; // Apply wave effect 1.1188 + cimg_for3x3(up,x,y,0,0,U) uc(x,y) = (Unc+Upc+Ucn+Ucp)/2 - upp(x,y); 1.1189 + (uc-=(float)(uc.blur(0.7f).mean())).swap(upp).swap(up); 1.1190 + 1.1191 + CImgList<> points(points0); 1.1192 + CImgList<unsigned int> faces(faces0); 1.1193 + CImgList<unsigned char> colors(colors0); 1.1194 + CImgList<> opacities(opacities0); 1.1195 + cimglist_for(points,p) points(p,2) = cimg::min(30 + uc.linear_atXY((p%w)/2.0f,(p/w)/2.0f),70.0f); 1.1196 + { cimglist_for(particles,l) { 1.1197 + points.insert(CImg<>::vector(3*(particles(l,0)-w/2.0f),3*(particles(l,1)-h/2.0f),30.0f+particles(l,2))); 1.1198 + faces.insert(CImg<unsigned int>::vector(points.size-1)); 1.1199 + colors.insert(ball); 1.1200 + opacities.insert(mball); 1.1201 + }} 1.1202 + const CImg<> rot = CImg<>::rotation_matrix(1.0f,0,0,(float)(cimg::valuePI/3.0f))*CImg<>::rotation_matrix(0,0,1.0f,alpha); 1.1203 + (+back).draw_object3d(back.dimx()/2.0f,back.dimy()/2.0f,0,rot*points,faces,colors,opacities,4,false,500.0f,0,0,0,1,1). 1.1204 + display(disp.resize(false).wait(20)); 1.1205 + } 1.1206 + return 0; 1.1207 +} 1.1208 + 1.1209 +// Item : Breakout 1.1210 +//----------------- 1.1211 +void* item_breakout() { 1.1212 + 1.1213 + // Init graphics 1.1214 + CImg<unsigned char> 1.1215 + board(8,10,1,1,0), 1.1216 + background = CImg<unsigned char>(board.dimx()*32,board.dimy()*16+200,1,3,0).noise(20,1).draw_plasma().blur(1,8,0), 1.1217 + visu0(background/2.0), visu(visu0), brick(16,16,1,1,200), racket(64,8,1,3,0), ball(8,8,1,3,0); 1.1218 + const unsigned char white[] = { 255,255,255 }, green1[] = { 60,150,30 }, green2[] = { 130,255,130 }; 1.1219 + { cimg_for_borderXY(brick,x,y,1) brick(x,y) = x>y?255:128; } 1.1220 + { cimg_for_insideXY(brick,x,y,1) brick(x,y) = cimg::min(255,64+8*(x+y)); } 1.1221 + brick.resize(31,15,1,1,1).resize(32,16,1,1,0); 1.1222 + ball.draw_circle(4,4,2,white); ball-=ball.get_erode(3)/1.5; 1.1223 + racket.draw_circle(4,3,4,green1).draw_circle(3,2,2,green2); 1.1224 + { cimg_forY(racket,y) racket.draw_rectangle(4,y,racket.dimx()-7,y,CImg<unsigned char>::vector(y*4,255-y*32,255-y*25)); } 1.1225 + racket.draw_image(racket.dimx()/2,racket.get_crop(0,0,racket.dimx()/2-1,racket.dimy()-1).mirror('x')); 1.1226 + const int 1.1227 + w = visu.dimx(), h = visu.dimy(), w2 = w/2, h2 = h/2, 1.1228 + bw = ball.dimx(), bh = ball.dimy(), bw2 = bw/2, bh2 = bh/2, 1.1229 + rw = racket.dimx(), rh = racket.dimy(), rw2 = rw/2; 1.1230 + float xr = (float)(w-rw2), oxr = (float)xr, xb = 0, yb = 0, oxb = 0, oyb = 0, vxb = 0, vyb = 0; 1.1231 + 1.1232 + // Begin game loop 1.1233 + CImgDisplay disp(visu,"[#24] - Breakout"); 1.1234 + disp.move((CImgDisplay::screen_dimx()-w)/2,(CImgDisplay::screen_dimy()-h)/2); 1.1235 + for (unsigned int N = 0, N0 = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; ) { 1.1236 + if (N0) { 1.1237 + int X = (int)xr; 1.1238 + if (disp.mouse_x>=0) X = (int)(w2+((disp.mouse_x<0?w2:disp.mouse_x)-w2)*2); 1.1239 + else disp.set_mouse(xr>w2?w-81:80,h2); 1.1240 + if (X<rw2) { X = rw2; disp.set_mouse(80,h2); } 1.1241 + if (X>=w-rw2) { X = w-rw2-1; disp.set_mouse(w-81,h2); } 1.1242 + oxr = xr; xr = (float)X; oxb = xb; oyb = yb; xb+=vxb; yb+=vyb; 1.1243 + if ((xb>=w-bw2) || (xb<bw2)) { xb-=vxb; yb-=vyb; vxb=-vxb; } 1.1244 + if (yb<bh2) { yb = (float)bh2; vyb=-vyb; } 1.1245 + if (yb>=h-rh-8-bh2 && yb<h-8-bh2 && xr-rw2<=xb && xr+rw2>=xb) { 1.1246 + xb = oxb; yb = h-rh-8.0f-bh2; vyb=-vyb; vxb+=(xr-oxr)/4; 1.1247 + if (cimg::abs(vxb)>8) vxb*=8/cimg::abs(vxb); 1.1248 + } 1.1249 + if (yb<board.dimy()*16) { 1.1250 + const int X = (int)xb/32, Y = (int)yb/16; 1.1251 + if (board(X,Y)) { 1.1252 + board(X,Y) = 0; 1.1253 + ++N; 1.1254 + const unsigned int x0 = X*brick.dimx(), y0 = Y*brick.dimy(), x1 = (X+1)*brick.dimx()-1, y1 = (Y+1)*brick.dimy()-1; 1.1255 + visu0.draw_image(x0,y0,background.get_crop(x0,y0,x1,y1)); 1.1256 + if (oxb<(X<<5) || oxb>=((X+1)<<5)) vxb=-vxb; 1.1257 + else if (oyb<(Y<<4) || oyb>=((Y+1)<<4)) vyb=-vyb; 1.1258 + } 1.1259 + } 1.1260 + disp.set_title("[#24] - Breakout : %u/%u",N,N0); 1.1261 + } 1.1262 + if (yb>h || N==N0) { 1.1263 + disp.show_mouse(); 1.1264 + while (!disp.is_closed && !disp.key && !disp.button) { 1.1265 + ((visu=visu0)/=2).draw_text(50,visu.dimy()/2-10,N0?"Game Over !":"Get Ready ?",white,0,1,25). 1.1266 + display(disp); 1.1267 + disp.wait(); 1.1268 + if (disp.is_resized) disp.resize(disp); 1.1269 + } 1.1270 + board.fill(0); visu0 = background; 1.1271 + cimg_forXY(board,x,y) if (0.2f+cimg::crand()>=0) { 1.1272 + CImg<> cbrick = CImg<double>::vector(100+cimg::rand()*155,100+cimg::rand()*155,100+cimg::rand()*155). 1.1273 + unroll('v').resize(brick.dimx(),brick.dimy()); 1.1274 + cimg_forV(cbrick,k) (cbrick.get_shared_channel(k).mul(brick))/=255; 1.1275 + visu0.draw_image(x*32,y*16,cbrick); 1.1276 + board(x,y) = 1; 1.1277 + } 1.1278 + N0 = (int)board.sum(); N = 0; 1.1279 + oxb = xb = (float)w2; oyb = yb = board.dimy()*16.0f+bh; vxb = 2.0f; vyb = 3.0f; 1.1280 + disp.hide_mouse(); 1.1281 + } else disp.display((visu=visu0).draw_image((int)(xr-rw2),h-rh-8,racket).draw_image((int)(xb-bw2),(int)(yb-bh2),ball)); 1.1282 + if (disp.is_resized) disp.resize(disp); 1.1283 + disp.wait(20); 1.1284 + } 1.1285 + return 0; 1.1286 +} 1.1287 + 1.1288 +// Item : 3D Reflection 1.1289 +//---------------------- 1.1290 +void* item_3d_reflection() { 1.1291 + 1.1292 + // Init images and display 1.1293 + CImgDisplay disp(512,512,"[#25] - 3D Reflection",0); 1.1294 + CImg<unsigned char> back(400,400,1,3,0); 1.1295 + cimg_forV(back,k) { back(399,0,k) = back(0,0,k) = 50*((k+1)%2); back(399,399,k) = back(0,399,k) = 20*k; } 1.1296 + back.draw_plasma().blur(6,1,0).translate(200,0,0,0,2).blur(6,1,0); 1.1297 + CImg<unsigned char> light0 = back.get_resize(-50,-50,1,1), visu(back), reflet(back.dimx(),back.dimy(),1,1), light(light0); 1.1298 + back.get_shared_channel(0)/=3; back.get_shared_channel(2)/=2; 1.1299 + 1.1300 + // Create 3D objects 1.1301 + CImgList<unsigned int> back_faces, main_faces; 1.1302 + CImgList<float> back_pts0, main_pts; 1.1303 + CImgList<unsigned char> main_colors, back_colors, light_colors, light_colors2; 1.1304 + 1.1305 + main_pts = CImg<>::torus3d(main_faces,30,12,24,12).get_split('x'); 1.1306 + cimglist_for(main_faces,l) 1.1307 + if (l%2) main_colors.insert(CImg<unsigned char>::vector(255,120,16)); 1.1308 + else main_colors.insert(CImg<unsigned char>::vector(255,100,16)); 1.1309 + 1.1310 + const unsigned int res1 = 32, res2 = 32; 1.1311 + for (unsigned int v = 1; v<res2; ++v) for (unsigned int u = 0; u<res1; ++u) { 1.1312 + const float 1.1313 + alpha = (float)(u*2*cimg::valuePI/res1), beta = (float)(-cimg::valuePI/2 + v*cimg::valuePI/res2), 1.1314 + x = (float)(std::cos(beta)*std::cos(alpha)), 1.1315 + y = (float)(std::cos(beta)*std::sin(alpha)), 1.1316 + z = (float)(std::sin(beta)); 1.1317 + back_pts0.insert(CImg<>::vector(x,y,z)); 1.1318 + } 1.1319 + const unsigned int N = back_pts0.size; 1.1320 + back_pts0.insert(CImg<>::vector(0,0,-140)).insert(CImg<>::vector(0,0,140)); 1.1321 + CImg<float> back_pts = back_pts0.get_append('x'); 1.1322 + for (unsigned int vv = 0; vv<res2-2; ++vv) for (unsigned int uu = 0; uu<res1; ++uu) { 1.1323 + const int nv = (vv+1)%(res2-1), nu = (uu+1)%res1; 1.1324 + back_faces.insert(CImg<unsigned int>::vector(res1*vv+nu,res1*nv+uu,res1*vv+uu)); 1.1325 + back_faces.insert(CImg<unsigned int>::vector(res1*vv+nu,res1*nv+nu,res1*nv+uu)); 1.1326 + back_colors.insert(CImg<unsigned char>::vector(128,255,255)); 1.1327 + back_colors.insert(CImg<unsigned char>::vector(64,240,196)); 1.1328 + } 1.1329 + for (unsigned int uu = 0; uu<res1; ++uu) { 1.1330 + const int nu = (uu+1)%res1; 1.1331 + back_faces.insert(CImg<unsigned int>::vector(nu,uu,N)); 1.1332 + back_faces.insert(CImg<unsigned int>::vector(res1*(res2-2)+nu, N+1,res1*(res2-2)+uu)); 1.1333 + if (uu%2) back_colors.insert(2,CImg<unsigned char>::vector(128,255,255)); 1.1334 + else back_colors.insert(2,CImg<unsigned char>::vector(64,240,196)); 1.1335 + } 1.1336 + 1.1337 + light_colors.assign(back_faces.size,CImg<unsigned char>::vector(255)); 1.1338 + light_colors2.assign(light_colors).insert(light,light_colors.size,true); 1.1339 + 1.1340 + // Start 3D animation 1.1341 + for (float main_x = -1.5f*visu.dimx(), 1.1342 + back_alpha = 0, back_beta = 0, back_theta = -3.0f, 1.1343 + main_alpha = 0, main_beta = 0, main_theta = 0; 1.1344 + !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; 1.1345 + main_alpha+=0.041f, main_beta+=0.063f, main_theta+=0.02f, 1.1346 + back_alpha+=0.0031f, back_beta+=0.0043f, back_theta+=0.01f) { 1.1347 + const int 1.1348 + main_X = (int)(visu.dimx()/2 + main_x + 100*std::cos(2.1*main_theta)), 1.1349 + main_Y = (int)(visu.dimy()/2 + 120*std::sin(1.8*main_theta)); 1.1350 + CImgList<> rmain_pts = (CImg<>::rotation_matrix(-1,1,0,main_alpha)*CImg<>::rotation_matrix(1,0,1,main_beta))*main_pts; 1.1351 + const CImg<> rback_pts = (CImg<>::rotation_matrix(1,1,0,back_alpha)*CImg<>::rotation_matrix(0.5,0,1,back_beta))*back_pts; 1.1352 + (light=light0).draw_object3d(main_X/2.0f,main_Y/2.0f,0,rmain_pts,main_faces,light_colors,3,false,500,0,0,-5000,0.2f,0.1f); 1.1353 + reflet.fill(0).draw_object3d(2*visu.dimx()/3.0f,visu.dimy()/2.0f,0,rback_pts,back_faces,light_colors2,5,false,500,0,0,-5000,0.2f,0.1f); 1.1354 + rmain_pts*=2; 1.1355 + (visu=back).draw_object3d(2*visu.dimx()/3.0f,visu.dimy()/2.0f,0,rback_pts,back_faces,back_colors,3,false,500,0,0,-5000,0.2f,0.1f); 1.1356 + unsigned char *ptrs = reflet.ptr(), *ptrr = visu.ptr(0,0,0,0), *ptrg = visu.ptr(0,0,0,1), *ptrb = visu.ptr(0,0,0,2); 1.1357 + cimg_forXY(visu,x,y) { 1.1358 + const unsigned char v = *(ptrs++); 1.1359 + if (v) { *ptrr = (*ptrr+v)>>1; *ptrg = (3**ptrr+v)>>2; *ptrb = (*ptrb+v)>>1; } 1.1360 + ++ptrr; ++ptrg; ++ptrb; 1.1361 + } 1.1362 + visu.draw_object3d((float)main_X,(float)main_Y,0,rmain_pts,main_faces,main_colors,4, 1.1363 + false,500,0,0,-5000,0.1f,1.4f); 1.1364 + 1.1365 + if (disp.is_resized) { 1.1366 + const int s = cimg::min(disp.window_dimx(),disp.window_dimy()); 1.1367 + disp.resize(s,s,false); 1.1368 + } 1.1369 + if (disp.is_keyCTRLLEFT && disp.key==cimg::keyF) disp.resize(512,512,false).toggle_fullscreen(false); 1.1370 + disp.display(visu).wait(20); 1.1371 + back.translate(-4,0,0,0,2); 1.1372 + light0.translate(2,0,0,0,2); 1.1373 + if (main_x<0) main_x +=2; 1.1374 + const float H = back_theta<0?0.0f:(float)(0.3f-0.3f*std::cos(back_theta)); 1.1375 + for (unsigned int p = 0, v = 1; v<res2; ++v) for (unsigned int u = 0; u<res1; ++u) { 1.1376 + const float 1.1377 + alpha = (float)(u*2*cimg::valuePI/res1), beta = (float)(-cimg::valuePI/2 + v*cimg::valuePI/res2), 1.1378 + x = back_pts0(p,0), y = back_pts0(p,1), z = back_pts0(p,2), 1.1379 + altitude = 140*(float)cimg::abs(1+H*std::sin(3*alpha)*std::cos(5*beta)); 1.1380 + back_pts(p,0) = altitude*x; back_pts(p,1) = altitude*y; back_pts(p,2) = altitude*z; 1.1381 + ++p; 1.1382 + } 1.1383 + } 1.1384 + return 0; 1.1385 +} 1.1386 + 1.1387 +// Item : Fish-Eye Magnification 1.1388 +//------------------------------ 1.1389 +void* item_fisheye_magnification() { 1.1390 + const unsigned char purple[] = { 255,0,255 }, white[] = { 255,255,255 }, black[] = { 0,0,0 }; 1.1391 + const CImg<unsigned char> img0 = CImg<unsigned char>(data_logo,555,103,1,3,true).get_resize(-144,-144,1,3,5); 1.1392 + CImgDisplay disp(img0,"[#26] - Fish-Eye Magnification"); 1.1393 + int rm = 80, xc = 0, yc = 0, rc = 0; 1.1394 + CImg<unsigned char> img, res; 1.1395 + for (float alpha = 0; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; alpha+=0.02f) { 1.1396 + if (!img) img = img0.get_resize(disp,3); 1.1397 + if (disp.mouse_x>=0) { xc = disp.mouse_x; yc = disp.mouse_y; rc = rm; } 1.1398 + else { 1.1399 + xc = (int)(img.dimx()*(1 + 0.9f*std::cos(1.2f*alpha))/2); 1.1400 + yc = (int)(img.dimy()*(1 + 0.8f*std::sin(3.4f*alpha))/2); 1.1401 + rc = (int)(90 + 60*std::sin(alpha)); 1.1402 + } 1.1403 + const int x0 = xc - rc, y0 = yc - rc, x1 = xc + rc, y1 = yc + rc; 1.1404 + res = img; 1.1405 + cimg_for_inXY(res,x0,y0,x1,y1,x,y) { 1.1406 + const float X = (float)x - xc, Y = (float)y - yc, r2 = X*X + Y*Y, rrc = (float)std::sqrt(r2)/rc; 1.1407 + if (rrc<1) { 1.1408 + const int xi = (int)(xc + rrc*X), yi = (int)(yc + rrc*Y); 1.1409 + res(x,y,0) = img(xi,yi,0); res(x,y,1) = img(xi,yi,1); res(x,y,2) = img(xi,yi,2); 1.1410 + } 1.1411 + } 1.1412 + const int xf = xc+3*rc/8, yf = yc-3*rc/8; 1.1413 + res.draw_circle(xc,yc,rc,purple,0.2f).draw_circle(xf,yf,rc/3,white,0.2f).draw_circle(xf,yf,rc/5,white,0.2f). 1.1414 + draw_circle(xf,yf,rc/10,white,0.2f).draw_circle(xc,yc,rc,black,0.7f,~0U); 1.1415 + disp.display(res).wait(20); 1.1416 + rm+=(disp.button&1?8:(disp.button&2?-8:0)); 1.1417 + rm = rm<30?30:(rm>200?200:rm); 1.1418 + if (disp.is_resized) { disp.resize(false); img.assign(); } 1.1419 + } 1.1420 + return 0; 1.1421 +} 1.1422 + 1.1423 +// Item : Word puzzle 1.1424 +//------------------------------ 1.1425 +void* item_word_puzzle() { 1.1426 + 1.1427 + // Create B&W and color letters 1.1428 + CImg<unsigned char> model(60,60,1,3,0), color(3), background, canvas, elaps; 1.1429 + CImgList<unsigned char> letters('Z'-'A'+1), cletters(letters); 1.1430 + const unsigned char white[] = { 255,255,255 }, gray[] = { 128,128,128 }, black[] = { 0,0,0 }; 1.1431 + char tmptxt[] = { 'A',0 }; 1.1432 + model.fill(255).draw_rectangle(5,5,54,54,gray).blur(3,0).threshold(140).normalize(0,255); 1.1433 + cimglist_for(letters,l) 1.1434 + (letters[l].draw_text(5,2,&(tmptxt[0]='A'+l),white,0,1,64).resize(60,60,1,1,0,0,true). 1.1435 + resize(-100,-100,1,3)|=model).blur(0.5); 1.1436 + { cimglist_for(cletters,l) { 1.1437 + CImg<int> tmp = letters[l]; 1.1438 + color.rand(100,255); 1.1439 + cimg_forV(tmp,k) (tmp.get_shared_channel(k)*=color[k])/=255; 1.1440 + cletters[l] = tmp; 1.1441 + }} 1.1442 + 1.1443 + CImgDisplay disp(500,400,"[#27] - Word Puzzle",0); 1.1444 + while (!disp.is_closed && disp.key!=cimg::keyQ && disp.key!=cimg::keyESC) { 1.1445 + 1.1446 + // Create background, word data and display. 1.1447 + background.assign(40,40,1,2,0).noise(30,2).distance(255).normalize(0,255).resize(500,400,1,3,3); 1.1448 + CImg<int> current(14,6,1,1,0), solution(14,4,1,1,0); 1.1449 + current.get_shared_line(0).fill('T','H','E','C','I','M','G','L','I','B','R','A','R','Y'); 1.1450 + current.get_shared_line(1).rand(-30,background.dimx()-30); 1.1451 + current.get_shared_line(2).rand(-30,background.dimy()-30); 1.1452 + solution.get_shared_line(0) = current.get_shared_line(0); 1.1453 + solution.get_shared_line(1).fill(20,80,140,100,180,260,340,40,100,160,220,280,340,400); 1.1454 + solution.get_shared_line(2).fill(20,20,20,120,150,180,210,310,310,310,310,310,310,310); 1.1455 + { cimg_forX(solution,l) background.draw_image(solution(l,1),solution(l,2),letters(solution(l)-'A'),0.3f); } 1.1456 + const int last = current.dimx()-1; 1.1457 + 1.1458 + // Start user interaction 1.1459 + int timer = 0, completed = 0; 1.1460 + for (bool selected = false, refresh_canvas = true, stopflag = false; 1.1461 + !stopflag && !disp.is_closed && disp.key!=cimg::keyQ && disp.key!=cimg::keyESC; disp.resize(disp).wait(20)) { 1.1462 + if (refresh_canvas) { 1.1463 + canvas = background; 1.1464 + cimg_forX(current,l) if (!current(l,5)) { 1.1465 + int &x = current(l,1), &y = current(l,2); 1.1466 + if (x<-30) x = -30; else if (x>canvas.dimx()-30) x = canvas.dimx()-30; 1.1467 + if (y<-30) y = -30; else if (y>canvas.dimy()-30) y = canvas.dimy()-30; 1.1468 + canvas.draw_rectangle(x+8,y+8,x+67,y+67,black,0.3f).draw_image(x,y,cletters(current(l)-'A')); 1.1469 + } 1.1470 + refresh_canvas = false; 1.1471 + } 1.1472 + (+canvas).draw_text(360,3,"Elapsed Time : %d",white,0,1,16,timer++).display(disp); 1.1473 + 1.1474 + if (disp.button&1) { 1.1475 + const int mx = disp.mouse_x, my = disp.mouse_y; 1.1476 + if (mx>=0 && my>=0) { 1.1477 + if (!selected) { 1.1478 + int ind = -1; 1.1479 + cimg_forX(current,l) if (!current(l,5)) { 1.1480 + const int x = current(l,1), y = current(l,2), dx = mx - x, dy = my - y; 1.1481 + if (dx>=0 && dx<60 && dy>=0 && dy<60) { selected = true; ind = l; current(l,3) = dx; current(l,4) = dy; } 1.1482 + } 1.1483 + if (ind>=0 && ind<last) { 1.1484 + const CImg<int> vec = current.get_column(ind); 1.1485 + current.draw_image(ind,current.get_crop(ind+1,last)).draw_image(last,vec); 1.1486 + } 1.1487 + } else { current(last,1) = mx - current(last,3); current(last,2) = my - current(last,4); refresh_canvas = true; } 1.1488 + } 1.1489 + } else { 1.1490 + bool win = true; 1.1491 + cimg_forX(solution,j) if (!solution(j,3)) { 1.1492 + win = false; 1.1493 + const int x = solution(j,1), y = solution(j,2); 1.1494 + cimg_forX(current,i) if (!current(i,5) && solution(j)==current(i)) { 1.1495 + const int xc = current(i,1), yc = current(i,2), dx = cimg::abs(x-xc), dy = cimg::abs(y-yc); 1.1496 + if (dx<=12 && dy<=12) { 1.1497 + cimg_forV(background,k) cimg_forY(letters[0],y) 1.1498 + background.get_shared_line(solution(j,2)+y,0,k). 1.1499 + draw_image(solution(j,1),0, 1.1500 + (CImg<float>(cletters(solution(j)-'A').get_shared_line(y,0,k))*=2.0*std::cos((y-30.0f)/18)). 1.1501 + cut(0,255),0.8f); 1.1502 + current(i,5) = solution(j,3) = 1; refresh_canvas = true; 1.1503 + } 1.1504 + } 1.1505 + } 1.1506 + selected = false; 1.1507 + if (win) { stopflag = true; completed = 1; } 1.1508 + } 1.1509 + } 1.1510 + 1.1511 + // Display final score 1.1512 + const char 1.1513 + *const mention0 = "Need more training !", *const mention1 = "Still amateur, hu ?", 1.1514 + *const mention2 = "Not so bad !", *const mention3 = " Good !", *const mention4 = "Very good !", 1.1515 + *const mention5 = " Expert !", 1.1516 + *mention = completed?(timer<700?mention5:timer<800?mention4:timer<900?mention3:timer<1000?mention2:timer<1200?mention1:mention0):mention0; 1.1517 + canvas.assign().draw_text(0,0,"Final time : %d\n\n%s",white,0,1,32,timer,mention); 1.1518 + ((background/=2)&CImg<unsigned char>(2,2).fill(0,255,255,0).resize(background,0,2)). 1.1519 + draw_image((background.dimx()-canvas.dimx())/2,(background.dimy()-canvas.dimy())/2, 1.1520 + canvas,canvas.get_dilate(3).dilate(3).dilate(3),1,255).display(disp.flush()); 1.1521 + while (!disp.is_closed && !disp.key && !disp.button) disp.resize(disp).wait(); 1.1522 + } 1.1523 + return 0; 1.1524 +} 1.1525 + 1.1526 +// Run a selected effect 1.1527 +//----------------------- 1.1528 +void start_item(const unsigned int demo_number) { 1.1529 + switch (demo_number) { 1.1530 + case 1: item_blurring_gradient(); break; 1.1531 + case 2: item_rotozoom(); break; 1.1532 + case 3: item_anisotropic_smoothing(); break; 1.1533 + case 4: item_fractal_animation(); break; 1.1534 + case 5: item_gamma_correction(); break; 1.1535 + case 6: item_filled_triangles(); break; 1.1536 + case 7: item_mandelbrot_explorer(); break; 1.1537 + case 8: item_mini_paint(); break; 1.1538 + case 9: item_soccer_bobs(); break; 1.1539 + case 10: item_bump(); break; 1.1540 + case 11: item_bouncing_bubble(); break; 1.1541 + case 12: item_virtual_landscape(); break; 1.1542 + case 13: item_plasma(); break; 1.1543 + case 14: item_oriented_convolutions(); break; 1.1544 + case 15: item_shade_bobs(); break; 1.1545 + case 16: item_fourier_filtering(); break; 1.1546 + case 17: item_image_zoomer(); break; 1.1547 + case 18: item_blobs_editor(); break; 1.1548 + case 19: item_double_torus(); break; 1.1549 + case 20: item_3d_metaballs(); break; 1.1550 + case 21: item_fireworks(); break; 1.1551 + case 22: item_rubber_logo(); break; 1.1552 + case 23: item_image_waves(); break; 1.1553 + case 24: item_breakout(); break; 1.1554 + case 25: item_3d_reflection(); break; 1.1555 + case 26: item_fisheye_magnification(); break; 1.1556 + case 27: item_word_puzzle(); break; 1.1557 + default: break; 1.1558 + } 1.1559 +} 1.1560 + 1.1561 +/*--------------------------- 1.1562 + 1.1563 + Main procedure 1.1564 + 1.1565 + --------------------------*/ 1.1566 +int main(int argc, char **argv) { 1.1567 + 1.1568 + // Display info about the CImg Library configuration 1.1569 + //-------------------------------------------------- 1.1570 + unsigned int demo_number = cimg_option("-run",0,0); 1.1571 + if (demo_number) start_item(demo_number); 1.1572 + else { 1.1573 + cimg::info(); 1.1574 + 1.1575 + // Demo selection menu 1.1576 + //--------------------- 1.1577 + const unsigned char 1.1578 + white[] = { 255,255,255 }, black[] = { 0,0,0 }, red[] = { 120,50,80 }, 1.1579 + yellow[] = { 200,155,0 }, green[] = { 30,200,70 }, purple[] = { 175,32,186 }, 1.1580 + blue[] = { 55,140,185 }, grey[] = { 127,127,127 }; 1.1581 + float 1.1582 + rx = 0, ry = 0, t = 0, gamma = 0, vgamma = 0, T = 0.9f, 1.1583 + nrx = (float)(2*cimg::crand()), 1.1584 + nry = (float)(2*cimg::crand()); 1.1585 + int y0 = 2*13; 1.1586 + CImg<unsigned char> back(1,2,1,3,10), fore, text, img; 1.1587 + back.fillV(0,1,0,10,10,235).resize(320,420,1,3,3).get_shared_channel(2).noise(10,1).draw_plasma(); 1.1588 + back.draw_rectangle(0,y0-7,back.dimx()-1,y0+20,red); 1.1589 + fore.assign(back.dimx(),50,1,1,0).draw_text(20,y0-5,"** CImg %u.%u.%u Samples **",grey,0,1,22, 1.1590 + cimg_version/100,(cimg_version/10)%10,cimg_version%10); 1.1591 + (fore+=fore.get_dilate(3).dilate(3)).resize(-100,-100,1,3); 1.1592 + cimg_forXY(fore,x,y) 1.1593 + if (fore(x,y)==127) fore(x,y,0) = fore(x,y,1) = fore(x,y,2) = 1; 1.1594 + else if (fore(x,y)) { 1.1595 + const float val = cimg::min(255.0f,7.0f*(y-3)); 1.1596 + fore(x,y,0) = (unsigned char)(val/1.5f); 1.1597 + fore(x,y,1) = (unsigned char)val; 1.1598 + fore(x,y,2) = (unsigned char)(val/1.1f); 1.1599 + } 1.1600 + text.draw_text(1,1, 1.1601 + "1- Blurring Gradient\n" 1.1602 + "2- Rotozoom\n" 1.1603 + "3- Anisotropic Smoothing\n" 1.1604 + "4- Fractal Animation\n" 1.1605 + "5- Gamma Correction\n" 1.1606 + "6- Filled Triangles\n" 1.1607 + "7- Mandelbrot explorer\n" 1.1608 + "8- Mini-Paint\n" 1.1609 + "9- Soccer Bobs\n" 1.1610 + "10- Bump Effect\n" 1.1611 + "11- Bouncing Bubble\n" 1.1612 + "12- Virtual Landscape\n" 1.1613 + "13- Plasma & Sinus Scroll\n" 1.1614 + "14- Oriented Convolutions\n" 1.1615 + "15- Shade Bobs\n" 1.1616 + "16- Fourier Filtering\n" 1.1617 + "17- Image Zoomer\n" 1.1618 + "18- Blobs Editor\n" 1.1619 + "19- Double Torus\n" 1.1620 + "20- 3D Metaballs\n" 1.1621 + "21- Fireworks\n" 1.1622 + "22- Rubber Logo\n" 1.1623 + "23- Image Waves\n" 1.1624 + "24- Breakout\n" 1.1625 + "25- 3D Reflection\n" 1.1626 + "26- Fish-Eye Magnification\n" 1.1627 + "27- Word Puzzle\n", 1.1628 + white,0,1,13); 1.1629 + fore.resize(back,0).draw_image(20,y0+2*13,text|=text.get_dilate(3)>>4); 1.1630 + 1.1631 + CImgDisplay disp(back,"CImg Library Samples",0,false,true); 1.1632 + disp.move((disp.screen_dimx()-disp.window_dimx())/2,(disp.screen_dimy()-disp.window_dimy())/2); 1.1633 + img = back; back*=0.15f; 1.1634 + for (y0+=2*13; !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC; demo_number = 0) { 1.1635 + while (!demo_number && !disp.is_closed && !disp.is_keyQ && !disp.is_keyESC) { 1.1636 + img*=0.85f; img+=back; 1.1637 + for (int i = 0; i<60; ++i) { 1.1638 + const float 1.1639 + mx = (float)(img.dimx()/2+(img.dimx()/2-30)*((1-gamma)*std::cos(3*t+rx*i*18.0f*cimg::valuePI/180) + 1.1640 + gamma*std::cos(3*t+nrx*i*18.0f*cimg::valuePI/180))), 1.1641 + my = (float)(img.dimy()/2+(img.dimy()/2-30)*((1-gamma)*std::sin(4*t+ry*i*18.0f*cimg::valuePI/180) + 1.1642 + gamma*std::sin(4*t+nry*i*18.0f*cimg::valuePI/180))), 1.1643 + mz = (float)(1.3f + 1.2f*((1-gamma)*std::sin(2*t+(rx+ry)*i*20*cimg::valuePI/180) + 1.1644 + gamma*std::sin(2*t+(nrx+nry)*i*20*cimg::valuePI/180))); 1.1645 + const int j = i%5; 1.1646 + img.draw_circle((int)mx,(int)my,(int)(10*mz),j!=0?(j!=1?(j!=2?(j!=3?green:red):yellow):purple):blue,0.2f). 1.1647 + draw_circle((int)(mx+4*mz),(int)(my-4),(int)(3*mz),white,0.1f). 1.1648 + draw_circle((int)mx,(int)my,(int)(10*mz),black,0.2f,~0U); 1.1649 + } 1.1650 + const unsigned char *ptrs = fore.end(); 1.1651 + cimg_for(img,ptrd,unsigned char) { const unsigned char val = *(--ptrs); if (val) *ptrd = val; } 1.1652 + int y = disp.mouse_y; 1.1653 + if (y>=y0 && y<y0+27*13) { 1.1654 + y = (y/13)*13+7; 1.1655 + for (int yy = y-7; yy<=y+6; ++yy) img.draw_rectangle(0,yy,0,1,img.dimx()-1,yy,0,1,(unsigned char)(130-15*cimg::abs(yy-y))); 1.1656 + img.draw_triangle(2,y-4,2,y+4,8,y,yellow).draw_triangle(img.dimx()-2,y-4,img.dimx()-2,y+4,img.dimx()-8,y,yellow); 1.1657 + } 1.1658 + gamma+=vgamma; if (gamma>1) { gamma = vgamma = 0; rx = nrx; ry = nry; nrx=(float)(2*cimg::crand()); nry=(float)(2*cimg::crand()); } 1.1659 + t+=0.006f; T+=0.005f; if (T>1) { T-=(float)(1+cimg::crand()); vgamma = 0.03f; } 1.1660 + if (disp.button) { disp.button = 0; demo_number = 1+(disp.mouse_y-y0)/13; } 1.1661 + disp.resize(disp,false).display(img).wait(25); 1.1662 + } 1.1663 + start_item(demo_number); 1.1664 + } 1.1665 + } 1.1666 + 1.1667 + // Exit demo 1.1668 + //----------- 1.1669 + std::exit(0); 1.1670 + return 0; 1.1671 +}