Sliding window with roi c++ - c++

Question

I have little indexing problem with the following for loop. Simply I am scanning the image with roi but I am not able to scan whole image. I have some non scanned regions left in the last rows and cols. Any suggestion?
Sorry for simple question.
`
// Sliding Window for scaning the image
for (int rowIndex = 0; rowIndex <= lBPIIImage2.rows - roih; rowIndex = getNextIndex(rowIndex, lBPIIImage2.rows, roih, steprow))
{
for (int colindex = 0; colindex <=lBPIIImage2.cols - roiw; colindex = getNextIndex(colindex, lBPIIImage2.cols, roiw, stepcol))
{
searchRect = cvRect(colindex, rowIndex, roiw, roih);
frameSearchRect = lBPIIImage2(searchRect);
LoopDummy = frameSearchRect.clone();
rectangle(frame, searchRect, CV_RGB(255, 0, 0), 1, 8, 0);
//normalize(LoopDummy, LoopDummy, 0, 255, NORM_MINMAX, CV_8UC1);
//imshow("Track", LoopDummy);
//waitKey(30);
images.push_back(LoopDummy);
Coordinate.push_back(make_pair(rowIndex, colindex));
}
}

Answer 1

Instead of this
for (int rowindex = 0; rowindex <= frameWidth - roiw; rowindex += StepRow)
try something like this
for (int rowIndex = 0; rowIndex < frameWidth - roiw;
rowIndex = getNextIndex(rowIndex, frameWidth, roiw, StepRow))
where function getNextIndex is like this:
int getNextIndex(int currentIndex, int frameSize, int roi, int step)
{
int temp = min(currentIndex + step, frameSize - roi - 1);
return currentIndex != temp ? temp : frameSize;
}
Note that I replaced <= with < in the condition part of the loop. It makes sense to me to change that bit. In my comments index values should be 0,5,6, instead of 0,5,7. If it really should stand <= then just remove the - 1 part above.

Answer 2

Dialecticus has your problem covered, but I'd like to expand a little. The problem, as you've noticed, affects both rows and columns, but I'll only talk about width since height handling is analogous.
Parts of an array or range not iterated over by a loop, especially ones at the end, is a typical symptom that the loop's condition and/or increment do not cover the entire array/range and need adjustment. In your case, to scan the entire image width, you'd need frameWidth - roiw to be an exact number of StepRows, i.e. (frameWidth - roiw) % StepRow == 0. I strongly suspect that's not true in your case.
For example, if your image is 14 pixels wide, and your region of interest width is 8, in which case your step would be 4 pixels (I assume you meant roiw * 0.5), then this would happen:
Iteration #3 would fail the rowindex <= frameWidth - roiw test and exit the loop without scanning the last 2 pixels.
I see three options, each with its disadvantages:
Disclaimer: All code below is not tested and may contain typos and logical errors. Please test and adjust accordingly.
Change the offset of the last region so it fits the end of the image. In this case, the last rowindex increment would not be StepRow but the number of pixels between the end of your last scanning region and the end of the image. The drawback is that the last two regions may overlap more than those before them - in our case, region 1 would cover pixels 0:7, region 2 - 4:11 and region 3 - 6:13.
To do this, you can modify your loop increment to check if this is the last iteration (please think of how to write it prettier, I just used the ternary operator to make the change smaller):
for (int rowindex = 0;
/* Note that a region of (roiw) pixels ending at (frameWidth - 1) should start
at (frameWidth - roiw), so the <= operator should be correct. To verify that,
check the single-region case where rowindex == 0 and frameWidth == roiw */
rowindex <= frameWidth - roiw;
rowindex += ((rowindex + roiw + StepRow <= frameWidth) ?
StepRow :
(frameWidth - (rowindex + roiw))))
Clamp the size of the last region to the end of the image. The drawback would be that your last region is smaller than those before it - in our case, regions 1 and 2 would have a size of 8, while region 3 would be 6 pixels.
To do this, you can put a check when constructing the cvRect to see if it needs to be smaller. You should also change your loop condition somehow, so that you actually enter it in this case:
/* (StepRow - 1) should make sure that enter the loop is entered when the
last unscanned region has a width between 1 and stepRow, inclusive */
for (int rowindex = 0; rowindex <= frameWidth - roiw + (StepRow - 1); rowindex += StepRow)
/* ... column loop ... */
{
if (rowindex > frameWidth - roiw)
{
roiw = frameWidth - rowindex;
}
searchRect = cvRect(rowindex, colindex, roiw, roih)
Use a varying step so that your regions are of equal width and overlap as equally as possible. In our case, the three regions would overlap equally, being at pixels 0:7, 3:11 and 6:14, but obviously that won't be true in most cases.
To do that, you can calculate how many iterations you expect to do with your current step, and then divide by that number the difference between your frame and ROI width, which would give you your fractional step. Since pixel offset is an integer, to construct the cvRect, you'd need an integer value. I suggest keeping and incrementing the rowindex and step as fractions and converting to int just before use in the cvRect constructor - in this way, your index will move as evenly as possible.
Note that I've used an epsilon value to (hopefully) avoid rounding errors in float-to-int conversion when the float value is very close to an int. See this blog post and comments for an example and an explanation of the technique. However, keep in mind that the code is not tested and there may still be rounding errors, especially if your int values are big!
/* To see how these calculations work out, experiment with
roiw == 8, StepRow == 4 and frameWidth == 14, 15, 16, 17 */
/* N.B.: Does not cover the case when frameWidth < roiw! */
int stepRowCount = (frameWidth - roiw + (StepRow - 1)) / StepRow + 1;
float step = ((float)(frameWidth - roiw)) / (stepRowCount - 1);
float eps = 0.005;
for (float rowindex = 0.0; (int)(rowindex + eps) <= frameWidth - roiw; rowindex += StepRow)
/* ... column loop ... */
{ searchRect = cvRect((int)(rowindex + eps), colindex, roiw, roih);
P.S.: Shouldn't your index that iterates the image width be called colindex and vice versa, since in an 1920x1080 image you have 1920 columns and 1080 rows (hence terms like 1080p)?