Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

olena: olena-2.0-590-g8020a9b Fix "too many keypoints" error

by Anthony Seure

--- milena/sandbox/anthony/src/scale_space.cc | 71 +++++++++++++++-------------- 1 files changed, 36 insertions(+), 35 deletions(-) diff --git a/milena/sandbox/anthony/src/scale_space.cc b/milena/sandbox/anthony/src/scale_space.cc index 074eff4..735d3f1 100644 --- a/milena/sandbox/anthony/src/scale_space.cc +++ b/milena/sandbox/anthony/src/scale_space.cc @@ -10,20 +10,20 @@ using namespace mln; -// Set the gaussian kernel of size (6 * t + 1) -double *gaussian_kernel(unsigned t) +// Set the gaussian kernel +double *gaussian_kernel() { - int size = 6 * t + 1; + double variance = sqrt(2.0); unsigned index = 0; - double *kernel = new double[size * size]; + double *kernel = new double[49]; static const double pi = 4.0 * atan(1.0); - double div = (2.0 * pi * t * t); + double div = (2.0 * pi * variance); - for (int i = -(size / 2); i < (size / 2) + 1; ++i) + for (int i = -3; i < 4; ++i) { - for (int j = -(size / 2); j < (size / 2) + 1; ++j) + for (int j = -3; j < 4; ++j) { - double e = exp(- (i * i + j * j) / (2.0 * t * t) ); + double e = exp(- (i*i + j*j) / (2.0 * variance) ); kernel[index++] = e / div; } } @@ -33,14 +33,13 @@ double *gaussian_kernel(unsigned t) // Apply the convolution of the image by the kernel template<typename I> -void convolve(const I& original, I& filtered, double *kernel, unsigned t) +void convolve(const I& original, I& filtered, double *kernel) { mln_piter(I) p(filtered.domain()); - int size = 6 * t + 1; window2d win; - for (int i = -(size / 2); i < (size / 2) + 1; ++i) - for (int j = -(size / 2); j < (size / 2) + 1; ++j) + for (int i = -3; i < 4; ++i) + for (int j = -3; j < 4; ++j) win.insert(i, j); // Iterate through all image sites @@ -66,20 +65,20 @@ void convolve(const I& original, I& filtered, double *kernel, unsigned t) // Blur the image thanks to a convolution matrix template<typename I> -I blur(const I& original, unsigned t) +I blur(const I& original) { I filtered; - double *kernel = gaussian_kernel(t); + double *kernel = gaussian_kernel(); initialize(filtered, original); - convolve(original, filtered, kernel, t); + convolve(original, filtered, kernel); return filtered; } // Downscale by 2 the image resolution template<typename I> -I downscaleResolution(const I& original) +I downscaling2(const I& original) { mln_piter(I) p(original.domain()); window2d win; @@ -142,10 +141,11 @@ void buildOctave(const I& original, io::pgm::save(original, name.str()); octave.push_back(original); + blured = duplicate(original); for(unsigned i = 1; i <= b; i *= 2) { - blured = blur(original, i); + blured = blur(blured); octave.push_back(blured); name.str(""); @@ -169,13 +169,13 @@ void buildScaleSpace(std::vector< std::vector >& scaleSpace, buildOctave(original, 1, b, scaleSpace); // 2nd octave - I reduced = downscaleResolution(original); + I reduced = downscaling2(original); buildOctave(reduced, 2, b, scaleSpace); for (unsigned i = 3; i <= n; ++i) { // i-th octave - reduced = downscaleResolution(reduced); + reduced = downscaling2(reduced); buildOctave(reduced, i, b, scaleSpace); } } @@ -209,7 +209,7 @@ void buildDifferenceOfGaussianSpace(std::vector< std::vector >& scaleSpace, for_all(p) { - int diff = ((int) level2(p)) - ((int) level1(p)); + int diff = ((int) level1(p)) - ((int) level2(p)); dog(p) = (diff >= 0) ? diff : 0; } @@ -238,7 +238,6 @@ void find_extremum(T& min, T& max, const I& current, N n) // Find the minimum value in the upper and lower layers around p template<typename T, typename I, typename P> -//void find_min(T& min, const I& upper, const I& lower, const P& p) void find_min(T& min, const I& upper, const I& lower, const P& pUpper, const P& pLower) { mln_niter(neighb2d) nUpper(c8(), pUpper); @@ -257,7 +256,6 @@ void find_min(T& min, const I& upper, const I& lower, const P& pUpper, const P& // Find the maximum value in the upper and lower layers around p template<typename T, typename I, typename P> -//void find_max(T& max, const I& upper, const I& lower, const P& p) void find_max(T& max, const I& upper, const I& lower, const P& pUpper, const P& pLower) { mln_niter(neighb2d) nUpper(c8(), pUpper); @@ -281,12 +279,11 @@ void buildExtrema(C extrema, std::vector< std::vector >& dogSpace) { extrema = data::convert(value::rgb8(), original); - //initialize(extrema, original); - value::int_u8 min = 255; - value::int_u8 max = 0; - value::int_u8 center = 0; + //value::int_u8 min = 255; + //value::int_u8 max = 0; + //value::int_u8 center = 0; - const unsigned blur_level = dogSpace.at(0).size(); //TODO Reverse the vector + const unsigned blur_level = dogSpace.at(0).size(); //unsigned i = 0; for (unsigned i = 0; i < blur_level; ++i) @@ -301,6 +298,10 @@ void buildExtrema(C extrema, for_all(p) { + value::int_u8 min = 255; + value::int_u8 max = 0; + value::int_u8 center = 0; + mln_niter(neighb2d) n(c8(), p); center = current(p); @@ -313,19 +314,19 @@ void buildExtrema(C extrema, { find_min(min, upper, lower, pUpper, pLower); - if (center <= min) + if (center < min) { - mln_psite(I) pOriginal(p.row() * (j+1), p.col() * (j+1)); - extrema(pOriginal) = literal::blue; + mln_psite(I) pOriginal(p.row() * pow(2, j), p.col() * pow(2, j)); + extrema(pOriginal) = literal::red; } } else if (center >= max) { - find_max(min, upper, lower, pUpper, pLower); + find_max(max, upper, lower, pUpper, pLower); - if (center >= max) + if (center > max) { - mln_psite(I) pOriginal(p.row() * (j+1), p.col() * (j+1)); + mln_psite(I) pOriginal(p.row() * pow(2, j), p.col() * pow(2, j)); extrema(pOriginal) = literal::red; } } @@ -342,14 +343,14 @@ int main(int argc, char** argv) typedef image2d<value::int_u8> I; typedef image2d<value::rgb8> C; - const unsigned blur_level = 4; + const unsigned blur_level = 5; const unsigned octave_level = 4; std::vector< std::vector > scaleSpace; std::vector< std::vector > dogSpace; I original; C extrema; - io::pgm::load(original, "images/keith512.pgm"); + io::pgm::load(original, "images/lena.pgm"); buildScaleSpace(scaleSpace, original, octave_level, blur_level); buildDifferenceOfGaussianSpace(scaleSpace, dogSpace); -- 1.7.2.5

11 years, 7 months

olena: branch sandbox/anthony updated: olena-2.0-591-ga674962

by git＠lrde.epita.fr

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Olena, a generic and efficient image processing platform". The branch sandbox/anthony has been updated via a674962cd9a863e37b7165bd4ef5a1d8fddde6d1 (commit) from 8020a9b93b5ccdafd6fcf810cc3cddafe70a1dae (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- a674962 Add upscaled first octave ----------------------------------------------------------------------- Summary of changes: milena/sandbox/anthony/src/scale_space.cc | 191 ++++++++++++++++++++++++++--- 1 files changed, 174 insertions(+), 17 deletions(-) hooks/post-receive -- Olena, a generic and efficient image processing platform

11 years, 7 months

olena: olena-2.0-591-ga674962 Add upscaled first octave

