Adapt DFT-based convolution to fit the direct one

Author: ayllon

SEImplementation/SEImplementation/Segmentation/BackgroundConvolution.h

@@ -94,16 +94,7 @@ class BgDFTConvolutionImageSource : public ProcessingImageSource<DetectionImage:
                               std::shared_ptr<VectorImage<SeFloat>> kernel)
     : ProcessingImageSource<DetectionImage::PixelType>(image),
       m_variance(variance), m_threshold(threshold), m_convolution(kernel) {
-    m_kernel_min = std::numeric_limits<DetectionImage::PixelType>::max();
-    for (int y = 0; y < kernel->getHeight(); ++y) {
-      for (int x = 0; x < kernel->getWidth(); ++x) {
-        auto v = std::abs(kernel->getValue(x, y));
-        if (v > 0. && v < m_kernel_min) {
-          m_kernel_min = v;
-        }
-      }
     }
-  }
 
 protected:
 
@@ -135,7 +126,7 @@ class BgDFTConvolutionImageSource : public ProcessingImageSource<DetectionImage:
       }
     );
 
-    // Get the mask, and the negative
+    // Get the mask
     // For instance, with a threshold of 0.5
     // Variance     Mask       Negative
     // 1  1  1     0  0  0     1  1  1
@@ -147,60 +138,41 @@ class BgDFTConvolutionImageSource : public ProcessingImageSource<DetectionImage:
         return clipped_variance->getValue(x, y) < m_threshold;
       }
     );
-    auto mask_neg = FunctionalImage<DetectionImage::PixelType>::create(
-      mask->getWidth(), mask->getHeight(),
-      [mask](int x, int y) -> DetectionImage::PixelType {
-        return mask->getValue(x, y) == 0.;
-      }
-    );
 
     // Get the image masking out values where the variance is greater than the threshold
     auto masked_img = MultiplyImage<DetectionImage::PixelType>::create(clipped_img, mask);
 
-    // Convolve the original image with the kernel, padding with 0
-    auto conv_img = VectorImage<DetectionImage::PixelType>::create(clipped_img);
-    m_convolution.convolve(conv_img);
-
-    // Convolve the masked image, padding with 0 as well
+    // Convolve the masked image, padding with 0
     auto conv_masked = VectorImage<DetectionImage::PixelType>::create(masked_img);
     m_convolution.convolve(conv_masked);
 
-    // Convolve the mask, and the negative
+    // Convolve the mask
     // This gives us in each cell the sum of the kernel values that have been used,
-    // so we can divide the previous convolutions.
+    // so we can divide the previous convolution.
     auto conv_mask = VectorImage<DetectionImage::PixelType>::create(mask);
-    auto conv_mask_neg = VectorImage<DetectionImage::PixelType>::create(mask_neg);
     m_convolution.convolve(conv_mask);
-    m_convolution.convolve(conv_mask_neg);
 
-    // Copy out the value of the convolved image, divided by the negative mask, replacing
-    // any non-masked cell
+    // Copy out the value of the convolved image, divided by the negative mask, applying
+    // again the mask to the convolved result
     int off_x = start_x - clip_x;
     int off_y = start_y - clip_y;
     for (int y = 0; y < height; ++y) {
       for (int x = 0; x < width; ++x) {
-        // We want to use the masked convolution only if the resulting convolved mask
-        // is not 0. Since we are dealing with floats, we can not just compare to 0, because
-        // there will likely be a very small value greater than 0
-        if (std::abs(conv_mask->getValue(x + off_x, y + off_y)) > m_kernel_min / 2.) {
+        if (mask->getValue(x + off_x, y + off_y)) {
           tile.setValue(
             x + start_x, y + start_y,
             conv_masked->getValue(x + off_x, y + off_y) / conv_mask->getValue(x + off_x, y + off_y)
           );
-        }
-        else {
-          tile.setValue(
-            x + start_x, y + start_y,
-            conv_img->getValue(x + off_x, y + off_y) / conv_mask_neg->getValue(x + off_x, y + off_y)
-          );
+        } else {
+          tile.setValue(x + start_x, y + start_y, 0);
         }
       }
     }
   }
 
 private:
   std::shared_ptr<DetectionImage> m_variance;
-  DetectionImage::PixelType m_threshold, m_kernel_min;
+  DetectionImage::PixelType m_threshold;
   ConvolutionType m_convolution;
 };
 

SEImplementation/tests/src/Segmentation/BackgroundConvolution_test.cpp

@@ -43,17 +43,17 @@ BOOST_AUTO_TEST_CASE_TEMPLATE (kernel3_background, T, convolution_types) {
   auto image_source = std::make_shared<T>(image, variance, 0.5, kernel);
   auto result = image_source->getImageTile(0, 0, 5, 5)->getImage();
 
-  // When applying the kernel for getting the value of a cell, is there is no value corresponding to a
-  // variance below the threshold, the kernel is applied as one would normally expect.
-  // Otherwise, *only* the values that are below the threshold are actually used for the given cell.
+  // When applying the kernel for getting the value of a cell, the convolution is done only for pixels
+  // with a variance below the threshold: basically, on a masked image.
+  // The convolved image is masked again, so pixels that are next to a pixel below the threshold remain 0.
   // For this test, there are only two cells below the threshold (0.1 and 0.2, corresponding to 3.2 and 4.2)
   auto expected = VectorImage<SeFloat>::create(
     5, 5, std::vector<SeFloat>{
-      1.275, 2.020, 3.02000, 4.02000, 4.775,
-      1.300, 2.100, 3.20000, 4.20000, 4.900,
-      1.400, 3.200, 3.53333, 3.86667, 4.200,
-      1.500, 2.300, 3.20000, 4.20000, 5.100,
-      1.625, 2.380, 3.38000, 4.38000, 5.125,
+      0.00, 0.00, 0.00, 0.00, 0.00,
+      0.00, 0.00, 0.00, 0.00, 0.00,
+      0.00, 0.00, 3.53333, 3.86667, 0.00,
+      0.00, 0.00, 0.00, 0.00, 0.00,
+      0.00, 0.00, 0.00, 0.00, 0.00,
     }
   );
 
@@ -94,10 +94,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE (kernel3_background_with_offset, T, convolution_ty
 
   auto expected = VectorImage<SeFloat>::create(
     3, 4, std::vector<SeFloat>{
-      2.100, 3.20000, 4.20000,
-      3.200, 3.53333, 3.86667,
-      2.300, 3.20000, 4.20000,
-      2.380, 3.38000, 4.38000,
+      0.00, 0.00, 0.00,
+      0.00, 3.53333, 3.86667,
+      0.00, 0.00, 0.00,
+      0.00, 0.00, 0.00,
     }
   );
 
@@ -127,7 +127,7 @@ struct KernelSize {
 typedef boost::mpl::list<KernelSize<5>, KernelSize<7>, KernelSize<9>, KernelSize<11>> kernel_sizes;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE (kerneln_background, T, kernel_sizes) {
-  // For a big kernel, just compare both do the same
+  // For a big kernel, just compare they both do the same
   // Doing it manually would be painful, but the previous test, with small sizes,
   // can be easily followed up by hand