OpenCV CascadeClassifier detectMultiScale resulting Rect outside input Mat bounds - c++

Question

I'm having a problem with detectMultiScale returning rectangles outside the bounds of the input Mat.
So what I'm doing is an optimization technique where the first frame of a video feed is passed to detectMultiScale in it's entirety.
If an object was detected, I create a temp Mat, which i clone the previous frames detected object's rect from the current full frame.
Then i pass this temp Mat to detectMultiScale, so only the area around the rectangle where the previous frame detected an object.
The problem i'm having is that the results from detectMultiScale when passing the temp Mat give rectangles that are outside the bounds of the input temp Mat.
Mostly I would just like to know exactly what is going on here. I have two ideas of what could be happening, but I can't figure out for sure.
Either the clone operation when cloning a rect from a full frame to the temp Mat is somewhere inside the Mat object setting the cloned area at the rows and columns of the full frame. So for example, i have a full frame of 100x100, i'm trying to clone a 10x10 rectangle from it at position 80x80. The resulting Mat will then be size 10x10, but maybe inside the Mat somewhere it is saying the Mat starts at 80x80?
CascadeClassifier is keeping state somewhere of the full frame i had passed to it previously?
I don't know what is happening here for sure, but was hoping someone could shed some light.
Here's a little code example of what i'm trying to do, with comments explaining the results i'm seeing:
std::vector<cv::Rect> DetectObjects(cv::Mat fullFrame, bool useFullFrame, cv::Rect detectionRect)
{
// fullFrame is 100x100
// detectionRect is 10x10 at position 80x80 eg. cv::Rect(80,80,10,10)
// useFullFrame is False
std::vector<cv::Rect> results;
if(useFullFrame)
{
object_cascade.detectMultiScale(fullFrame,
results,
m_ScaleFactor,
m_Neighbors,
0 | cv::CASCADE_SCALE_IMAGE | cv::CASCADE_DO_ROUGH_SEARCH | cv::CASCADE_DO_CANNY_PRUNING,
m_MinSize,
m_MaxSize);
}
else
{
// useFullFrame is false, so we run this block
cv::Mat tmpMat = fullFrame(detectionRect).clone();
// tmpMat is size 10,10
object_cascade.detectMultiScale(tmpMat,
results,
m_ScaleFactor,
m_Neighbors,
0 | cv::CASCADE_SCALE_IMAGE | cv::CASCADE_DO_ROUGH_SEARCH | cv::CASCADE_DO_CANNY_PRUNING,
m_MinSize,
m_MaxSize);
}
if(results.size() > 0)
{
// this is the weird part. When looking at the first element of
// results, (result[0]), it is at position 80,80, size 10,10
// so it is cv::Rect(80,80,10,10)
// even though the second detectMultiScale was ran with a Mat of 10x10
// do stuff
}
}
This is pretty darn close to what i have in code, except for the actual example values i mention above in the comments, i used values that were easy rather than full frame values like 1920x1080 and actual results, something like 367x711 for example.
So why am i getting results from detectMultiScale that are outside the bounds of the input Mat?
EDIT:
I had written this program originally for an embedded linux distribution, where this problem does not arise (i've always gotten expected results). This problem is happening on a windows release and build of opencv, so i'm currently going through the opencv code to see if there's anything that stands out related to this.

Answer 1

I believe this is a simple logic error. This:
if(fullFrame)
should be this:
if(useFullFrame)