[libcvd-members] libcvd/test fast_test.cxx

[Edward Rosten]

CVSROOT:        /cvsroot/libcvd
Module name:    libcvd
Changes by:     Edward Rosten <edrosten>        10/09/20 14:32:47

Modified files:
        test           : fast_test.cxx 

Log message:
        More extensive FAST test program.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libcvd/test/fast_test.cxx?cvsroot=libcvd&r1=1.2&r2=1.3

Patches:
Index: fast_test.cxx
===================================================================
RCS file: /cvsroot/libcvd/libcvd/test/fast_test.cxx,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- fast_test.cxx       23 Aug 2007 00:06:40 -0000      1.2
+++ fast_test.cxx       20 Sep 2010 14:32:47 -0000      1.3
@@ -18,46 +18,130 @@
 
 using namespace CVD;
 
-template<class A, class B> void test(const Image<byte>& i, A funcf, B funcp)
+inline bool positive(int val, int centre, int barrier)
 {
-       cout << "Size: " << i.size() << endl;
+       return val > centre + barrier;
+}
 
-       vector<ImageRef> faster, normal;
+inline bool negative(int val, int centre, int barrier)
+{
+       return val < centre - barrier;
+}
 
-       funcp(i, normal, 1);
-       funcf(i, faster, 1);
+template<int num_for_corner, class Test>
+inline int is_corner(const SubImage<byte>& im, const ImageRef off, int 
barrier, const Test& test)
+{
+       int num_consecutive=0;
+       int first_cons=0;
+       const int centre = im[off];
 
-       cout << normal.size() << " " << faster.size() << " ";
+       for(int i=0; i<16; i++)
+       {
+               int val = im[fast_pixel_ring[i] + off];
+               if(test(val, centre, barrier))
+               {
+                       num_consecutive++;
 
-       if(normal.size() == faster.size())
-               cout << "ok." << endl;
+                       if(num_consecutive == num_for_corner)
+                               return 1;
+               } 
        else
-               cout << "\x1b[31m BROKEN!\x1b[0m\n";
+               {
+                       if(num_consecutive == i)
+                               first_cons=i;
+
+                       num_consecutive=0;
+               }
+       }
+       
+       return first_cons+num_consecutive >=num_for_corner;
+}
+
+template<int Num> void segment_test(const SubImage<byte>& im, 
vector<ImageRef>& v, int threshold)
+{
+       for(int y=3; y < im.size().y-3; y++)
+               for(int x=3; x < im.size().x-3; x++)
+                       if(is_corner<Num>(im, ImageRef(x, y), threshold, 
positive) || is_corner<Num>(im, ImageRef(x, y), threshold, negative))
+                               v.push_back(ImageRef(x, y));    
+}
+
+
+
+
+
+template<class A, class B, class C> void test(const Image<byte>& i, A funcf, B 
funcp, C funcs, int threshold)
+{
+       cout << "Size: " << i.size() << " threshold: " << threshold << " ";
+
+       vector<ImageRef> faster, normal, simple;
+
+       funcp(i, normal, threshold);
+       funcf(i, faster, threshold);
+       funcs(i, simple, threshold);
 
 
        sort(normal.begin(), normal.end());
        sort(faster.begin(), faster.end());
+       sort(simple.begin(), simple.end());
 
-       VideoDisplay d(i.size(), 2);
+       vector<ImageRef> all;
+       copy(normal.begin(), normal.end(), back_inserter(all));
+       copy(faster.begin(), faster.end(), back_inserter(all));
+       copy(simple.begin(), simple.end(), back_inserter(all));
        
-       vector<ImageRef> extra_in_normal, extra_in_faster;
+       sort(all.begin(), all.end());
+       vector<ImageRef>::iterator new_end = unique(all.begin(), all.end());
+       all.resize(new_end - all.begin());
 
-       set_difference(normal.begin(), normal.end(), faster.begin(), 
faster.end(), back_inserter(extra_in_normal));
-       set_difference(faster.begin(), faster.end(), normal.begin(), 
normal.end(), back_inserter(extra_in_faster));
+       cout << normal.size() << " " << faster.size() << " " << simple.size() 
<< " " << all.size() << " ";
+
+
+
+       vector<ImageRef> bad;
+       set_symmetric_difference(faster.begin(), faster.end(), simple.begin(), 
simple.end(), back_inserter(bad));
+       set_symmetric_difference(normal.begin(), normal.end(), simple.begin(), 
simple.end(), back_inserter(bad));
+
+       if(bad.empty())
+       {
+               cout << "ok." << endl;
+               return;
+       }
+
+       VideoDisplay d(i.size(), 2);
 
        glDrawPixels(i);
        glPointSize(3);
        glBegin(GL_POINTS);
-       glColor3f(1, 0, 0);
-       glVertex(extra_in_normal);
-       glColor3f(0, 1, 0);
-       glVertex(extra_in_faster);
+
+       for(unsigned int i=0; i < all.size(); i++)
+       {
+               Rgb<byte> colour(0,0,0);
+
+               if(!binary_search(normal.begin(), normal.end(), all[i]))
+                       colour.red = 255;
+
+               if(!binary_search(faster.begin(), faster.end(), all[i]))
+                       colour.green = 255;
+
+               if(!binary_search(simple.begin(),simple.end(), all[i]))
+                       colour.blue = 255;
+
+               //Colour can never be white. Black means OK.
+
+               if(colour != Rgb<byte>(0,0,0))
+               {
+                       glColor(colour);
+                       glVertex(all[i]);
+               }
+       }
        glEnd();
-       glFlush();
+
+       cout << "\x1b[31m BROKEN!\x1b[0m\n";
+
        cin.get();
 }
 
-template<class A, class B> void test_images(const Image<byte>& im, A funcf, B 
funcp)
+template<class A, class B, class C> void test_images(const Image<byte>& im, A 
funcf, B funcp, C funcs, int threshold)
 {
        ImageRef one(1,1);
        ImageRef zero(0,0);
@@ -70,35 +154,31 @@
                SubImage<byte> s = im.sub_image(zero, size);
                copy(s.begin(), s.end(),part.begin());
 
-               test(part, funcf, funcp);
+               test(part, funcf, funcp, funcs, threshold);
        }
 }
 
 
 int main(int argc, char** argv)
 {
-       if(argc != 2)
-               return 1;
 
+       for(;;)
+       {
+               Image<byte> im(ImageRef(drand48() * 1024 + 16, drand48()*1024 + 
16));
 
+               for(byte* i = im.begin(); i != im.end(); i++)
+                       *i =  (drand48() * 256);
 
-       try{
-               Image<byte> im= img_load(argv[1]);
+               int threshold = drand48() * 256;
 
                cout << "*************************FAST-9\n";
-               test_images(im, fast_corner_detect_9, 
fast_corner_detect_plain_9);
+               test_images(im, fast_corner_detect_9, 
fast_corner_detect_plain_9, segment_test<9>, threshold);
 
                cout << "*************************FAST-10\n";
-               test_images(im, fast_corner_detect_10, 
fast_corner_detect_plain_10);
+               test_images(im, fast_corner_detect_10, 
fast_corner_detect_plain_10, segment_test<10>, threshold);
 
                cout << "*************************FAST-12\n";
-               test_images(im, fast_corner_detect_12, 
fast_corner_detect_plain_12);
+               test_images(im, fast_corner_detect_12, 
fast_corner_detect_plain_12, segment_test<12>, threshold);
                
        }
-       catch(Exceptions::All e)
-       {
-               cerr << "Error: " << e.what << endl;
-       }
-
-       return 0;
 }