added ccv_filter unit test. find a bug in ccv_normalize, should

affect the accuracy of sift impl, and now sift should be much more
accurate (200% improve due to the bug fix)

Author: liuliu

bin/siftmatch.c

@@ -18,7 +18,7 @@ int main(int argc, char** argv)
 	unsigned int elapsed_time = get_current_time();
 	ccv_sift_param_t param;
 	param.noctaves = 3;
-	param.nlevels = 8;
+	param.nlevels = 6;
 	param.up2x = 1;
 	param.edge_threshold = 10;
 	param.norm_threshold = 0;
@@ -56,7 +56,7 @@ int main(int argc, char** argv)
 				mind2 = d;
 			}
 		}
-		if (mind < mind2 * 0.6)
+		if (mind < mind2 * 0.36)
 		{
 			ccv_keypoint_t* op = (ccv_keypoint_t*)ccv_array_get(obj_keypoints, i);
 			ccv_keypoint_t* kp = (ccv_keypoint_t*)ccv_array_get(image_keypoints, minj);

lib/ccv.h

@@ -361,8 +361,8 @@ int ccv_serialize(ccv_dense_matrix_t* mat, char* out, int* len, int type, void*
 double ccv_trace(ccv_matrix_t* mat);
 
 enum {
-	CCV_L2_NORM = 0x00,
-	CCV_L1_NORM = 0x01,
+	CCV_L2_NORM = 0x01,
+	CCV_L1_NORM = 0x02,
 };
 
 double ccv_norm(ccv_matrix_t* mat, int type);

lib/ccv_algebra.c

@@ -24,12 +24,32 @@ double ccv_normalize(ccv_matrix_t* a, ccv_matrix_t** b, int btype, int l_type)
 	btype = (btype == 0) ? CCV_GET_DATA_TYPE(da->type) | CCV_C1 : CCV_GET_DATA_TYPE(btype) | CCV_C1;
 	ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, da->rows, da->cols, CCV_ALL_DATA_TYPE | CCV_C1, btype, sig);
 	ccv_cache_return(db, 0);
-	double sum = 0;
+	double sum = 0, inv;
 	int i, j;
 	unsigned char* a_ptr = da->data.ptr;
 	unsigned char* b_ptr = db->data.ptr;
 	switch (l_type)
 	{
+		case CCV_L1_NORM:
+#define for_block(__for_set, __for_get) \
+			for (i = 0; i < da->rows; i++) \
+			{ \
+				for (j = 0; j < da->cols; j++) \
+					sum += __for_get(a_ptr, j, 0); \
+				a_ptr += da->step; \
+			} \
+			inv = 1.0 / sum; \
+			a_ptr = da->data.ptr; \
+			for (i = 0; i < da->rows; i++) \
+			{ \
+				for (j = 0; j < da->cols; j++) \
+					__for_set(b_ptr, j, __for_get(a_ptr, j, 0) * inv, 0); \
+				a_ptr += da->step; \
+				b_ptr += db->step; \
+			}
+			ccv_matrix_setter(db->type, ccv_matrix_getter, da->type, for_block);
+#undef for_block
+			break;
 		case CCV_L2_NORM:
 #define for_block(__for_set, __for_get) \
 			for (i = 0; i < da->rows; i++) \
@@ -39,7 +59,7 @@ double ccv_normalize(ccv_matrix_t* a, ccv_matrix_t** b, int btype, int l_type)
 				a_ptr += da->step; \
 			} \
 			sum = sqrt(sum); \
-			double inv = 1.0 / sqrt(sum); \
+			inv = 1.0 / sum; \
 			a_ptr = da->data.ptr; \
 			for (i = 0; i < da->rows; i++) \
 			{ \

test/data/chessbox.png samples/chessbox.pngtest/data/chessbox.png renamed to samples/chessbox.png

@@ -49,7 +49,7 @@ TEST_CASE("vector L2 normalize")
 	for (i = 0; i < 10; i++)
 		dmt->data.fl[i] = i;
 	ccv_normalize(dmt, (ccv_matrix_t**)&dmt, 0, CCV_L2_NORM);
-	float hm[10] = {0.000000, 0.243382, 0.486764, 0.730147, 0.973529, 1.216911, 1.460293, 1.703675, 1.947057, 2.190440};
+	float hm[10] = {0.000000, 0.059235, 0.118470, 0.177705, 0.236940, 0.296174, 0.355409, 0.414644, 0.473879, 0.533114};
 	REQUIRE_ARRAY_EQ_WITH_TOLERANCE(float, hm, dmt->data.fl, 10, 1e-6, "10d vector L2 normalize failure");
 	ccv_matrix_free(dmt);
 	ccv_garbage_collect();

samples/nature.png

@@ -1,5 +1,6 @@
 #include "ccv.h"
 #include "case.h"
+#include "ccv_case.h"
 
 int rosenbrock(const ccv_dense_matrix_t* x, double* f, ccv_dense_matrix_t* df, void* data)
 {
@@ -40,8 +41,32 @@ TEST_CASE("minimize rosenbrock")
 	ccv_garbage_collect();
 }
 
-TEST_CASE("fftw-based filter on Gaussian kernel")
+double gaussian(double x, double y, void* data)
 {
+	return exp(-(x * x + y * y) / 20);
+}
+
+TEST_CASE("FFTW-based filter on Gaussian kernel")
+{
+	ccv_dense_matrix_t* image = 0;
+	ccv_unserialize("../samples/nature.png", &image, CCV_SERIAL_ANY_FILE);
+	ccv_dense_matrix_t* gray = ccv_dense_matrix_new(image->rows, image->cols, CCV_32F | CCV_C1, 0, 0);
+	ccv_dense_matrix_t* kernel = ccv_dense_matrix_new(10, 10, CCV_32F | CCV_C1, 0, 0);
+	/* grayscale conversion, at this point, ccv doesn't support grayscale conversion yet */
+	int i, j;
+	for (i = 0; i < image->rows; i++)
+		for (j = 0; j < image->cols; j++)
+			gray->data.fl[i * gray->cols + j] = (image->data.ptr[i * image->step + j * 3] * 29 + image->data.ptr[i * image->step + j * 3 + 1] * 61 + image->data.ptr[i * image->step + j * 3 + 2] * 10) / 100;
+	ccv_filter_kernel(kernel, gaussian, 0);
+	ccv_normalize(kernel, (ccv_matrix_t**)&kernel, 0, CCV_L1_NORM);
+	ccv_dense_matrix_t* x = 0;
+	ccv_filter(gray, kernel, (ccv_matrix_t**)&x, 0);
+	REQUIRE_MATRIX_FILE_EQ(x, "data/nature.filter.bin", "should apply Gaussian filter with FFTW on nature.png with sigma = sqrt(10)");
+	ccv_matrix_free(image);
+	ccv_matrix_free(gray);
+	ccv_matrix_free(kernel);
+	ccv_matrix_free(x);
+	ccv_garbage_collect();
 }
 
 #include "case_main.h"

test/algebra.tests.c

@@ -123,7 +123,7 @@ TEST_CASE("compress sparse matrix")
 TEST_CASE("matrix slice")
 {
 	ccv_dense_matrix_t* image = 0;
-	ccv_unserialize("data/chessbox.png", &image, CCV_SERIAL_ANY_FILE);
+	ccv_unserialize("../samples/chessbox.png", &image, CCV_SERIAL_ANY_FILE);
 	ccv_dense_matrix_t* b = 0;
 	ccv_slice(image, (ccv_matrix_t**)&b, 0, 33, 41, 111, 91);
 	REQUIRE_MATRIX_FILE_EQ(b, "data/chessbox.slice.bin", "should have data/chessbox.png sliced at (33, 41) with 111 x 91");