by Anthony Seure

--- milena/sandbox/anthony/src/scale_space.cc | 191 ++++++++++++++++++++++++++--- 1 files changed, 174 insertions(+), 17 deletions(-) diff --git a/milena/sandbox/anthony/src/scale_space.cc b/milena/sandbox/anthony/src/scale_space.cc index 735d3f1..87853ef 100644 --- a/milena/sandbox/anthony/src/scale_space.cc +++ b/milena/sandbox/anthony/src/scale_space.cc @@ -11,19 +11,19 @@ using namespace mln; // Set the gaussian kernel -double *gaussian_kernel() +float *gaussian_kernel() { - double variance = sqrt(2.0); + float variance = sqrt(2.0); unsigned index = 0; - double *kernel = new double[49]; - static const double pi = 4.0 * atan(1.0); - double div = (2.0 * pi * variance); + float *kernel = new float[49]; + static const float pi = 4.0 * atan(1.0); + float div = (2.0 * pi * variance); for (int i = -3; i < 4; ++i) { for (int j = -3; j < 4; ++j) { - double e = exp(- (i*i + j*j) / (2.0 * variance) ); + float e = exp(- (i*i + j*j) / (2.0 * variance) ); kernel[index++] = e / div; } } @@ -33,7 +33,7 @@ double *gaussian_kernel() // Apply the convolution of the image by the kernel template<typename I> -void convolve(const I& original, I& filtered, double *kernel) +void convolve(const I& original, I& filtered, float *kernel) { mln_piter(I) p(filtered.domain()); window2d win; @@ -68,7 +68,7 @@ template<typename I> I blur(const I& original) { I filtered; - double *kernel = gaussian_kernel(); + float *kernel = gaussian_kernel(); initialize(filtered, original); convolve(original, filtered, kernel); @@ -125,6 +125,160 @@ I downscaling2(const I& original) return reduced; } +float *upscalingTL_kernel() +{ + const static float one = 1.0 / 8.0; + const static float two = 2.0 / 8.0; + const static float three = 2.0 / 8.0; + const static float four = 3.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingTR_kernel() +{ + const static float one = 2.0 / 8.0; + const static float two = 1.0 / 8.0; + const static float three = 3.0 / 8.0; + const static float four = 2.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingBL_kernel() +{ + const static float one = 2.0 / 8.0; + const static float two = 3.0 / 8.0; + const static float three = 1.0 / 8.0; + const static float four = 2.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingBR_kernel() +{ + const static float one = 3.0 / 8.0; + const static float two = 2.0 / 8.0; + const static float three = 2.0 / 8.0; + const static float four = 1.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +template<typename I> +unsigned upscalePixel(const I& original, int i, int j, int type) +{ + float *kernel; + window2d win; + mln_psite(I) p(i, j); + float value = 0; + unsigned index = 0; + int iStart = 0; + int jStart = 0; + + if (type == 0) + { + kernel = upscalingTL_kernel(); + iStart = -1; + jStart = -1; + } + else if (type == 1) + { + kernel = upscalingTR_kernel(); + iStart = 0; + jStart = -1; + } + else if (type == 2) + { + kernel = upscalingBL_kernel(); + iStart = -1; + jStart = 0; + } + else + { + kernel = upscalingBR_kernel(); + iStart = 0; + jStart = 0; + } + + for (int ii = iStart; ii < iStart + 2; ++ii) + for (int jj = jStart; jj < jStart + 2; ++jj) + win.insert(ii, jj); + + mln_qiter(window2d) q(win, p); + + for_all(q) + { + if (original.has(q)) + { + value += original(q) * kernel[index]; + } + + ++index; + } + + return (static_cast<int>(value)); +} + +// Upscale by 2 the image resolution +template<typename I> +I upscaling2(const I& original) +{ + box2d size(original.nrows() * 2, original.ncols() * 2); + I upscaled(size); + + mln_piter(I) p(upscaled.domain()); + int index = 0; + + for_all(p) + { + int i = p.col(); + int j = p.row(); + + if (i % 2 == 0 && j % 2 == 0) // Top left + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 0); + else if (i % 2 == 0) // Bottom left + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 2); + else if (j % 2 == 0) // Top right + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 1); + else // Bottom right + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 3); + + ++index; + } + + + return upscaled; +} + // Build the n-th octave on b blur levels template<typename I> void buildOctave(const I& original, @@ -165,18 +319,22 @@ void buildScaleSpace(std::vector< std::vector >& scaleSpace, { if (n > 2) { + // Upscaled octave + I upscaled = upscaling2(original); + buildOctave(upscaled, 0, b, scaleSpace); + // 1st octave buildOctave(original, 1, b, scaleSpace); // 2nd octave - I reduced = downscaling2(original); - buildOctave(reduced, 2, b, scaleSpace); + I downscaled = downscaling2(original); + buildOctave(downscaled, 2, b, scaleSpace); for (unsigned i = 3; i <= n; ++i) { // i-th octave - reduced = downscaling2(reduced); - buildOctave(reduced, i, b, scaleSpace); + downscaled = downscaling2(downscaled); + buildOctave(downscaled, i, b, scaleSpace); } } else @@ -279,9 +437,6 @@ void buildExtrema(C extrema, std::vector< std::vector >& dogSpace) { extrema = data::convert(value::rgb8(), original); - //value::int_u8 min = 255; - //value::int_u8 max = 0; - //value::int_u8 center = 0; const unsigned blur_level = dogSpace.at(0).size(); @@ -316,7 +471,8 @@ void buildExtrema(C extrema, if (center < min) { - mln_psite(I) pOriginal(p.row() * pow(2, j), p.col() * pow(2, j)); + mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), + p.col() * pow(2, (j-1))); extrema(pOriginal) = literal::red; } } @@ -326,7 +482,8 @@ void buildExtrema(C extrema, if (center > max) { - mln_psite(I) pOriginal(p.row() * pow(2, j), p.col() * pow(2, j)); + mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), + p.col() * pow(2, (j-1))); extrema(pOriginal) = literal::red; } } -- 1.7.2.5

11 years, 7 months

olena: branch sandbox/anthony updated: olena-2.0-592-ge6c9b24

by git＠lrde.epita.fr

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Olena, a generic and efficient image processing platform". The branch sandbox/anthony has been updated via e6c9b2483d5651c061cad24ace0a87a7a8ce8a4d (commit) from a674962cd9a863e37b7165bd4ef5a1d8fddde6d1 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- e6c9b24 Add Keypoint class and start extremum elimination ----------------------------------------------------------------------- Summary of changes: milena/sandbox/anthony/Makefile | 2 +- milena/sandbox/anthony/src/keypoint.cc | 18 + milena/sandbox/anthony/src/keypoint.hh | 27 ++ milena/sandbox/anthony/src/scale_space.cc | 517 ----------------------------- 4 files changed, 46 insertions(+), 518 deletions(-) create mode 100644 milena/sandbox/anthony/src/keypoint.cc create mode 100644 milena/sandbox/anthony/src/keypoint.hh delete mode 100644 milena/sandbox/anthony/src/scale_space.cc hooks/post-receive -- Olena, a generic and efficient image processing platform

11 years, 7 months

olena: olena-2.0-592-ge6c9b24 Add Keypoint class and start extremum elimination

by Anthony Seure

