New way to calculate the window size

main.cpp

@@ -17,6 +17,8 @@
 
 using namespace cimg_library;
 
+int SIZE = 3;
+
 double Sum(CImg<unsigned char> img, int startedX, int startedY, int w) {
     double res = 0;
     for(int i = startedX - ((w - 1) / 2); i < startedX + ((w + 1) / 2); i++) {
@@ -40,6 +42,32 @@ void ShowMatrix(CImg<unsigned char> img) {
     std::cout << std::endl;
 }
 
+double min(std::vector<Euclidean> vect) {
+	double min = (*vect.begin()).getDistance();
+	std::vector<Euclidean>::iterator it;
+
+	for (it = vect.begin() + 1; it != vect.end(); it++) {
+		if ((*it).getDistance() < min) {
+			min = (*it).getDistance();
+		}
+	}
+
+	return min;
+}
+
+double max(std::vector<Euclidean> vect) {
+	double max = (*vect.begin()).getDistance();
+	std::vector<Euclidean>::iterator it;
+
+	for (it = vect.begin() + 1; it != vect.end(); it++) {
+		if ((*it).getDistance() > max) {
+			max = (*it).getDistance();
+		}
+	}
+
+	return max;
+}
+
 /*******************************************************************************
   Main
  *******************************************************************************/
@@ -71,6 +99,8 @@ int main()
     CImgDisplay dispBase(inputImg,"Image de base");
 #endif
 
+printf("Start\n");
+
     std::vector<Euclidean> vectEMax, vectEMin;
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -79,9 +109,9 @@ int main()
 
     CImg<unsigned char> imgMax(inputImg.channel(0));
     CImg<unsigned char> imgMin(inputImg.channel(0));
-
+printf("  Calculate the extremas..\n");
-    for (int i = 0; i < inputImg.width(); i += 3) {
+    for (int i = 0; i < inputImg.width(); i += SIZE) {
-        for (int j = 0; j < inputImg.height(); j += 3) {
+        for (int j = 0; j < inputImg.height(); j += SIZE) {
 
             // Save max and min locations
             int xmax = i;
@@ -96,9 +126,9 @@ int main()
             Euclidean eMax(i, j);
             Euclidean eMin(i, j);
 
-            // 3x3
+            // SIZExSIZE
-            for (int k = i; k<i+3 ; k++) {
+            for (int k = i; k<i+SIZE ; k++) {
-                for (int l = j; l<j+3 ; l++) {
+                for (int l = j; l<j+SIZE ; l++) {
 
                     // Max
                     if ((imgMax(k,l) <= max) && (l!=ymax || k!=xmax)) {
@@ -156,6 +186,7 @@ int main()
     // Array of Euclidean distance to the nearest non zero element
     std::vector<Euclidean>::iterator it1, it2;
  
+printf("  Calculate the Euclidean distances..\n");
     for (it1 = vectEMax.begin(); it1 != vectEMax.end(); it1++) {
         for (it2 = it1 + 1; it2 != vectEMax.end(); it2++) {
             double dist = (*it1).computeDistanceFrom(*it2);
@@ -189,35 +220,31 @@ int main()
     }
 
     int wmax = 0;
-    std::vector<int> w;
 
-    // Calculate the windows sizes
+printf("  Calculate the window size..\n");
+    // Calculate the window size
     for(unsigned int i = 0; i < vectEMin.size(); i++) {
-        double d1 = MIN(vectEMax[i].getDistance(), vectEMin[i].getDistance());
+        //double d1 = MIN(min(vectEMax), min(vectEMin));
-        double d2 = MAX(vectEMax[i].getDistance(), vectEMin[i].getDistance());
+        //double d2 = MAX(min(vectEMax), min(vectEMin));
-        double d3 = MIN(vectEMax[i].getDistance(), vectEMin[i].getDistance());
+        //double d3 = MIN(max(vectEMax), max(vectEMin));
-        double d4 = MAX(vectEMax[i].getDistance(), vectEMin[i].getDistance());
+        double d4 = MAX(max(vectEMax), max(vectEMin));
 
-        int wi = (int)ceil(MIN(MIN(d1, d2), MIN(d3, d4)));
+        wmax = (int)ceil(d4);
-        if(wi%2 == 0)
+        if(wmax%2 == 0) {
-        {
+            wmax++;
-            wi++;
         }
-        if(wi > wmax) {
-            wmax=wi;
-        }
-        w.push_back(wi);
     }
 
     CImg<unsigned char> imgSource(inputImg.channel(0));
 
+printf("  Order the filters..\n");
     // Order filters with source image
     std::vector<unsigned char> vectFilterMax, vectFilterMin;
 
     for(int unsigned i = 0; i < vectEMax.size(); i++) {
         unsigned char max = 0;
-        for (int k = vectEMax[i].getX() - ((w[i] - 1) / 2); k < vectEMax[i].getX() + ((w[i] + 1) / 2); k++) {
+        for (int k = vectEMax[i].getX() - ((wmax - 1) / 2); k < vectEMax[i].getX() + ((wmax + 1) / 2); k++) {
-            for (int l = vectEMax[i].getY() - ((w[i] - 1) / 2); l < vectEMax[i].getY() + ((w[i] + 1) / 2); l++) {
+            for (int l = vectEMax[i].getY() - ((wmax - 1) / 2); l < vectEMax[i].getY() + ((wmax + 1) / 2); l++) {
                 if( (k>=0 && k<imgSource.width()) && (l>=0  && l<imgSource.height()) ) {
                     if (imgSource(k, l) > max) {
                         max = imgSource(k, l);
@@ -230,8 +257,8 @@ int main()
 
     for(int unsigned i = 0; i < vectEMin.size(); i++) {
         unsigned char min = 255;
-        for (int k = vectEMin[i].getX() - ((w[i] - 1) / 2); k < vectEMin[i].getX() + ((w[i] + 1) / 2); k++) {
+        for (int k = vectEMin[i].getX() - ((wmax - 1) / 2); k < vectEMin[i].getX() + ((wmax + 1) / 2); k++) {
-            for (int l = vectEMin[i].getY() - ((w[i] - 1) / 2); l < vectEMin[i].getY() + ((w[i] + 1) / 2); l++) {
+            for (int l = vectEMin[i].getY() - ((wmax - 1) / 2); l < vectEMin[i].getY() + ((wmax + 1) / 2); l++) {
                 if( (k>=0 && k<imgSource.width()) && (l>=0  && l<imgSource.height()) ) {
                     if (imgSource(k, l) < min) {
                         min = imgSource(k, l);
@@ -244,10 +271,12 @@ int main()
 
     CImg<unsigned char> newImgMax(imgMax.width(), imgMax.height());
 
+printf("  Calculate the upper envelope..\n");
     // Calculate the upper envelope
     for(int unsigned i = 0; i < vectEMax.size(); i++) {
-        for (int k = vectEMax[i].getX() - ((w[i] - 1) / 2); k < vectEMax[i].getX() + ((w[i] + 1) / 2); k++) {
+		//wmax=wmax;
-            for (int l = vectEMax[i].getY() - ((w[i] - 1) / 2); l < vectEMax[i].getY() + ((w[i] + 1) / 2); l++) {
+        for (int k = vectEMax[i].getX() - ((wmax - 1) / 2); k < vectEMax[i].getX() + ((wmax + 1) / 2); k++) {
+            for (int l = vectEMax[i].getY() - ((wmax - 1) / 2); l < vectEMax[i].getY() + ((wmax + 1) / 2); l++) {
                 if( (k>=0 && k<imgSource.width()) && (l>=0  && l<imgSource.height()) ) {
                     imgMax(k, l) = vectFilterMax[i];
                 }
@@ -267,6 +296,7 @@ int main()
     }
 #endif
 
+printf("  Smooth the upper envelope..\n");
     // Smooth of the upper envelope
     for (int k = 0; k < imgSource.width(); k++) {
         for (int l = 0; l < imgSource.height(); l++) {
@@ -278,10 +308,11 @@ int main()
 
     CImg<unsigned char> newImgMin(imgMin.width(), imgMin.height());
 
+printf("  Calculate the lower envelope..\n");
     // Calculate the lower envelope
     for(int unsigned i = 0; i < vectEMin.size(); i++) {
-        for (int k = vectEMin[i].getX() - ((w[i] - 1) / 2); k < vectEMin[i].getX() + ((w[i] + 1) / 2); k++) {
+        for (int k = vectEMin[i].getX() - ((wmax - 1) / 2); k < vectEMin[i].getX() + ((wmax + 1) / 2); k++) {
-            for (int l = vectEMin[i].getY() - ((w[i] - 1) / 2); l < vectEMin[i].getY() + ((w[i] + 1) / 2); l++) {
+            for (int l = vectEMin[i].getY() - ((wmax - 1) / 2); l < vectEMin[i].getY() + ((wmax + 1) / 2); l++) {
                 if( (k>=0 && k<imgSource.width()) && (l>=0  && l<imgSource.height()) ) {
                     imgMin(k, l) = vectFilterMin[i];
                 }
@@ -299,6 +330,7 @@ int main()
     }
 #endif
 
+printf("  Smooth the lower envelope..\n");
     // Smooth of the lower envelope
     for (int k = 0; k < imgSource.width(); k++) {
         for (int l = 0; l < imgSource.height(); l++) {
@@ -338,6 +370,7 @@ int main()
     //                       Part 2: Average                                     //
     ///////////////////////////////////////////////////////////////////////////////
 
+printf("  Average..\n");
     // Calculate the Average
     CImg<unsigned char> imgMoyenne(inputImg.width(), inputImg.height());
 
@@ -366,9 +399,11 @@ int main()
 
 
 #ifndef DEBUG
+printf("  Deletion..\n");
     CImg<unsigned char> imgFin(inputImg - imgMoyenne);
     CImgDisplay dispFin(imgFin, "Image Finale");
 
+printf("End\n");
     while (!dispBase.is_closed()) {
         dispBase.wait();
     }