Merge pull request #26 from Kalpanika/feature/verbosity

Feature/verbosity

Author: rolkar

src/makefile

@@ -94,13 +94,13 @@ else
 
 -include $(BINDIR)/*.d
 
-$(BINDIR)/x3f_extract$(EXE): $(addprefix $(BINDIR)/,x3f_extract.o x3f_io.o x3f_process.o x3f_meta.o x3f_image.o x3f_spatial_gain.o x3f_output_dng.o x3f_output_tiff.o x3f_output_ppm.o x3f_histogram.o x3f_print.o x3f_dump.o x3f_matrix.o x3f_dngtags.o x3f_denoise_utils.o x3f_denoise_aniso.o x3f_denoise.o $(AUXOBJS)) $(OCV_LIBS) $(TIFF_LIBS)
+$(BINDIR)/x3f_extract$(EXE): $(addprefix $(BINDIR)/,x3f_extract.o x3f_io.o x3f_process.o x3f_meta.o x3f_image.o x3f_spatial_gain.o x3f_output_dng.o x3f_output_tiff.o x3f_output_ppm.o x3f_histogram.o x3f_print.o x3f_dump.o x3f_matrix.o x3f_dngtags.o x3f_denoise_utils.o x3f_denoise_aniso.o x3f_denoise.o x3f_printf.o $(AUXOBJS)) $(OCV_LIBS) $(TIFF_LIBS)
 	$(CXX) $^ -o $@ $(LDFLAGS) -lm
 
-$(BINDIR)/x3f_io_test$(EXE): $(addprefix $(BINDIR)/,x3f_io_test.o x3f_io.o x3f_print.o $(AUXOBJS))
+$(BINDIR)/x3f_io_test$(EXE): $(addprefix $(BINDIR)/,x3f_io_test.o x3f_io.o x3f_print.o x3f_printf.o $(AUXOBJS))
 	$(CC) $^ -o $@ $(LDFLAGS)
 
-$(BINDIR)/x3f_matrix_test$(EXE): $(addprefix $(BINDIR)/,x3f_matrix_test.o x3f_matrix.o $(AUXOBJS))
+$(BINDIR)/x3f_matrix_test$(EXE): $(addprefix $(BINDIR)/,x3f_matrix_test.o x3f_matrix.o x3f_printf.o $(AUXOBJS))
 	$(CC) $^ -o $@ $(LDFLAGS) -lm
 
 $(BINDIR)/%.o: %.c | $(BINDIR)

src/x3f_denoise.cpp

@@ -9,6 +9,7 @@
 #include "x3f_denoise_utils.h"
 #include "x3f_denoise.h"
 #include "x3f_io.h"
+#include "x3f_printf.h"
 
 using namespace cv;
 
@@ -17,27 +18,27 @@ static void denoise_nlm(Mat& img, float h)
   UMat out, sub, sub_dn, sub_res, res;
   float h1[3] = {0.0, h, h}, h2[3] = {0.0, h/8, h/4};
 
-  std::cout << "BEGIN denoising\n";
+  x3f_printf(DEBUG, "BEGIN denoising\n");
   fastNlMeansDenoising(img, out, std::vector<float>(h1, h1+3),
 		       3, 11, NORM_L1);
-  std::cout << "END denoising\n";
+  x3f_printf(DEBUG, "END denoising\n");
 
-  std::cout << "BEGIN V median filtering\n";
+  x3f_printf(DEBUG, "BEGIN V median filtering\n");
   UMat V(out.size(), CV_16U);
   int get_V[2] = { 2,0 }, set_V[2] = { 0,2 };
   mixChannels(std::vector<UMat>(1, out), std::vector<UMat>(2, V), get_V, 1);
   medianBlur(V, V, 3);
   mixChannels(std::vector<UMat>(1, V), std::vector<UMat>(2, out), set_V, 1);
-  std::cout << "END V median filtering\n";
+  x3f_printf(DEBUG, "END V median filtering\n");
 
-  std::cout << "BEGIN low-frequency denoising\n";
+  x3f_printf(DEBUG, "BEGIN low-frequency denoising\n");
   resize(out, sub, Size(), 1.0/4, 1.0/4, INTER_AREA);
   fastNlMeansDenoising(sub, sub_dn, std::vector<float>(h2, h2+3),
 		       3, 21, NORM_L1);
   subtract(sub, sub_dn, sub_res, noArray(), CV_16S);
   resize(sub_res, res, out.size(), 0.0, 0.0, INTER_CUBIC);
   subtract(out, res, out, noArray(), CV_16U);
-  std::cout << "END low-frequency denoising\n";
+  x3f_printf(DEBUG, "END low-frequency denoising\n");
 
   out.copyTo(img);
 }
@@ -99,10 +100,10 @@ void x3f_expand_quattro(x3f_area16_t *image, x3f_area16_t *active,
     UMat out;
     float h[3] = {0.0, d->h, d->h*2};
 
-    std::cout << "BEGIN Quattro full-resolution denoising\n";
+    x3f_printf(DEBUG, "BEGIN Quattro full-resolution denoising\n");
     fastNlMeansDenoising(act_exp, out, std::vector<float>(h, h+3),
 			 3, 11, NORM_L1);
-    std::cout << "END Quattro full-resolution denoising\n";
+    x3f_printf(DEBUG, "END Quattro full-resolution denoising\n");
 
     out.copyTo(act_exp);
   }
@@ -117,10 +118,10 @@ void x3f_set_use_opencl(int flag)
   if (flag) {
     if (ocl::useOpenCL()) {
       ocl::Device dev = ocl::Device::getDefault();
-      std::cout << "OpenCL device name: " << dev.name() << "\n";
-      std::cout << "OpenCL device version: " << dev.version() << "\n";
+      x3f_printf(INFO, "OpenCL device name: %s\n", dev.name().c_str());
+      x3f_printf(INFO, "OpenCL device version: %s\n", dev.version().c_str());
     }
-    else std::cerr << "WARNING: OpenCL is not available\n";
+    else x3f_printf(WARN, "WARNING: OpenCL is not available\n");
   }
-  else std::cout << "OpenCL is disabled\n";
+  else x3f_printf(DEBUG, "OpenCL is disabled\n");
 }

src/x3f_denoise_aniso.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include "x3f_denoise_aniso.h"
+#include "x3f_printf.h"
 #include <algorithm> //for std::sort for the median filter
 
 static inline float determine_pixel_difference(const float& v1_1, const float& v1_2, const float& v1_3,
@@ -30,7 +31,7 @@ void median_filter(x3f_area16_t *image)
   const uint32_t edgeless_rows = rows - 1;
   const uint32_t jump = image->channels;
   const uint32_t stride = image->row_stride;
-  
+
   uint16_t* current_set = new uint16_t[9];
   memset(current_set, 0, sizeof(uint16_t)*9);
   uint16_t* current_ptr;
@@ -40,9 +41,9 @@ void median_filter(x3f_area16_t *image)
   //gonna do median filtering by channel for now, to start with.
   uint16_t* scratch = new uint16_t[rows * cols * jump];
   float avg;
-  
+
   memcpy(scratch, image->data, rows*cols*jump*sizeof(uint16_t));
-  
+
   for (y = 1; y < edgeless_rows; y++){
     for (x = 1; x < edgeless_cols; x++) {
       for (i = 0; i < jump; i++){
@@ -78,8 +79,8 @@ void median_filter(x3f_area16_t *image)
   }
   //copy from scratch back into the image
   memcpy(image->data, scratch, rows*cols*jump*sizeof(uint16_t));
-  
-  
+
+
   delete [] scratch;
   delete [] current_set;
 }
@@ -101,20 +102,20 @@ void denoise_aniso_float(const uint32_t& in_rows, const uint32_t& in_columns, fl
   //not ideal, because there will be noise there, but it should avoid the green boundary problem.
   //there are a number of ways to solve boundary problems, but none of them are efficient.
   memcpy(out_image, image, in_rows * in_columns * jump * sizeof(float));
-  
+
   //diffusion for the first channel is different, to prevent color bleed
   float* h = new float[jump];
   h[0] = 5.0f;
   h[1] = 1.0f;
   h[2] = 1.0f;
-  
+
   for (y = 1; y < edgeless_rows; y++){
     for (x = 1,
 	   out_ptr = (out_image + y * row_stride + jump),
 	   in_ptr = (image + y * row_stride + jump);
          x < edgeless_cols;
          x++, out_ptr += jump, in_ptr += jump){
-      
+
       coeff_fwd = determine_pixel_difference(*in_ptr, *(in_ptr+1), *(in_ptr+2),
                                              *(in_ptr + jump), *(in_ptr + jump + 1), *(in_ptr + jump + 2));
       coeff_bkwd = determine_pixel_difference(*in_ptr, *(in_ptr+1), *(in_ptr+2),
@@ -123,12 +124,12 @@ void denoise_aniso_float(const uint32_t& in_rows, const uint32_t& in_columns, fl
 					      *(in_ptr + row_stride), *(in_ptr + row_stride + 1), *(in_ptr + row_stride + 2));
       coeff_up = determine_pixel_difference(*in_ptr, *(in_ptr+1), *(in_ptr+2),
                                             *(in_ptr - row_stride), *(in_ptr - row_stride + 1), *(in_ptr - row_stride + 2));
-      
+
       //uncomment out this line to do isotropic noise reduction
       //coeff_fwd = coeff_up = coeff_down = coeff_bkwd = -1.0f;
       lambda1 = coeff_fwd + coeff_bkwd + coeff_down + coeff_up;
       lambda2 = fabs(lambda1);
-      
+
       for (i = 0; i < jump; i++)
 	{
 	  *(out_ptr + i) = *(in_ptr + i) - (lambda2 * *(in_ptr + i) + coeff_fwd * *(in_ptr + jump + i)
@@ -139,7 +140,7 @@ void denoise_aniso_float(const uint32_t& in_rows, const uint32_t& in_columns, fl
 	}
     }
   }
-  
+
   memcpy(image, out_image, in_rows * in_columns * jump * sizeof(float));
   delete [] out_image;
   delete [] h;
@@ -153,7 +154,7 @@ void denoise_aniso(x3f_area16_t *image, const int& in_iterations)
   float* float_image = convert_to_float_image(image);
   for (int i = 0; i < in_iterations; i++){
     denoise_aniso_float(image->rows, image->columns, float_image);
-    std::cout << "iteration: " << i << std::endl;
+    x3f_printf(DEBUG, "iteration: %d\n", i);
   }
   convert_from_float_image(image, float_image);
   delete [] float_image;
@@ -178,36 +179,36 @@ void denoise_iso_float(const uint32_t& in_rows, const uint32_t& in_columns, floa
   //not ideal, because there will be noise there, but it should avoid the green boundary problem.
   //there are a number of ways to solve boundary problems, but none of them are efficient.
   memcpy(out_image, image, in_rows * in_columns * jump * sizeof(float));
-  
+
   //diffusion for the first channel is different, to prevent color bleed
   float* h = new float[jump];
   h[0] = 5.0f;
   h[1] = 1.0f;
   h[2] = 1.0f;
-  
+
   coeff_fwd = coeff_up = coeff_down = coeff_bkwd = -1.0f;
   lambda1 = coeff_fwd + coeff_bkwd + coeff_down + coeff_up;
   lambda2 = fabs(lambda1);
-  
+
   for (y = 1; y < edgeless_rows; y++){
     for (x = 1,
          out_ptr = (out_image + y * row_stride + jump),
          in_ptr = (image + y * row_stride + jump);
          x < edgeless_cols;
          x++, out_ptr += jump, in_ptr += jump){
-      
-      
+
+
       for (i = 0; i < jump; i++)
       {
         *(out_ptr + i) = *(in_ptr + i) - (lambda2 * *(in_ptr + i) + coeff_fwd * *(in_ptr + jump + i)
                                           + coeff_bkwd * *(in_ptr - jump + i)
                                           + coeff_down * *(in_ptr + row_stride + i)
                                           + coeff_up * *(in_ptr - row_stride + i))/(h[i] *lambda2);
-        
+
       }
     }
   }
-  
+
   memcpy(image, out_image, in_rows * in_columns * jump * sizeof(float));
   delete [] out_image;
   delete [] h;
@@ -221,7 +222,7 @@ void denoise_iso(x3f_area16_t *image, const int& in_iterations)
   float* float_image = convert_to_float_image(image);
   for (int i = 0; i < in_iterations; i++){
     denoise_iso_float(image->rows, image->columns, float_image);
-    std::cout << "iteration: " << i << std::endl;
+    x3f_printf(DEBUG, "iteration: %d\n", i);
   }
   convert_from_float_image(image, float_image);
   delete [] float_image;
@@ -244,19 +245,19 @@ void morphological_op(x3f_area16_t *image, const int& in_radius, const bool& ero
 {
   const int ysize = image->rows;  //forcing a cast to signed for boundary conditions
   const int xsize = image->columns;
-  
+
   uint16_t (*determinant)(const uint16_t&, const uint16_t&);
   determinant = &give_max;
   uint16_t seed = 0;
   if (erode){
     determinant = &give_min;
     seed = 65535;
   }
-  
+
   const int the_edge = in_radius*2 + 1;
   bool** theMask = new bool*[the_edge];
   const int sqrRad = in_radius*in_radius;
-  
+
   int x, y;
   for (y = -in_radius; y <= in_radius; y++){
     theMask[y + in_radius] = new bool[the_edge];
@@ -268,7 +269,7 @@ void morphological_op(x3f_area16_t *image, const int& in_radius, const bool& ero
       }
     }
   }
-  
+
   int dx, dy, i;
   const int jump = image->channels;
   uint16_t* outPixelData = new uint16_t[ysize*xsize*jump];
@@ -296,11 +297,11 @@ void morphological_op(x3f_area16_t *image, const int& in_radius, const bool& ero
       }
     }
   }
-  
+
   //memcpy(image->data, outPixelData, ysize*xsize*jump*sizeof(uint16_t));
   delete [] outPixelData;
   delete [] maxes;
-  
+
   for (y = -in_radius; y <= in_radius; y++){
     delete [] theMask[y + in_radius];
   }
@@ -319,10 +320,10 @@ void denoise_splotchify(x3f_area16_t *image, const int& in_radius)
   uint16_t* channel = new uint16_t[channel_size];
   uint16_t* chan_ptr = channel;
   uint16_t* image_ptr;
-  
+
   int morph_elem = 2; //ellipse
   int morph_size = in_radius;
-  
+
   cv::Mat element = cv::getStructuringElement( morph_elem, cv::Size( 2*morph_size + 1, 2*morph_size+1 ), cv::Point( morph_size, morph_size ) );
   for (i = 0; i < image->channels; i++){
     //first, get the data, one channel at a time.
@@ -332,16 +333,16 @@ void denoise_splotchify(x3f_area16_t *image, const int& in_radius)
         *chan_ptr = *image_ptr;
       }
     }
-    
+
     if (i>0){//skipping the first channel
       cv::Mat img(image->rows, image->columns, CV_16U, //apparently doesn't work on color images
               channel, sizeof(uint16_t)*xsize);
-    
+
       cv::UMat out;
       cv::morphologyEx( img, out, 3, element );
       cv::morphologyEx( out, img, 2, element );
-      
-      
+
+
       for (y = 0; y < ysize; y++){
         for (x = 0, chan_ptr = &(channel[y*xsize]), image_ptr = &(image->data[y*image->row_stride + i]);
              x < xsize; x++, chan_ptr++, image_ptr+=3){
@@ -351,5 +352,5 @@ void denoise_splotchify(x3f_area16_t *image, const int& in_radius)
     }
   }
   delete [] channel;
-  
+
 }