--- milena/sandbox/anthony/Makefile | 2 +- milena/sandbox/anthony/src/keypoint.cc | 18 + milena/sandbox/anthony/src/keypoint.hh | 27 ++ milena/sandbox/anthony/src/scale_space.cc | 517 ----------------------------- 4 files changed, 46 insertions(+), 518 deletions(-) create mode 100644 milena/sandbox/anthony/src/keypoint.cc create mode 100644 milena/sandbox/anthony/src/keypoint.hh delete mode 100644 milena/sandbox/anthony/src/scale_space.cc diff --git a/milena/sandbox/anthony/Makefile b/milena/sandbox/anthony/Makefile index e43db7f..ff62f9e 100644 --- a/milena/sandbox/anthony/Makefile +++ b/milena/sandbox/anthony/Makefile @@ -4,7 +4,7 @@ CFLAGS=-Wall -Werror CLIBS=-I../../ CLEAN=*.o output/* log -SRC=src/scale_space.cc +SRC=src/main.cc src/keypoint.cc OUTPUT=a.out all: scale diff --git a/milena/sandbox/anthony/src/keypoint.cc b/milena/sandbox/anthony/src/keypoint.cc new file mode 100644 index 0000000..bf0a5f5 --- /dev/null +++ b/milena/sandbox/anthony/src/keypoint.cc @@ -0,0 +1,18 @@ +#include "keypoint.hh" + +// Constructor +Keypoint::Keypoint(unsigned i, unsigned j, + unsigned scale, unsigned size, bool maximum) +{ + this->i = i; + this->j = j; + this->scale = scale; + this->size = size; + this->maximum = maximum; +} + +// Getters +unsigned Keypoint::getI() { return i; } +unsigned Keypoint::getJ() { return j; } +unsigned Keypoint::getScale() { return scale; } +unsigned Keypoint::getSize() { return size; } diff --git a/milena/sandbox/anthony/src/keypoint.hh b/milena/sandbox/anthony/src/keypoint.hh new file mode 100644 index 0000000..798a980 --- /dev/null +++ b/milena/sandbox/anthony/src/keypoint.hh @@ -0,0 +1,27 @@ +#ifndef KEYPOINT_HH +# define KEYPOINT_HH + +# include <ostream> + +class Keypoint +{ + public: + // Constructor + Keypoint(unsigned i, unsigned j, + unsigned scale, unsigned size, bool maximum); + + // Getters + unsigned getI(); + unsigned getJ(); + unsigned getScale(); + unsigned getSize(); + + private: + unsigned i; + unsigned j; + unsigned scale; + unsigned size; + bool maximum; +}; + +#endif /* ! KEYPOINT_HH */ diff --git a/milena/sandbox/anthony/src/scale_space.cc b/milena/sandbox/anthony/src/scale_space.cc deleted file mode 100644 index 87853ef..0000000 --- a/milena/sandbox/anthony/src/scale_space.cc +++ /dev/null @@ -1,517 +0,0 @@ -#include <mln/core/image/image2d.hh> -#include <mln/data/all.hh> -#include <mln/io/pgm/all.hh> -#include <mln/io/ppm/save.hh> -#include <mln/core/alias/neighb2d.hh> -#include <mln/literal/all.hh> -#include <mln/value/int_s8.hh> - -#include <cmath> - -using namespace mln; - -// Set the gaussian kernel -float *gaussian_kernel() -{ - float variance = sqrt(2.0); - unsigned index = 0; - float *kernel = new float[49]; - static const float pi = 4.0 * atan(1.0); - float div = (2.0 * pi * variance); - - for (int i = -3; i < 4; ++i) - { - for (int j = -3; j < 4; ++j) - { - float e = exp(- (i*i + j*j) / (2.0 * variance) ); - kernel[index++] = e / div; - } - } - - return kernel; -} - -// Apply the convolution of the image by the kernel -template<typename I> -void convolve(const I& original, I& filtered, float *kernel) -{ - mln_piter(I) p(filtered.domain()); - window2d win; - - for (int i = -3; i < 4; ++i) - for (int j = -3; j < 4; ++j) - win.insert(i, j); - - // Iterate through all image sites - for_all(p) - { - // Create the window around the site - mln_qiter(window2d) q(win, p); - float sum = 0; - int index = 0; - - // Iterate through all window image sites - for_all(q) - { - if (filtered.has(q)) - sum += original(q) * kernel[index++]; - else - sum += 127 * kernel[index++]; - } - - filtered(p) = static_cast<int>(sum); - } -} - -// Blur the image thanks to a convolution matrix -template<typename I> -I blur(const I& original) -{ - I filtered; - float *kernel = gaussian_kernel(); - - initialize(filtered, original); - convolve(original, filtered, kernel); - - return filtered; -} - -// Downscale by 2 the image resolution -template<typename I> -I downscaling2(const I& original) -{ - mln_piter(I) p(original.domain()); - window2d win; - int index = 0; - - // Initialize the rescaled image - box2d size(original.nrows() / 2, original.ncols() / 2); - I reduced(size); - - // Set the 2x2 window matrix - for (int i = 0; i < 2; ++i) - for (int j = 0; j < 2; ++j) - win.insert(i, j); - - // Iterate through all image sites - for_all(p) - { - // Get 1/4 of total pixels - if (index % 2 == 0) - { - int i = (index % original.ncols()) / 2; - int j = (index / original.ncols()) / 2; - int count = 0; - int sum = 0; - mln_qiter(window2d) q(win, p); - - // Iterate through all window image sites - for_all(q) - { - if (original.has(q)) - { - sum += original(q); - ++count; - } - } - - if (reduced.has(point2d(j, i))) - opt::at(reduced, j, i) = sum / count; - } - - ++index; - } - - return reduced; -} - -float *upscalingTL_kernel() -{ - const static float one = 1.0 / 8.0; - const static float two = 2.0 / 8.0; - const static float three = 2.0 / 8.0; - const static float four = 3.0 / 8.0; - - float *kernel = new float[4]; - - kernel[0] = one; - kernel[1] = two; - kernel[2] = three; - kernel[3] = four; - - return kernel; -} - -float *upscalingTR_kernel() -{ - const static float one = 2.0 / 8.0; - const static float two = 1.0 / 8.0; - const static float three = 3.0 / 8.0; - const static float four = 2.0 / 8.0; - - float *kernel = new float[4]; - - kernel[0] = one; - kernel[1] = two; - kernel[2] = three; - kernel[3] = four; - - return kernel; -} - -float *upscalingBL_kernel() -{ - const static float one = 2.0 / 8.0; - const static float two = 3.0 / 8.0; - const static float three = 1.0 / 8.0; - const static float four = 2.0 / 8.0; - - float *kernel = new float[4]; - - kernel[0] = one; - kernel[1] = two; - kernel[2] = three; - kernel[3] = four; - - return kernel; -} - -float *upscalingBR_kernel() -{ - const static float one = 3.0 / 8.0; - const static float two = 2.0 / 8.0; - const static float three = 2.0 / 8.0; - const static float four = 1.0 / 8.0; - - float *kernel = new float[4]; - - kernel[0] = one; - kernel[1] = two; - kernel[2] = three; - kernel[3] = four; - - return kernel; -} - -template<typename I> -unsigned upscalePixel(const I& original, int i, int j, int type) -{ - float *kernel; - window2d win; - mln_psite(I) p(i, j); - float value = 0; - unsigned index = 0; - int iStart = 0; - int jStart = 0; - - if (type == 0) - { - kernel = upscalingTL_kernel(); - iStart = -1; - jStart = -1; - } - else if (type == 1) - { - kernel = upscalingTR_kernel(); - iStart = 0; - jStart = -1; - } - else if (type == 2) - { - kernel = upscalingBL_kernel(); - iStart = -1; - jStart = 0; - } - else - { - kernel = upscalingBR_kernel(); - iStart = 0; - jStart = 0; - } - - for (int ii = iStart; ii < iStart + 2; ++ii) - for (int jj = jStart; jj < jStart + 2; ++jj) - win.insert(ii, jj); - - mln_qiter(window2d) q(win, p); - - for_all(q) - { - if (original.has(q)) - { - value += original(q) * kernel[index]; - } - - ++index; - } - - return (static_cast<int>(value)); -} - -// Upscale by 2 the image resolution -template<typename I> -I upscaling2(const I& original) -{ - box2d size(original.nrows() * 2, original.ncols() * 2); - I upscaled(size); - - mln_piter(I) p(upscaled.domain()); - int index = 0; - - for_all(p) - { - int i = p.col(); - int j = p.row(); - - if (i % 2 == 0 && j % 2 == 0) // Top left - opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 0); - else if (i % 2 == 0) // Bottom left - opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 2); - else if (j % 2 == 0) // Top right - opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 1); - else // Bottom right - opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 3); - - ++index; - } - - - return upscaled; -} - -// Build the n-th octave on b blur levels -template<typename I> -void buildOctave(const I& original, - unsigned n, - unsigned b, - std::vector< std::vector >& scaleSpace) -{ - std::vector octave; - std::stringstream name; - I blured; - initialize(blured, original); - - name << "output/SS-o" << n << "-0.pgm"; - io::pgm::save(original, name.str()); - - octave.push_back(original); - blured = duplicate(original); - - for(unsigned i = 1; i <= b; i *= 2) - { - blured = blur(blured); - octave.push_back(blured); - - name.str(""); - name << "output/SS-o" << n << "-" < -void buildScaleSpace(std::vector< std::vector >& scaleSpace, - const I& original, - unsigned n, - unsigned b) -{ - if (n > 2) - { - // Upscaled octave - I upscaled = upscaling2(original); - buildOctave(upscaled, 0, b, scaleSpace); - - // 1st octave - buildOctave(original, 1, b, scaleSpace); - - // 2nd octave - I downscaled = downscaling2(original); - buildOctave(downscaled, 2, b, scaleSpace); - - for (unsigned i = 3; i <= n; ++i) - { - // i-th octave - downscaled = downscaling2(downscaled); - buildOctave(downscaled, i, b, scaleSpace); - } - } - else - { - std::cerr << "ERROR: buildScaleSpace: Wrong level number (" << n << ")" - << std::endl; - } -} - -// Build the DoG pyramid of the scale space -template<typename I> -void buildDifferenceOfGaussianSpace(std::vector< std::vector >& scaleSpace, - std::vector< std::vector >& dogSpace) -{ - for (unsigned i = 0; i < scaleSpace.size(); ++i) - { - std::vector octave = scaleSpace.at(i); - std::vector dogOctave; - - for (unsigned j = 0; j < octave.size() - 1; ++j) - { - std::stringstream name; - I level1 = octave.at(j); - I level2 = octave.at(j + 1); - I dog; - - initialize(dog, level1); - - mln_piter(I) p(level1.domain()); - - for_all(p) - { - int diff = ((int) level1(p)) - ((int) level2(p)); - dog(p) = (diff >= 0) ? diff : 0; - } - - dogOctave.push_back(dog); - name << "output/DoG_o" < -void find_extremum(T& min, T& max, const I& current, N n) -{ - for_all(n) - { - if (current(n) > max) - max = current(n); - - if (current(n) < min) - min = current(n); - } -} - -// Find the minimum value in the upper and lower layers around p -template<typename T, typename I, typename P> -void find_min(T& min, const I& upper, const I& lower, const P& pUpper, const P& pLower) -{ - mln_niter(neighb2d) nUpper(c8(), pUpper); - mln_niter(neighb2d) nLower(c8(), pLower); - - // Upper processing - for_all(nUpper) - if (upper(nUpper) < min) - min = upper(nUpper); - - // Lower processing - for_all(nLower) - if (lower(nLower) < min) - min = lower(nLower); -} - -// Find the maximum value in the upper and lower layers around p -template<typename T, typename I, typename P> -void find_max(T& max, const I& upper, const I& lower, const P& pUpper, const P& pLower) -{ - mln_niter(neighb2d) nUpper(c8(), pUpper); - mln_niter(neighb2d) nLower(c8(), pLower); - - // Upper processing - for_all(nUpper) - if (upper(nUpper) > max) - max = upper(nUpper); - - // Lower processing - for_all(nLower) - if (lower(nLower) > max) - max = lower(nLower); -} - -// Build the extrema image -template<typename I, typename C> -void buildExtrema(C extrema, - I original, - std::vector< std::vector >& dogSpace) -{ - extrema = data::convert(value::rgb8(), original); - - const unsigned blur_level = dogSpace.at(0).size(); - - //unsigned i = 0; - for (unsigned i = 0; i < blur_level; ++i) - { - for (unsigned j = 1; j < dogSpace.size() - 1; ++j) - { - I current = dogSpace.at(j).at(i); - I upper = dogSpace.at(j+1).at(i); - I lower = dogSpace.at(j-1).at(i); - - mln_piter(I) p(current.domain()); - - for_all(p) - { - value::int_u8 min = 255; - value::int_u8 max = 0; - value::int_u8 center = 0; - - mln_niter(neighb2d) n(c8(), p); - center = current(p); - - mln_psite(I) pUpper(p.row() / 2, p.col() / 2); - mln_psite(I) pLower(p.row() * 2, p.col() * 2); - - find_extremum(min, max, current, n); - - if (center <= min) - { - find_min(min, upper, lower, pUpper, pLower); - - if (center < min) - { - mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), - p.col() * pow(2, (j-1))); - extrema(pOriginal) = literal::red; - } - } - else if (center >= max) - { - find_max(max, upper, lower, pUpper, pLower); - - if (center > max) - { - mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), - p.col() * pow(2, (j-1))); - extrema(pOriginal) = literal::red; - } - } - } - } - } - - io::ppm::save(extrema, "output/extrema.ppm"); -} - -// Main entry point -int main(int argc, char** argv) -{ - typedef image2d<value::int_u8> I; - typedef image2d<value::rgb8> C; - - const unsigned blur_level = 5; - const unsigned octave_level = 4; - std::vector< std::vector > scaleSpace; - std::vector< std::vector > dogSpace; - I original; - C extrema; - - io::pgm::load(original, "images/lena.pgm"); - - buildScaleSpace(scaleSpace, original, octave_level, blur_level); - buildDifferenceOfGaussianSpace(scaleSpace, dogSpace); - buildExtrema(extrema, original, dogSpace); - - return 0; -} -- 1.7.2.5

