Fixed issue with PatchGenerator and PatchStitcher when creating patches at the first row and column when overlap > 0

Author: smistad

source/FAST/Algorithms/ImagePatch/PatchGenerator.cpp

@@ -84,7 +84,7 @@ void PatchGenerator::generateStream() {
                 try {
                     std::tie(level, resampleFactor) = m_inputImagePyramid->getClosestLevelForMagnification(m_magnification, 0.1);
                     if(resampleFactor != 1.0f)
-                        reportWarning() << "Requested magnification level does not exist in image pyramid. " <<
+                        reportWarning() << "Requested magnification " << m_magnification << " does not exist in a level of the image pyramid. " <<
                                         "Will now try to sample from a lower level and resize. This may increase runtime." << reportEnd();
                 } catch(Exception &e) {
                     throw Exception("Unable to generate patches for magnification level " +
@@ -121,13 +121,7 @@ void PatchGenerator::generateStream() {
                         patchHeight = levelHeight - (patchY * patchHeightWithoutOverlap - overlapInPixelsY)*resampleFactor;
                     }
                     int patchOffsetX = (patchX * patchWidthWithoutOverlap - overlapInPixelsX)*resampleFactor;
-                    if(patchX == 0 && overlapInPixelsX > 0) {
-                        patchOffsetX = 0;
-                    }
                     int patchOffsetY = (patchY * patchHeightWithoutOverlap - overlapInPixelsY)*resampleFactor;
-                    if(patchY == 0 && overlapInPixelsY > 0) {
-                        patchOffsetY = 0;
-                    }
 
                     if(m_inputMask) {
                         // If a mask exist, check if this patch should be included or not
@@ -160,10 +154,10 @@ void PatchGenerator::generateStream() {
                     if(patchWidth < overlapInPixelsX*2 || patchHeight < overlapInPixelsY*2)
                         continue;
                     auto patch = access->getPatchAsImage(level,
-                                                         patchOffsetX,
-                                                         patchOffsetY,
-                                                         patchWidth,
-                                                         patchHeight);
+                                                         patchOffsetX < 0 ? 0 : patchOffsetX, // if there is overlap, we will have negative offset at edges
+                                                         patchOffsetY < 0 ? 0 : patchOffsetY,
+                                                         patchWidth + (patchOffsetX < 0 ? patchOffsetX : 0), // We have to reduce width and height if negative offset
+                                                         patchHeight + (patchOffsetY < 0 ? patchOffsetY : 0));
 
                     // If patch does not have correct size, pad it
                     int paddingValue = m_paddingValue;
@@ -174,18 +168,13 @@ void PatchGenerator::generateStream() {
                             paddingValue = 0;
                         }
                     }
-                    if(patch->getWidth() != (int)(m_width*resampleFactor) || patch->getHeight() != (int)(m_height*resampleFactor)) {
+                    if(patchOffsetX < 0 || patchOffsetY < 0 || patch->getWidth() != (int)(m_width*resampleFactor) || patch->getHeight() != (int)(m_height*resampleFactor)) {
                         // Edge cases, patches may not be the target patch size. Need to pad.
-                        patch = patch->crop(Vector2i(0, 0), Vector2i(m_width*resampleFactor, m_height*resampleFactor), true, paddingValue);
+                        patch = patch->crop(Vector2i(patchOffsetX < 0 ? patchOffsetX : 0, patchOffsetY < 0 ? patchOffsetY : 0), Vector2i(m_width*resampleFactor, m_height*resampleFactor), true, paddingValue);
                     }
                     if(resampleFactor > 1.0f) {
                         patch = ImageResizer::create(m_width, m_height, 1, m_inputImagePyramid->getNrOfChannels() > 1)->connect(patch)->runAndGetOutputData<Image>();
                     }
-                    if(m_overlapPercent > 0.0f && (patchX == 0 || patchY == 0)) {
-                        int offsetX = patchX == 0 ? -overlapInPixelsX : 0;
-                        int offsetY = patchY == 0 ? -overlapInPixelsY : 0;
-                        patch = patch->crop(Vector2i(offsetX, offsetY), Vector2i(m_width, m_height), true, paddingValue);
-                    }
 
                     // Store some frame data useful for patch stitching
                     patch->setFrameData("original-width", std::to_string(round(levelWidth/resampleFactor)));

source/FAST/Algorithms/ImagePatch/PatchStitcher.cpp

@@ -170,8 +170,12 @@ void PatchStitcher::processImage(std::shared_ptr<Image> patch) {
         const int patchOverlapY = std::stoi(patch->getFrameData("patch-overlap-y"));
         // Calculate offset. If this calculation is incorrect. Update in ImagePyramidPatchExporter as well.
         // Position of where to insert the (cropped) patch
-        const int startX = std::stoi(patch->getFrameData("patchid-x")) * (std::stoi(patch->getFrameData("patch-width")) - patchOverlapX*2); // TODO + overlap to compensate for start offset
-        const int startY = std::stoi(patch->getFrameData("patchid-y")) * (std::stoi(patch->getFrameData("patch-height")) - patchOverlapY*2);
+        const int patchWidth = std::stoi(patch->getFrameData("patch-width"));
+        const int patchHeight = std::stoi(patch->getFrameData("patch-height"));
+        const int patchWidthWithoutOverlap = patchWidth - patchOverlapX*2;
+        const int patchHeightWithoutOverlap = patchHeight - patchOverlapY*2;
+        const int startX = std::stoi(patch->getFrameData("patchid-x")) * patchWidthWithoutOverlap;
+        const int startY = std::stoi(patch->getFrameData("patchid-y")) * patchHeightWithoutOverlap;
         if(m_outputImage) {
             // 2D image
             cl::Program program = getOpenCLProgram(device, "2D");
@@ -190,8 +194,8 @@ void PatchStitcher::processImage(std::shared_ptr<Image> patch) {
                 kernel,
                 cl::NullRange,
                 cl::NDRange(
-                        std::min(patch->getWidth(), m_outputImage->getWidth()-startX),
-                        std::min(patch->getHeight(), m_outputImage->getHeight()-startY)
+                        std::min(patchWidthWithoutOverlap, m_outputImage->getWidth()-startX),
+                        std::min(patchHeightWithoutOverlap, m_outputImage->getHeight()-startY)
                     ),
                 cl::NullRange
             );

source/FAST/Algorithms/ImagePatch/PatchStitcher2D.cl

@@ -8,14 +8,15 @@ __kernel void applyPatch2D(
         __private int patchOverlapX,
         __private int patchOverlapY
     ) {
-    const int2 pos = {get_global_id(0) + startX, get_global_id(1) + startY};
+    const int2 pos = {get_global_id(0), get_global_id(1)}; // Patch pos
+    const int2 globalPos = {get_global_id(0) + startX, get_global_id(1) + startY};
     int dataType = get_image_channel_data_type(image);
-    int2 offset = {startX - patchOverlapX, startY - patchOverlapY};
+    int2 offset = {patchOverlapX, patchOverlapY};
     if(dataType == CLK_FLOAT) {
-		write_imagef(image, pos, read_imagef(patch, sampler, pos - offset));
+		write_imagef(image, globalPos, read_imagef(patch, sampler, pos + offset));
 	} else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
-		write_imageui(image, pos, read_imageui(patch, sampler, pos - offset));
+		write_imageui(image, globalPos, read_imageui(patch, sampler, pos + offset));
 	} else {
-		write_imagei(image, pos, read_imagei(patch, sampler, pos - offset));
+		write_imagei(image, globalPos, read_imagei(patch, sampler, pos + offset));
     }
 }