From 2a41e3b4304314bf927557caac53616c0f41b39d Mon Sep 17 00:00:00 2001
From: William DURAND <william.durand1@gmail.com>
Date: Mon, 5 Dec 2011 17:17:32 +0100
Subject: [PATCH] Added Euclidean distance calculations

---
 Euclidean.cpp | 11 ++++++++
 Euclidean.hpp | 39 ++++++++++++++++++++++++++
 Makefile      |  9 +++---
 main.cpp      | 77 +++++++++++++++++++++++++++++++++++++++++++--------
 4 files changed, 121 insertions(+), 15 deletions(-)
 create mode 100644 Euclidean.cpp
 create mode 100644 Euclidean.hpp

diff --git a/Euclidean.cpp b/Euclidean.cpp
new file mode 100644
index 0000000..2522945
--- /dev/null
+++ b/Euclidean.cpp
@@ -0,0 +1,11 @@
+#include "Euclidean.hpp"
+
+double Euclidean::computeDistanceFrom(const Euclidean & euclidian)
+{
+    double diffx = _x - euclidian.getX();
+    double diffy = _y - euclidian.getY();
+    double diffx_sqr = pow(diffx, 2);
+    double diffy_sqr = pow(diffy, 2);
+
+    return sqrt(diffx_sqr + diffy_sqr);
+}
diff --git a/Euclidean.hpp b/Euclidean.hpp
new file mode 100644
index 0000000..4a6c682
--- /dev/null
+++ b/Euclidean.hpp
@@ -0,0 +1,39 @@
+#ifndef __EUCLIDIAN_HPP__
+#define __EUCLIDIAN_HPP__
+
+#include <math.h>
+
+class Euclidean
+{
+    public:
+        Euclidean(const int x, const int y) : _x(x), _y(y) {}
+
+        void setX(const int x) { _x = x; }
+
+        int getX() const { return _x; }
+
+        void setY(const int y) { _y = y; }
+
+        int getY() const { return _y; }
+
+        void setDistance(const double distance) { _distance = distance; }
+
+        double getDistance() const { return _distance; }
+
+        void setNearest(Euclidean & nearest) { _nearest = &nearest; }
+
+        Euclidean* getNearest() const { return _nearest; }
+
+        double computeDistanceFrom(const Euclidean & euclidian);
+
+    private:
+        int _x;
+
+        int _y;
+
+        double _distance;
+
+        Euclidean *_nearest;
+};
+
+#endif
diff --git a/Makefile b/Makefile
index 4691aaa..d75657d 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@
 .SUFFIXES:.cpp .o
 
 EXEC=emd
-SOURCES=main.cpp
+SOURCES=main.cpp Euclidean.cpp
 
 OBJETS=$(SOURCES:%.cpp=%.o)
 
@@ -16,9 +16,9 @@ $(EXEC):$(OBJETS) Makefile
 	$(CC) $(CFLAGS) -c $< -o $@
 
 clean:
-	rm $(OBJETS)
+	rm -f $(OBJETS)
 clear:
-	rm $(EXEC)
+	rm -f $(EXEC)
 depend:
 	sed -e "/^#DEPENDANCIES/,$$ d" Makefile >dependances
 	echo "#DEPENDANCIES" >> dependances
@@ -26,4 +26,5 @@ depend:
 	cat dependances >Makefile
 	rm dependances
 
-main.o: main.cpp
+main.o: main.cpp Euclidean.hpp
+Euclidean.o: Euclidean.cpp
diff --git a/main.cpp b/main.cpp
index 309415d..5c64e9e 100644
--- a/main.cpp
+++ b/main.cpp
@@ -7,6 +7,9 @@
 
 #include "CImg.h"
 #include <math.h>
+#include <vector>
+
+#include "Euclidean.hpp"
 
 using namespace cimg_library;
 
@@ -19,14 +22,16 @@ int main()
 
     CImgDisplay dispBase(imgLena,"Image de base");
 
+    std::vector<Euclidean> vectEMax, vectEMin;
+
     ///////////////////////////////////////////////////////////////////////////////
     //                        Part 1: Finding minimas and maximas                //
     ///////////////////////////////////////////////////////////////////////////////
-	CImg<unsigned char> imgMax = imgLena.channel(0);
-	CImg<unsigned char> imgMin = imgLena.channel(0);
+    CImg<unsigned char> imgMax = imgLena.channel(0);
+    CImg<unsigned char> imgMin = imgLena.channel(0);
+
+    imgMax.print();
 
-	imgMax.print();
-    
     for (int i = 0; i<imgLena.width() ; i+=3) {
         for (int j = 0; j<imgLena.height() ; j+=3) {
 
@@ -40,6 +45,9 @@ int main()
             unsigned char max = imgMax(i,j);
             unsigned char min = imgMin(i,j);
 
+            Euclidean eMax(i, j);
+            Euclidean eMin(i, j);
+
             // 3x3
             for (int k = i; k<i+3 ; k++) {
                 for (int l = j; l<j+3 ; l++) {
@@ -52,6 +60,9 @@ int main()
                         imgMax(xmax,ymax) = 0;
                         xmax = k;
                         ymax = l;
+
+                        eMax.setX(k);
+                        eMax.setY(l);
                     }
 
                     // Min
@@ -59,15 +70,64 @@ int main()
                         imgMin(k,l) = 0;
                     } else {
                         min = imgMin(k,l);
-						imgMin(xmin,ymin) = 0;
+                        imgMin(xmin,ymin) = 0;
                         xmin = k;
                         ymin = l;
+
+                        eMin.setX(k);
+                        eMin.setY(l);
                     }
                 }
             }
+
+            vectEMax.push_back(eMax);
+            vectEMin.push_back(eMin);
         }
     }
 
+    // Array of Euclidean distance to the nearest non zero element
+    std::vector<Euclidean>::iterator it1, it2;
+
+    for (it1 = vectEMax.begin(); it1 != vectEMax.end(); it1++) {
+        for (it2 = it1 + 1; it2 != vectEMax.end(); it2++) {
+            double dist = (*it1).computeDistanceFrom(*it2);
+
+            if (0 == (*it1).getDistance() || dist < (*it1).getDistance()) {
+                (*it1).setDistance(dist);
+                (*it1).setNearest(*it2);
+            }
+
+            if (0 == (*it2).getDistance() || dist < (*it2).getDistance()) {
+                (*it2).setDistance(dist);
+                (*it2).setNearest(*it1);
+            }
+        }
+    }
+
+    for (it1 = vectEMin.begin(); it1 != vectEMin.end(); it1++) {
+        for (it2 = it1 + 1; it2 != vectEMin.end(); it2++) {
+            double dist = (*it1).computeDistanceFrom(*it2);
+
+            if (0 == (*it1).getDistance() || dist < (*it1).getDistance()) {
+                (*it1).setDistance(dist);
+                (*it1).setNearest(*it2);
+            }
+
+            if (0 == (*it2).getDistance() || dist < (*it2).getDistance()) {
+                (*it2).setDistance(dist);
+                (*it2).setNearest(*it1);
+            }
+        }
+    }
+
+    // Calculate the window size
+
+    // Order filters with source image
+
+    // Calculate the upper envelope
+
+    // Calculate the lower envelope
+
     // Display images for max and min
     CImgDisplay dispMax(imgMax,"Image de Max");
     CImgDisplay dispMin(imgMin,"Image de Min");
@@ -76,12 +136,7 @@ int main()
     //                        Part 2: Average                                    //
     ///////////////////////////////////////////////////////////////////////////////
 
-    // Calculate the upper envelope
-	// ??
-	// Calculate the lower envelope
-	// ??
-    
-	// Calculate the Average
+    // Calculate the Average
     CImg<unsigned char> imgMoyenne = (imgMax+imgMin)/2;
     CImgDisplay dispMoyenne(imgMoyenne,"Image Moyenne");