11 years, 7 months

olena: branch sandbox/anthony updated: olena-2.0-593-g609a6a4

by git＠lrde.epita.fr

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Olena, a generic and efficient image processing platform". The branch sandbox/anthony has been updated via 609a6a45b6b5d8725a1f7da78aa50604c841be44 (commit) from e6c9b2483d5651c061cad24ace0a87a7a8ce8a4d (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- 609a6a4 Edge response elimination done ----------------------------------------------------------------------- Summary of changes: milena/sandbox/anthony/src/main.cc | 583 ++++++++++++++++++++++++++++++++++++ 1 files changed, 583 insertions(+), 0 deletions(-) create mode 100644 milena/sandbox/anthony/src/main.cc hooks/post-receive -- Olena, a generic and efficient image processing platform

11 years, 7 months

olena: olena-2.0-593-g609a6a4 Edge response elimination done

by Anthony Seure

--- milena/sandbox/anthony/src/main.cc | 583 ++++++++++++++++++++++++++++++++++++ 1 files changed, 583 insertions(+), 0 deletions(-) create mode 100644 milena/sandbox/anthony/src/main.cc diff --git a/milena/sandbox/anthony/src/main.cc b/milena/sandbox/anthony/src/main.cc new file mode 100644 index 0000000..eea1c86 --- /dev/null +++ b/milena/sandbox/anthony/src/main.cc @@ -0,0 +1,583 @@ +#include <mln/core/image/image2d.hh> +#include <mln/data/all.hh> +#include <mln/io/pgm/all.hh> +#include <mln/io/ppm/save.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/literal/all.hh> +#include <mln/value/int_s8.hh> + +#include <cmath> + +#include "keypoint.hh" + +using namespace mln; + +// Set the gaussian kernel +float *gaussian_kernel() +{ + float variance = sqrt(2.0); + unsigned index = 0; + float *kernel = new float[49]; + static const float pi = 4.0 * atan(1.0); + float div = (2.0 * pi * variance); + + for (int i = -3; i < 4; ++i) + { + for (int j = -3; j < 4; ++j) + { + float e = exp(- (i*i + j*j) / (2.0 * variance) ); + kernel[index++] = e / div; + } + } + + return kernel; +} + +// Apply the convolution of the image by the kernel +template<typename I> +void convolve(const I& original, I& filtered, float *kernel) +{ + mln_piter(I) p(filtered.domain()); + window2d win; + + for (int i = -3; i < 4; ++i) + for (int j = -3; j < 4; ++j) + win.insert(i, j); + + // Iterate through all image sites + for_all(p) + { + // Create the window around the site + mln_qiter(window2d) q(win, p); + float sum = 0; + int index = 0; + + // Iterate through all window image sites + for_all(q) + { + if (filtered.has(q)) + sum += original(q) * kernel[index++]; + else + sum += 127 * kernel[index++]; + } + + filtered(p) = static_cast<int>(sum); + } +} + +// Blur the image thanks to a convolution matrix +template<typename I> +I blur(const I& original) +{ + I filtered; + float *kernel = gaussian_kernel(); + + initialize(filtered, original); + convolve(original, filtered, kernel); + + return filtered; +} + +// Downscale by 2 the image resolution +template<typename I> +I downscaling2(const I& original) +{ + mln_piter(I) p(original.domain()); + window2d win; + int index = 0; + + // Initialize the rescaled image + box2d size(original.nrows() / 2, original.ncols() / 2); + I reduced(size); + + // Set the 2x2 window matrix + for (int i = 0; i < 2; ++i) + for (int j = 0; j < 2; ++j) + win.insert(i, j); + + // Iterate through all image sites + for_all(p) + { + // Get 1/4 of total pixels + if (index % 2 == 0) + { + int i = (index % original.ncols()) / 2; + int j = (index / original.ncols()) / 2; + int count = 0; + int sum = 0; + mln_qiter(window2d) q(win, p); + + // Iterate through all window image sites + for_all(q) + { + if (original.has(q)) + { + sum += original(q); + ++count; + } + } + + if (reduced.has(point2d(j, i))) + opt::at(reduced, j, i) = sum / count; + } + + ++index; + } + + return reduced; +} + +float *upscalingTL_kernel() +{ + const static float one = 1.0 / 8.0; + const static float two = 2.0 / 8.0; + const static float three = 2.0 / 8.0; + const static float four = 3.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingTR_kernel() +{ + const static float one = 2.0 / 8.0; + const static float two = 1.0 / 8.0; + const static float three = 3.0 / 8.0; + const static float four = 2.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingBL_kernel() +{ + const static float one = 2.0 / 8.0; + const static float two = 3.0 / 8.0; + const static float three = 1.0 / 8.0; + const static float four = 2.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +float *upscalingBR_kernel() +{ + const static float one = 3.0 / 8.0; + const static float two = 2.0 / 8.0; + const static float three = 2.0 / 8.0; + const static float four = 1.0 / 8.0; + + float *kernel = new float[4]; + + kernel[0] = one; + kernel[1] = two; + kernel[2] = three; + kernel[3] = four; + + return kernel; +} + +template<typename I> +unsigned upscalePixel(const I& original, int i, int j, int type) +{ + float *kernel; + window2d win; + mln_psite(I) p(i, j); + float value = 0; + unsigned index = 0; + int iStart = 0; + int jStart = 0; + + if (type == 0) + { + kernel = upscalingTL_kernel(); + iStart = -1; + jStart = -1; + } + else if (type == 1) + { + kernel = upscalingTR_kernel(); + iStart = 0; + jStart = -1; + } + else if (type == 2) + { + kernel = upscalingBL_kernel(); + iStart = -1; + jStart = 0; + } + else + { + kernel = upscalingBR_kernel(); + iStart = 0; + jStart = 0; + } + + for (int ii = iStart; ii < iStart + 2; ++ii) + for (int jj = jStart; jj < jStart + 2; ++jj) + win.insert(ii, jj); + + mln_qiter(window2d) q(win, p); + + for_all(q) + { + if (original.has(q)) + { + value += original(q) * kernel[index]; + } + + ++index; + } + + return (static_cast<int>(value)); +} + +// Upscale by 2 the image resolution +template<typename I> +I upscaling2(const I& original) +{ + box2d size(original.nrows() * 2, original.ncols() * 2); + I upscaled(size); + + mln_piter(I) p(upscaled.domain()); + int index = 0; + + for_all(p) + { + int i = p.col(); + int j = p.row(); + + if (i % 2 == 0 && j % 2 == 0) // Top left + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 0); + else if (i % 2 == 0) // Bottom left + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 2); + else if (j % 2 == 0) // Top right + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 1); + else // Bottom right + opt::at(upscaled, i, j) = upscalePixel(original, i / 2, j / 2, 3); + + ++index; + } + + + return upscaled; +} + +// Build the n-th octave on b blur levels +template<typename I> +void buildOctave(const I& original, + unsigned n, + unsigned b, + std::vector< std::vector >& scaleSpace) +{ + std::vector octave; + std::stringstream name; + I blured; + initialize(blured, original); + + name << "output/SS-o" << n << "-0.pgm"; + io::pgm::save(original, name.str()); + + octave.push_back(original); + blured = duplicate(original); + + for(unsigned i = 1; i <= b; i *= 2) + { + blured = blur(blured); + octave.push_back(blured); + + name.str(""); + name << "output/SS-o" << n << "-" < +void buildScaleSpace(std::vector< std::vector >& scaleSpace, + const I& original, + unsigned n, + unsigned b) +{ + if (n > 2) + { + // Upscaled octave + I upscaled = upscaling2(original); + buildOctave(upscaled, 0, b, scaleSpace); + + // 1st octave + buildOctave(original, 1, b, scaleSpace); + + // 2nd octave + I downscaled = downscaling2(original); + buildOctave(downscaled, 2, b, scaleSpace); + + for (unsigned i = 3; i <= n; ++i) + { + // i-th octave + downscaled = downscaling2(downscaled); + buildOctave(downscaled, i, b, scaleSpace); + } + } + else + { + std::cerr << "ERROR: buildScaleSpace: Wrong level number (" << n << ")" + << std::endl; + } +} + +// Build the DoG pyramid of the scale space +template<typename I> +void buildDifferenceOfGaussianSpace(std::vector< std::vector >& scaleSpace, + std::vector< std::vector >& dogSpace) +{ + for (unsigned i = 0; i < scaleSpace.size(); ++i) + { + std::vector octave = scaleSpace.at(i); + std::vector dogOctave; + + for (unsigned j = 0; j < octave.size() - 1; ++j) + { + std::stringstream name; + I level1 = octave.at(j); + I level2 = octave.at(j + 1); + I dog; + + initialize(dog, level1); + + mln_piter(I) p(level1.domain()); + + for_all(p) + { + int diff = ((int) level1(p)) - ((int) level2(p)); + dog(p) = (diff >= 0) ? diff : 0; + } + + dogOctave.push_back(dog); + name << "output/DoG_o" < +void find_extremum(T& min, T& max, const I& current, N n) +{ + for_all(n) + { + if (current(n) > max) + max = current(n); + + if (current(n) < min) + min = current(n); + } +} + +// Find the minimum value in the upper and lower layers around p +template<typename T, typename I, typename P> +void find_min(T& min, const I& upper, const I& lower, const P& pUpper, const P& pLower) +{ + mln_niter(neighb2d) nUpper(c8(), pUpper); + mln_niter(neighb2d) nLower(c8(), pLower); + + // Upper processing + for_all(nUpper) + if (upper(nUpper) < min) + min = upper(nUpper); + + // Lower processing + for_all(nLower) + if (lower(nLower) < min) + min = lower(nLower); +} + +// Find the maximum value in the upper and lower layers around p +template<typename T, typename I, typename P> +void find_max(T& max, const I& upper, const I& lower, const P& pUpper, const P& pLower) +{ + mln_niter(neighb2d) nUpper(c8(), pUpper); + mln_niter(neighb2d) nLower(c8(), pLower); + + // Upper processing + for_all(nUpper) + if (upper(nUpper) > max) + max = upper(nUpper); + + // Lower processing + for_all(nLower) + if (lower(nLower) > max) + max = lower(nLower); +} + +template<typename T, typename I, typename P> +bool hasEdgeResponse(const I& dog, const P& p, const T& center) +{ + const static float bound_ratio = 12.1; + + /* Set the neighbors: + * n5 n1 n6 + * n2 p n3 + * n7 n4 n8 + */ + float n1 = dog(mln_psite(I)(p.row() - 1, p.col())); + float n2 = dog(mln_psite(I)(p.row(), p.col() - 1)); + float n3 = dog(mln_psite(I)(p.row(), p.col() + 1)); + float n4 = dog(mln_psite(I)(p.row() + 1, p.col())); + + float n5 = dog(mln_psite(I)(p.row() - 1, p.col() - 1)); + float n6 = dog(mln_psite(I)(p.row() - 1, p.col() + 1)); + float n7 = dog(mln_psite(I)(p.row() + 1, p.col() - 1)); + float n8 = dog(mln_psite(I)(p.row() + 1, p.col() + 1)); + + // Set Hessian matrix and find the ratio + + float dxx = n3 - 2.0 * center + n2; + float dyy = n4 - 2.0 * center + n1; + + float dxy = (n8 - n6 - n7 + n5) / 4.0; + float trace = dxx + dyy; + float determinant = dxx * dyy - dxy * dxy; + + if (determinant <= 0) + return true; + + float ratio = (trace * trace) / determinant; + + return (ratio >= bound_ratio); +} + +// Build the extrema image +template<typename I, typename C> +void buildExtrema(C extrema, + I original, + std::vector< std::vector >& dogSpace, + std::vector<Keypoint>& keypoints) +{ + const bool black = false; + + if (black) + initialize(extrema, original); + else + extrema = data::convert(value::rgb8(), original); + + // Number of scales (gaussian meaning) + unsigned scales = dogSpace.at(0).size(); + + // Iterates through all scales + for (unsigned i = 0; i < scales; ++i) + { + // Iterates through all resolutions + for (unsigned j = 1; j < dogSpace.size() - 1; ++j) + { + I current = dogSpace.at(j).at(i); + I upper = dogSpace.at(j+1).at(i); + I lower = dogSpace.at(j-1).at(i); + + mln_piter(I) p(current.domain()); + + for_all(p) + { + value::int_u8 min = 255; + value::int_u8 max = 0; + value::int_u8 center = 0; + + mln_niter(neighb2d) n(c8(), p); + center = current(p); + + mln_psite(I) pUpper(p.row() / 2, p.col() / 2); + mln_psite(I) pLower(p.row() * 2, p.col() * 2); + + // Find the min and max in the current neighborhood (c8) + find_extremum(min, max, current, n); + + if (center <= min) + { + // Find the min in other levels of the pyramid + find_min(min, upper, lower, pUpper, pLower); + + if (center < min && !hasEdgeResponse(current, p, center)) + { + mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), + p.col() * pow(2, (j-1))); + extrema(pOriginal) = literal::green; + keypoints.push_back(Keypoint(p.row(), p.col(), j, i, false)); + } + } + else if (center >= max) + { + // Find the max in other levels of the pyramid + find_max(max, upper, lower, pUpper, pLower); + + if (center > max && !hasEdgeResponse(current, p, center)) + { + mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), + p.col() * pow(2, (j-1))); + extrema(pOriginal) = literal::red; + keypoints.push_back(Keypoint(p.row(), p.col(), j, i, true)); + } + } + } + } + } + + io::ppm::save(extrema, "output/extrema.ppm"); +} + +template<typename I> +void discardEdgeResponses(std::vector< std::vector >& dogSpace, + std::vector<Keypoint>& keypoints) +{ + // FIXME Move work from buildExtrema here +} + +// Main entry point +int main(int argc, char** argv) +{ + typedef image2d<value::int_u8> I; + typedef image2d<value::rgb8> C; + + const unsigned blur_level = 5; + const unsigned octave_level = 3; + std::vector< std::vector > scaleSpace; + std::vector< std::vector > dogSpace; + std::vector<Keypoint> keypoints; + I original; + C extrema; + + io::pgm::load(original, "images/lena.pgm"); + + buildScaleSpace(scaleSpace, original, octave_level, blur_level); + buildDifferenceOfGaussianSpace(scaleSpace, dogSpace); + buildExtrema(extrema, original, dogSpace, keypoints); + // TODO Interpolation of nearby data for accurate position + // TODO Discard low-contrast keypoints + //discardEdgeResponses(dogSpace, keypoints); + + std::cout << keypoints.size() << std::endl; + + + return 0; +} -- 1.7.2.5

