Squashed 'third_party/cimg/' content from commit 4b66369
Change-Id: I7454d9107a08dba899fd4659731733049165ae0a
git-subtree-dir: third_party/cimg
git-subtree-split: 4b66369ab4e34a46119d6c43e9adce061bb40f4b
diff --git a/examples/edge_explorer2d.cpp b/examples/edge_explorer2d.cpp
new file mode 100644
index 0000000..9d32ece
--- /dev/null
+++ b/examples/edge_explorer2d.cpp
@@ -0,0 +1,218 @@
+/*
+ #
+ # File : edge_explorer2d.cpp
+ # ( C++ source file )
+ #
+ # Description : Real time edge detection while moving a ROI
+ # (rectangle of interest) over the original image.
+ # This file is a part of the CImg Library project.
+ # ( http://cimg.eu )
+ #
+ # Copyright : Orges Leka
+ # ( oleka(at)students.uni-mainz.de )
+ #
+ # 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;
+#ifndef cimg_imagepath
+#define cimg_imagepath "img/"
+#endif
+
+// Main procedure
+//----------------
+int main(int argc, char** argv) {
+
+ // Usage of the program displayed at the command line
+ cimg_usage("Real time edge detection with CImg. (c) Orges Leka");
+
+ // Read command line arguments
+ // With cimg_option we can get a new name for the image which is to be loaded from the command line.
+ const char* img_name = cimg_option("-i", cimg_imagepath "parrot.ppm","Input image.");
+ double
+ alpha = cimg_option("-a",1.0,"Blurring the gradient image."),
+ thresL = cimg_option("-tl",13.5,"Lower thresholding used in Hysteresis."),
+ thresH = cimg_option("-th",13.6,"Higher thresholding used in Hysteresis.");
+ const unsigned int
+ mode = cimg_option("-m",1,"Detection mode: 1 = Hysteresis, 2 = Gradient angle."),
+ factor = cimg_option("-s",80,"Half-size of edge-explorer window.");
+
+ cimg_help("\nAdditional notes : user can press following keys on main display window :\n"
+ " - Left arrow : Decrease alpha.\n"
+ " - Right arrow : Increase alpha.\n");
+
+ // Construct a new image called 'edge' of size (2*factor,2*factor)
+ // and of type 'unsigned char'.
+ CImg<unsigned char> edge(2*factor,2*factor);
+ CImgDisplay disp_edge(512,512,"Edge Explorer");
+
+ // Load the image with the name 'img_name' into the CImg 'img'.
+ // and create a display window 'disp' for the image 'img'.
+ const CImg<unsigned char> img = CImg<float>::get_load(img_name).norm().normalize(0,255);
+ CImgDisplay disp(img,"Original Image");
+
+ // Begin main interaction loop.
+ int x = 0, y = 0;
+ bool redraw = false;
+ while (!disp.is_closed() && !disp.is_keyQ() && !disp.is_keyESC()) {
+ disp.wait(100);
+ if (disp.button()&1) { alpha+=0.05; redraw = true; }
+ if (disp.button()&2) { alpha-=0.05; redraw = true; }
+ if (disp.wheel()) { alpha+=0.05*disp.wheel(); disp.set_wheel(); redraw = true; }
+ if (alpha<0) alpha = 0;
+ if (disp_edge.is_resized()) { disp_edge.resize(); redraw = true; }
+ if (disp_edge.is_closed()) disp_edge.show();
+ if (disp.is_resized()) disp.resize(disp);
+ if (disp.mouse_x()>=0) {
+ x = disp.mouse_x(); // Getting the current position of the mouse
+ y = disp.mouse_y(); //
+ redraw = true; // The image should be redrawn
+ }
+ if (redraw) {
+ disp_edge.set_title("Edge explorer (alpha=%g)",alpha);
+ const int
+ x0 = x - factor, y0 = y - factor, // These are the coordinates for the red rectangle
+ x1 = x + factor, y1 = y + factor; // to be drawn on the original image
+ const unsigned char
+ red[3] = { 255,0,0 }, //
+ black[3] = { 0,0,0 }; // Defining the colors we need for drawing
+
+ (+img).draw_rectangle(x0,y0,x1,y1,red,1.0f,0x55555555U).display(disp);
+ //^ We draw the red rectangle on the original window using 'draw_line'.
+ // Then we display the result via '.display(disp)' .
+ // Observe, that the color 'red' has to be of type 'const unsigned char',
+ // since the image 'img' is of type 'const CImg<unsigned char>'.
+
+ //'normalize' is used to get a greyscaled image.
+ CImg<> visu_bw = CImg<>(img).get_crop(x0,y0,x1,y1).get_norm().normalize(0,255).resize(-100,-100,1,2,2);
+ // get_crop(x0,y0,x1,y1) gets the rectangle we are interested in.
+
+ edge.fill(255); // Background color in the edge-detection window is white
+
+ // grad[0] is the gradient image of 'visu_bw' in x-direction.
+ // grad[1] is the gradient image of 'visu_bw' in y-direction.
+ CImgList<> grad(visu_bw.blur((float)alpha).normalize(0,255).get_gradient());
+
+ // To avoid unnecessary calculations in the image loops:
+ const double
+ pi = cimg::PI,
+ p8 = pi/8.0, p38 = 3.0*p8,
+ p58 = 5.0*p8, p78 = 7.0*p8;
+
+ cimg_forXY(visu_bw,s,t) {
+ // We take s,t instead of x,y, since x,y are already used.
+ // s corresponds to the x-ordinate of the pixel while t corresponds to the y-ordinate.
+ if ( 1 <= s && s <= visu_bw.width() - 1 && 1 <= t && t <=visu_bw.height() - 1) { // if - good points
+ double
+ Gs = grad[0](s,t), //
+ Gt = grad[1](s,t), // The actual pixel is (s,t)
+ Gst = cimg::abs(Gs) + cimg::abs(Gt), //
+ // ^-- For efficient computation we observe that |Gs|+ |Gt| ~=~ sqrt( Gs^2 + Gt^2)
+ Gr, Gur, Gu, Gul, Gl, Gdl, Gd, Gdr;
+ // ^-- right, up right, up, up left, left, down left, down, down right.
+ double theta = std::atan2(std::max(1e-8,Gt),Gs) + pi; // theta is from the interval [0,Pi]
+ switch(mode) {
+ case 1: // Hysterese is applied
+ if (Gst>=thresH) { edge.draw_point(s,t,black); }
+ else if (thresL <= Gst && Gst < thresH) {
+ // Neighbourhood of the actual pixel:
+ Gr = cimg::abs(grad[0](s + 1,t)) + cimg::abs(grad[1](s + 1,t)); // right
+ Gl = cimg::abs(grad[0](s - 1,t)) + cimg::abs(grad[1](s - 1,t)); // left
+ Gur = cimg::abs(grad[0](s + 1,t + 1)) + cimg::abs(grad[1](s + 1,t + 1)); // up right
+ Gdl = cimg::abs(grad[0](s - 1,t - 1)) + cimg::abs(grad[1](s - 1,t - 1)); // down left
+ Gu = cimg::abs(grad[0](s,t + 1)) + cimg::abs(grad[1](s,t + 1)); // up
+ Gd = cimg::abs(grad[0](s,t - 1)) + cimg::abs(grad[1](s,t - 1)); // down
+ Gul = cimg::abs(grad[0](s - 1,t + 1)) + cimg::abs(grad[1](s - 1,t + 1)); // up left
+ Gdr = cimg::abs(grad[0](s + 1,t - 1)) + cimg::abs(grad[1](s + 1,t - 1)); // down right
+ if (Gr>=thresH || Gur>=thresH || Gu>=thresH || Gul>=thresH
+ || Gl>=thresH || Gdl >=thresH || Gu >=thresH || Gdr >=thresH) {
+ edge.draw_point(s,t,black);
+ }
+ };
+ break;
+ case 2: // Angle 'theta' of the gradient (Gs,Gt) at the point (s,t)
+ if(theta >= pi)theta-=pi;
+ //rounding theta:
+ if ((p8 < theta && theta <= p38 ) || (p78 < theta && theta <= pi)) {
+ // See (*) below for explanation of the vocabulary used.
+ // Direction-pixel is (s + 1,t) with corresponding gradient value Gr.
+ Gr = cimg::abs(grad[0](s + 1,t)) + cimg::abs(grad[1](s + 1,t)); // right
+ // Contra-direction-pixel is (s - 1,t) with corresponding gradient value Gl.
+ Gl = cimg::abs(grad[0](s - 1,t)) + cimg::abs(grad[1](s - 1,t)); // left
+ if (Gr < Gst && Gl < Gst) {
+ edge.draw_point(s,t,black);
+ }
+ }
+ else if ( p8 < theta && theta <= p38) {
+ // Direction-pixel is (s + 1,t + 1) with corresponding gradient value Gur.
+ Gur = cimg::abs(grad[0](s + 1,t + 1)) + cimg::abs(grad[1](s + 1,t + 1)); // up right
+ // Contra-direction-pixel is (s-1,t-1) with corresponding gradient value Gdl.
+ Gdl = cimg::abs(grad[0](s - 1,t - 1)) + cimg::abs(grad[1](s - 1,t - 1)); // down left
+ if (Gur < Gst && Gdl < Gst) {
+ edge.draw_point(s,t,black);
+ }
+ }
+ else if ( p38 < theta && theta <= p58) {
+ // Direction-pixel is (s,t + 1) with corresponding gradient value Gu.
+ Gu = cimg::abs(grad[0](s,t + 1)) + cimg::abs(grad[1](s,t + 1)); // up
+ // Contra-direction-pixel is (s,t - 1) with corresponding gradient value Gd.
+ Gd = cimg::abs(grad[0](s,t - 1)) + cimg::abs(grad[1](s,t - 1)); // down
+ if (Gu < Gst && Gd < Gst) {
+ edge.draw_point(s,t,black);
+ }
+ }
+ else if (p58 < theta && theta <= p78) {
+ // Direction-pixel is (s - 1,t + 1) with corresponding gradient value Gul.
+ Gul = cimg::abs(grad[0](s - 1,t + 1)) + cimg::abs(grad[1](s - 1,t + 1)); // up left
+ // Contra-direction-pixel is (s + 1,t - 1) with corresponding gradient value Gdr.
+ Gdr = cimg::abs(grad[0](s + 1,t - 1)) + cimg::abs(grad[1](s + 1,t - 1)); // down right
+ if (Gul < Gst && Gdr < Gst) {
+ edge.draw_point(s,t,black);
+ }
+ };
+ break;
+ } // switch
+ } // if good-points
+ } // cimg_forXY */
+ edge.display(disp_edge);
+ }// if redraw
+ } // while
+ return 0;
+}
+
+// (*) Comments to the vocabulary used:
+// If (s,t) is the current pixel, and G=(Gs,Gt) is the gradient at (s,t),
+// then the _direction_pixel_ of (s,t) shall be the one of the eight neighbour pixels
+// of (s,t) in whose direction the gradient G shows.
+// The _contra_direction_pixel is the pixel in the opposite direction in which the gradient G shows.
+// The _corresponding_gradient_value_ of the pixel (x,y) with gradient G = (Gx,Gy)
+// shall be |Gx| + |Gy| ~=~ sqrt(Gx^2 + Gy^2).