11 years, 7 months

olena: branch sandbox/anthony updated: olena-2.0-595-gc54e2d1

by git＠lrde.epita.fr

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Olena, a generic and efficient image processing platform". The branch sandbox/anthony has been updated via c54e2d15a72f95f744770ff7d91f2a48ee1cfa02 (commit) from 3748427f0634fa0a7e531042cba2bba85a93447a (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- c54e2d1 Improve extremum ----------------------------------------------------------------------- Summary of changes: milena/sandbox/anthony/Makefile | 2 +- milena/sandbox/anthony/src/keypoint.cc | 39 +++++- milena/sandbox/anthony/src/keypoint.hh | 29 +++-- milena/sandbox/anthony/src/main.cc | 226 ++++++++++++++++++++++++------- milena/sandbox/anthony/src/matrix.cc | 30 ++++- milena/sandbox/anthony/src/matrix.hh | 5 +- 6 files changed, 259 insertions(+), 72 deletions(-) hooks/post-receive -- Olena, a generic and efficient image processing platform

11 years, 7 months

olena: olena-2.0-595-gc54e2d1 Improve extremum

by Anthony Seure

--- milena/sandbox/anthony/Makefile | 2 +- milena/sandbox/anthony/src/keypoint.cc | 39 +++++- milena/sandbox/anthony/src/keypoint.hh | 29 +++-- milena/sandbox/anthony/src/main.cc | 226 ++++++++++++++++++++++++------- milena/sandbox/anthony/src/matrix.cc | 30 ++++- milena/sandbox/anthony/src/matrix.hh | 5 +- 6 files changed, 259 insertions(+), 72 deletions(-) diff --git a/milena/sandbox/anthony/Makefile b/milena/sandbox/anthony/Makefile index 83ee52b..2953013 100644 --- a/milena/sandbox/anthony/Makefile +++ b/milena/sandbox/anthony/Makefile @@ -4,7 +4,7 @@ CFLAGS=-Wall -Werror CLIBS=-I../../ CLEAN=*.o output/* log -SRC=src/matrix.cc src/keypoint.cc src/main.cc +SRC=src/main.cc src/matrix.cc src/keypoint.cc OUTPUT=a.out all: scale diff --git a/milena/sandbox/anthony/src/keypoint.cc b/milena/sandbox/anthony/src/keypoint.cc index bf0a5f5..937e78d 100644 --- a/milena/sandbox/anthony/src/keypoint.cc +++ b/milena/sandbox/anthony/src/keypoint.cc @@ -1,8 +1,8 @@ #include "keypoint.hh" // Constructor -Keypoint::Keypoint(unsigned i, unsigned j, - unsigned scale, unsigned size, bool maximum) +Keypoint::Keypoint(int i, int j, + int scale, int size, bool maximum) { this->i = i; this->j = j; @@ -11,8 +11,35 @@ Keypoint::Keypoint(unsigned i, unsigned j, this->maximum = maximum; } +bool Keypoint::add(Matrix& offset, Keypoint& old) +{ + if (offset.get(0, 0) >= 1 || offset.get(0, 0) <= -1 + || offset.get(1, 0) >= 1 || offset.get(1, 0) <= -1) + { + i += offset.get(0, 0); + j += offset.get(1, 0); + scale += offset.get(2, 0); + + return (i != old.getI() && j != old.getJ()); + } + else + return false; +} + +//mln::point2d Keypoint::getPoint() +//{ + //mln::point2d p(i, j); + + //return p; +//} + // Getters -unsigned Keypoint::getI() { return i; } -unsigned Keypoint::getJ() { return j; } -unsigned Keypoint::getScale() { return scale; } -unsigned Keypoint::getSize() { return size; } +int Keypoint::getI() { return i; } +int Keypoint::getJ() { return j; } +int Keypoint::getScale() { return scale; } +int Keypoint::getSize() { return size; } + +// Setters +void Keypoint::setI(int offsetI) { i = offsetI; } +void Keypoint::setJ(int offsetJ) { j = offsetJ; } +void Keypoint::setScale(int offsetScale) { scale = offsetScale; } diff --git a/milena/sandbox/anthony/src/keypoint.hh b/milena/sandbox/anthony/src/keypoint.hh index 798a980..af24a4c 100644 --- a/milena/sandbox/anthony/src/keypoint.hh +++ b/milena/sandbox/anthony/src/keypoint.hh @@ -1,26 +1,35 @@ #ifndef KEYPOINT_HH # define KEYPOINT_HH +//# include <mln/core/alias/point2d.hh> # include <ostream> +# include "matrix.hh" class Keypoint { public: // Constructor - Keypoint(unsigned i, unsigned j, - unsigned scale, unsigned size, bool maximum); + Keypoint(int i, int j, + int scale, int size, bool maximum); + + bool add(Matrix& k, Keypoint& old); + //mln::point2d getPoint(); // Getters - unsigned getI(); - unsigned getJ(); - unsigned getScale(); - unsigned getSize(); + int getI(); + int getJ(); + int getScale(); + int getSize(); + + void setI(int offsetI); + void setJ(int offsetJ); + void setScale(int offsetScale); private: - unsigned i; - unsigned j; - unsigned scale; - unsigned size; + int i; + int j; + int scale; + int size; bool maximum; }; diff --git a/milena/sandbox/anthony/src/main.cc b/milena/sandbox/anthony/src/main.cc index 9cc956b..fae3c64 100644 --- a/milena/sandbox/anthony/src/main.cc +++ b/milena/sandbox/anthony/src/main.cc @@ -472,18 +472,11 @@ bool hasEdgeResponse(const I& dog, const P& p, const T& center) // Build the extrema image template<typename I, typename C> -void buildExtrema(C extrema, - I original, +void buildExtrema(C& extrema, + const I& original, std::vector< std::vector >& dogSpace, std::vector<Keypoint>& keypoints) { - const bool black = false; - - if (black) - initialize(extrema, original); - else - extrema = data::convert(value::rgb8(), original); - // Number of scales (gaussian meaning) unsigned scales = dogSpace.at(0).size(); @@ -523,7 +516,7 @@ void buildExtrema(C extrema, { mln_psite(I) pOriginal(p.row() * pow(2, (j-1)), p.col() * pow(2, (j-1))); - extrema(pOriginal) = literal::green; + extrema(pOriginal) = literal::red; keypoints.push_back(Keypoint(p.row(), p.col(), i, j, false)); } } @@ -543,75 +536,191 @@ void buildExtrema(C extrema, } } } - - io::ppm::save(extrema, "output/extrema.ppm"); } -/*****************************************************************************/ -/*****************************************************************************/ -/*****************************************************************************/ - +// Compute the first order matrix for interpolation template<typename I> -Matrix *computeFirstOrderMatrix(const std::vector< std::vector >& dogSpace, - const Keypoint& k) +void computeFirstOrderMatrix(const std::vector< std::vector >& dogSpace, + Keypoint& k, + Matrix& matrix) { - Matrix *matrix = new Matrix(3, 1); + matrix.initialize(); + + std::vector current = dogSpace.at(1); + std::vector upper = dogSpace.at(2); + std::vector lower = dogSpace.at(0); + + /* Point naming convention + * n1 + * n2 c n3 + * n4 + */ + point2d c(k.getI(), k.getJ()); + + point2d n1(k.getI(), k.getJ() - 1); + point2d n2(k.getI() - 1, k.getJ()); + point2d n3(k.getI() + 1, k.getJ()); + point2d n4(k.getI(), k.getJ() + 1); + + point2d cupper(c.row() / 2, c.col() / 2); + point2d clower(c.row() * 2, c.col() * 2); + + // Compute partial x + matrix.set(0, 0, (current.at(0)(n3) - current.at(0)(n2)) / 2.0); - return matrix; + // Compute partial y + matrix.set(1, 0, (current.at(0)(n3) - current.at(0)(n2)) / 2.0); + + // Compute partial scale + matrix.set(2, 0, (lower.at(0)(clower) - upper.at(0)(cupper)) / 2.0); } +// Compute the inversed second order matrix for interpolation template<typename I> -Matrix *computeSecondOrderMatrix(const std::vector< std::vector >& dogSpace, - const Keypoint& k) +void computeSecondOrderMatrix(const std::vector< std::vector >& dogSpace, + Keypoint& k, + Matrix& matrix) { - Matrix *matrix = new Matrix(3, 3); + matrix.initialize(); - return matrix; -} + const static std::vector current = dogSpace.at(1); + const static I upper = dogSpace.at(2).at(0); + const static I lower = dogSpace.at(0).at(0); + const static I main = current.at(0); -bool isBetter(Matrix offset) -{ - return (offset.get(0, 0) > 0.5 - || offset.get(0, 1) > 0.5 - || offset.get(0, 2) > 0.5); -} + /* Point naming convention + * n5 n1 n6 + * n2 c n3 + * n7 n4 n8 + */ + point2d c(k.getI(), k.getJ()); -void changeKeypoint(Keypoint& k, Matrix& offset) -{ + point2d n1(k.getI(), k.getJ() - 1); + point2d n2(k.getI() - 1, k.getJ()); + point2d n3(k.getI() + 1, k.getJ()); + point2d n4(k.getI(), k.getJ() + 1); + + point2d n5(k.getI() - 1, k.getJ() - 1); + point2d n6(k.getI() + 1, k.getJ() - 1); + point2d n7(k.getI() + 1, k.getJ() + 1); + point2d n8(k.getI() - 1, k.getJ() + 1); + + point2d cupper(c.row() / 2, c.col() / 2); + point2d n1upper(n1.row() / 2, n1.col() / 2); + point2d n2upper(n2.row() / 2, n3.col() / 2); + point2d n3upper(n3.row() / 2, n3.col() / 2); + point2d n4upper(n4.row() / 2, n4.col() / 2); + + point2d clower(c.row() * 2, c.col() * 2); + point2d n1lower(n1.row() * 2, n1.col() * 2); + point2d n2lower(n2.row() * 2, n2.col() * 2); + point2d n3lower(n3.row() * 2, n3.col() * 2); + point2d n4lower(n4.row() * 2, n4.col() * 2); + + float partial_xx, partial_yy, partial_ss, partial_xy, partial_xs, partial_ys; + + // Compute partial xx + partial_xx = main(n3) - 2 * main(c) + main(n2); + + // Compute partial yy + partial_yy = main(n4) - 2 * main(c) + main(n1); + + // Compute partial ss + partial_ss = lower(clower) - 2 * main(c) + + upper(cupper); + + // Compute partial xy + partial_xy = (main(n8) - main(n6) - main(n7) + main(n5)) / 4.0; + + // Compute partial xs + partial_xs = (upper(n3upper) - lower(n3lower) + - upper(n2upper) + lower(n2lower)) / 4.0; + + // Compute partial ys + partial_ys = (upper(n4upper) - lower(n4lower) + - upper(n1upper) + lower(n1lower)) / 4.0; + + matrix.set(0, 0, partial_xx); + matrix.set(0, 1, partial_xy); + matrix.set(0, 2, partial_xs); + + matrix.set(1, 0, partial_xy); + matrix.set(1, 1, partial_yy); + matrix.set(1, 2, partial_ys); + + matrix.set(2, 0, partial_xs); + matrix.set(2, 1, partial_ys); + matrix.set(2, 2, partial_ss); } // Discard low contrast keypoints thanks to taylor interpolation // See Brown and Lowe paper (2002) -// FIXME Move to object representation (size-templated matrix maybe ?) -template<typename I> +template<typename I, typename C> void discardLowContrastKeypoints(const std::vector< std::vector >& dogSpace, - std::vector<Keypoint>& keypoints) + std::vector<Keypoint>& keypoints, + C& extrema) { + Keypoint k_old(0, 0, 0, 0, true); + for (unsigned i = 0; i < keypoints.size(); ++i) { Keypoint k = keypoints.at(i); - Matrix *fom = computeFirstOrderMatrix(dogSpace, k); - Matrix *som = computeSecondOrderMatrix(dogSpace, k); - Matrix inversed(som->getHeight(), som->getWidth()); - bool inversible = som->inverse(inversed); + Matrix firstOrder(3, 1); + Matrix secondOrder(3, 3); + Matrix inversed(secondOrder.getHeight(), secondOrder.getWidth()); - if (inversible) + computeFirstOrderMatrix(dogSpace, k, firstOrder); + computeSecondOrderMatrix(dogSpace, k, secondOrder); + bool hasInversed = secondOrder.inverse(inversed); + + if (hasInversed) { - Matrix offset = (*fom) * (*som); - - if (isBetter(offset)) + Matrix x = inversed * firstOrder; + bool isMajorOffset = x.isMajorOffset(); + + if (isMajorOffset) + { + std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl; + std::cout << "First order matrix:" << std::endl; + firstOrder.print(); + + std::cout << "Second order matrix:" << std::endl; + secondOrder.print(); + + std::cout << "Offset: " << std::endl; + x.print(); + + std::cout << "k_old: " << k_old.getI() << " " << k_old.getJ() << std::endl; + std::cout << "k: " << k.getI() << " " << k.getJ() << std::endl; + bool hasMoved = k.add(x, k_old); + std::cout << "k++: " << k.getI() << " " << k.getJ() + << "\thasMoved: " << hasMoved << std::endl; + + point2d p(k.getI(), k.getJ()); + std::cout << "Final point: " << extrema.domain() << "\t" <= 0 && p.row() < geom::max_row(extrema) + && p.col() >= 0 && p.col() < geom::max_col(extrema)) + { + std::cout << "VALID" << std::endl; + extrema(p) = literal::red; + k_old = keypoints.at(i); + keypoints.at(i--) = k; + } + + std::cout << std::endl; + } + else { - changeKeypoint(k, offset); + point2d p(k.getI(), k.getJ()); + extrema(p) = literal::red; } } } } -/*****************************************************************************/ -/*****************************************************************************/ -/*****************************************************************************/ - // Main entry point int main(int argc, char** argv) { @@ -624,18 +733,33 @@ int main(int argc, char** argv) std::vector< std::vector > dogSpace; std::vector<Keypoint> keypoints; I original; - C extrema; + C extrema, improved; + bool black = true; io::pgm::load(original, "images/lena.pgm"); + if (black) + { + initialize(extrema, original); + initialize(improved, original); + } + else + { + extrema = data::convert(value::rgb8(), original); + improved = data::convert(value::rgb8(), original); + } + // Localization buildScaleSpace(scaleSpace, original, octave_level, blur_level); buildDifferenceOfGaussianSpace(scaleSpace, dogSpace); buildExtrema(extrema, original, dogSpace, keypoints); - //discardLowContrastKeypoints(dogSpace, keypoints); + discardLowContrastKeypoints(dogSpace, keypoints, improved); // Processing // TODO + io::ppm::save(extrema, "output/extrema.ppm"); + io::ppm::save(improved, "output/extrema_improved.ppm"); + return 0; } diff --git a/milena/sandbox/anthony/src/matrix.cc b/milena/sandbox/anthony/src/matrix.cc index 1c5784d..ee00ffc 100644 --- a/milena/sandbox/anthony/src/matrix.cc +++ b/milena/sandbox/anthony/src/matrix.cc @@ -46,7 +46,6 @@ void Matrix::print() std::cout << std::endl; } - float Matrix::determinant() { float d1 = m.at(0).at(0) * m.at(1).at(1) * m.at(2).at(2); @@ -99,7 +98,6 @@ bool Matrix::inverse(Matrix& inversed) for (unsigned j = 0; j < comatrix.getHeight(); ++j) comatrix.set(i, j, comatrix.get(i,j) / det); - comatrix.print(); inversed = comatrix; canInverse = true; @@ -120,7 +118,33 @@ Matrix Matrix::operator*(Matrix& right) result.add(i, k, m.at(i).at(j) * right.get(j, k)); return result; -}; +} + +void Matrix::absolute() +{ + for (unsigned i = 0; i < height; ++i) + for (unsigned j = 0; j < width; ++j) + m.at(i).at(j) *= (m.at(i).at(j) >= 0) ? 1 : -1; +} + +bool Matrix::isMajorOffset() +{ + unsigned i = 0; + unsigned j = 0; + bool isMajorOffset = false; + + while (!isMajorOffset && i < height) + { + while (!isMajorOffset && j < width) + { + isMajorOffset = m.at(i).at(j) > 0.5 || - m.at(i).at(j) > 0.5; + ++j; + } + ++i; + } + + return isMajorOffset; +} // Getters and Setters unsigned Matrix::getHeight() { return height; } diff --git a/milena/sandbox/anthony/src/matrix.hh b/milena/sandbox/anthony/src/matrix.hh index b2ca124..de83912 100644 --- a/milena/sandbox/anthony/src/matrix.hh +++ b/milena/sandbox/anthony/src/matrix.hh @@ -13,8 +13,9 @@ class Matrix void initialize(); void initialize(float *values); void print(); - float determinant(); bool inverse(Matrix& inversed); + void absolute(); + bool isMajorOffset(); // Operators Matrix operator*(Matrix& right); @@ -30,6 +31,8 @@ class Matrix std::vector< std::vector<float> > m; unsigned height; unsigned width; + + float determinant(); }; #endif /* ! MATRIX_HH */ -- 1.7.2.5

11 years, 7 months

olena: branch sandbox/anthony updated: olena-2.0-594-g3748427

by git＠lrde.epita.fr

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Olena, a generic and efficient image processing platform". The branch sandbox/anthony has been updated via 3748427f0634fa0a7e531042cba2bba85a93447a (commit) from 609a6a45b6b5d8725a1f7da78aa50604c841be44 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- 3748427 Add matrix class to handle Taylor approximation (dirty version) ----------------------------------------------------------------------- Summary of changes: milena/sandbox/anthony/Makefile | 2 +- milena/sandbox/anthony/src/main.cc | 78 ++++++++++++++++++--- milena/sandbox/anthony/src/matrix.cc | 130 ++++++++++++++++++++++++++++++++++ milena/sandbox/anthony/src/matrix.hh | 35 +++++++++ 4 files changed, 234 insertions(+), 11 deletions(-) create mode 100644 milena/sandbox/anthony/src/matrix.cc create mode 100644 milena/sandbox/anthony/src/matrix.hh hooks/post-receive -- Olena, a generic and efficient image processing platform

11 years, 7 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches