/* Checks if any of our blobs are overlapping. If so, then merge then and
eliminate one of them.
*/
void Blobs::checkForMergers()
{
for (int i = 1; i < numBlobs; i++) {
for (int j = 0; j < i; j++) {
if (blobsOverlap(j, i)) {
mergeBlobs(i, j);
}
}
}
}
void segmentImageTrack::track(float _levity)
{
levity = _levity;
if(iter == true)
{
// apply hard constraints to blob
applyHardConst();
}
else
{
iter = true;
}
// merge all remaining blobs into a super blob
mergeBlobs();
}
// vector<BlobCollection> horizontalBlob
void BlobDetector::formBlobs(Color blobColor) {
VisionPoint ***hp = classifier_->horizontalPoint;
//cout << "Forming blobs..." << endl;
int hbpos = blobColor;
if(blobColor == c_BLUE)
hbpos = c_FIELD_GREEN;
if(blobColor == c_YELLOW)
hbpos = c_ORANGE;
horizontalBlob[hbpos].clear();
int numBlobs = 0;
int numBlobs2 = 0;
for (int y = 0; y < iparams_.height; y+=2) {
int numRuns = classifier_->horizontalPointCount[blobColor][y];
for (int i = 0; i < numRuns; ++i) {
vector<VisionPoint*> children = hp[blobColor][y][i].children;
if (children.size() > 2) {
++numBlobs;
// get bounding box
uint16_t xi, xf, dx, yi, yf, dy, sumY, sumX = 0;
xi = iparams_.width;
xf = 0;
yi = iparams_.height;
yf = 0;
sumY = sumX = 0;
int numCorrectColorPixels = 0;
for(size_t c = 0; c < children.size(); ++c) {
if (children[c]->xi < xi)
xi = children[c]->xi;
if (children[c]->yi < yi)
yi = children[c]->yi;
if (children[c]->xf > xf)
xf = children[c]->xf;
if (children[c]->yf > yf)
yf = children[c]->yf;
sumY += yi;
sumX += xi + dx/2;
}
dx = xf - xi + 1;
dy = yf - yi + 1;
for(int a = xi; a <= xf; ++a)
{
for(int b=yi; b<=yf; ++b)
{
if(getSegPixelValueAt(a, b) == blobColor)
numCorrectColorPixels++;
}
}
float area = abs(dx) * 1.0 * abs(dy);
float ratio = numCorrectColorPixels / area;
if (ratio > 0.65 && area > 225) {
numBlobs2++;
Blob b;
b.xi = xi;
b.xf = xf;
b.yi = yi;
b.yf = yf;
b.dx = dx;
b.dy = dy;
b.correctPixelRatio = ratio;
b.numCorrectColorPixels = numCorrectColorPixels;
b.avgX = xi + dx / 2;
b.avgY = yi + dy / 2;
assert(b.xi + b.dx - 1< iparams_.width);
assert(b.xf < iparams_.width);
assert(b.yi + b.dy - 1 < iparams_.height);
assert(b.yf < iparams_.height);
assert(b.dx < iparams_.width);
assert(b.dy < iparams_.height);
assert(b.dx > 0);
assert(b.dy > 0);
assert(b.correctPixelRatio > 0);
assert(b.numCorrectColorPixels > 0);
horizontalBlob[hbpos].push_back(b);
}
}
}
BlobCollection mergedBlobs = mergeBlobs(horizontalBlob[hbpos], XTHRESHOLD, YTHRESHOLD);
horizontalBlob[hbpos].clear();
for(size_t i = 0; i < mergedBlobs.size(); ++i)
{
horizontalBlob[hbpos].push_back(mergedBlobs[i]);
}
//cout << "Blobs color " << blobColor << " : " << numBlobs << " numBlobs2 " << numBlobs2 << " real size " << horizontalBlob[blobColor].size() << endl;
}
//cout << "End forming blobs..." << endl;
}
void testMergeBlobs2()
{
printf("\nTEST MERGE BLOBS - 2\n");
int blobCount = 3;
CvPoint p1, p2, p3, p4;
/////////////////////////////////////////////
// Test 2
Blob* b2 = malloc(blobCount * sizeof(Blob));
CvSeq* blobPoints2[blobCount];
CvMemStorage* storage2 = cvCreateMemStorage(0);
initPointSeqs(blobPoints2, blobCount, storage2);
b2[0].box.x = 1; b2[0].box.y = 1;
b2[0].box.width = 2; b2[0].box.height = 2;
p1 = cvPoint(1,1);
p2 = cvPoint(1,3);
p3 = cvPoint(3,3);
p4 = cvPoint(3,1);
cvSeqPush(blobPoints2[0], &p1);
cvSeqPush(blobPoints2[0], &p2);
cvSeqPush(blobPoints2[0], &p3);
cvSeqPush(blobPoints2[0], &p4);
b2[0].points = blobPoints2[0];
b2[1].box.x = 2; b2[1].box.y = 2;
b2[1].box.width = 2; b2[1].box.height = 2;
p1 = cvPoint(2,2);
p2 = cvPoint(2,4);
p3 = cvPoint(4,4);
p4 = cvPoint(4,2);
cvSeqPush(blobPoints2[1], &p1);
cvSeqPush(blobPoints2[1], &p2);
cvSeqPush(blobPoints2[1], &p3);
cvSeqPush(blobPoints2[1], &p4);
b2[1].points = blobPoints2[1];
b2[2].box.x = 3; b2[2].box.y = 3;
b2[2].box.width = 2; b2[2].box.height = 2;
p1 = cvPoint(3,3);
p2 = cvPoint(3,5);
p3 = cvPoint(5,5);
p4 = cvPoint(5,3);
cvSeqPush(blobPoints2[2], &p1);
cvSeqPush(blobPoints2[2], &p2);
cvSeqPush(blobPoints2[2], &p3);
cvSeqPush(blobPoints2[2], &p4);
b2[2].points = blobPoints2[2];
blobCount = mergeBlobs(&b2, 3, 0);
printf("Expected: 1, Actual: %d\n", blobCount);
printf("Expected: 12, Actual: %d\n", b2[0].points->total);
// Boites englobantes
printf("Expected: 1, Actual: %d\n", b2[0].box.x);
printf("Expected: 1, Actual: %d\n", b2[0].box.y);
printf("Expected: 4, Actual: %d\n", b2[0].box.width);
printf("Expected: 4, Actual: %d\n", b2[0].box.height);
free(b2);
cvReleaseMemStorage(&storage2);
}
void testMergeBlobs()
{
printf("\nTEST MERGE BLOBS\n");
int blobCount = 3;
CvPoint p1, p2, p3, p4;
Blob* b = malloc(blobCount * sizeof(Blob));
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* blobPoints[blobCount];
initPointSeqs(blobPoints, blobCount, storage);
b[0].box.x = 0; b[0].box.y = 5;
b[0].box.width = 2; b[0].box.height = 2;
p1 = cvPoint(0,5);
p2 = cvPoint(0,7);
p3 = cvPoint(2,7);
p4 = cvPoint(2,5);
cvSeqPush(blobPoints[0], &p1);
cvSeqPush(blobPoints[0], &p2);
cvSeqPush(blobPoints[0], &p3);
cvSeqPush(blobPoints[0], &p4);
b[0].points = blobPoints[0];
b[1].box.x = 1; b[1].box.y = 1;
b[1].box.width = 3; b[1].box.height = 3;
p1 = cvPoint(1,1);
p2 = cvPoint(1,4);
p3 = cvPoint(4,4);
p4 = cvPoint(4,1);
cvSeqPush(blobPoints[1], &p1);
cvSeqPush(blobPoints[1], &p2);
cvSeqPush(blobPoints[1], &p3);
cvSeqPush(blobPoints[1], &p4);
b[1].points = blobPoints[1];
b[2].box.x = 3; b[2].box.y = 2;
b[2].box.width = 3; b[2].box.height = 3;
p1 = cvPoint(3,2);
p2 = cvPoint(3,5);
p3 = cvPoint(6,5);
p4 = cvPoint(6,2);
cvSeqPush(blobPoints[2], &p1);
cvSeqPush(blobPoints[2], &p2);
cvSeqPush(blobPoints[2], &p3);
cvSeqPush(blobPoints[2], &p4);
b[2].points = blobPoints[2];
blobCount = mergeBlobs(&b, 3, 0);
printf("Expected: 2, Actual: %d\n", blobCount);
printf("Expected: 4, Actual: %d\n", b[0].points->total);
printf("Expected: 8, Actual: %d\n", b[1].points->total);
// Boites englobantes
printf("Expected: 0, Actual: %d\n", b[0].box.x);
printf("Expected: 5, Actual: %d\n", b[0].box.y);
printf("Expected: 1, Actual: %d\n", b[1].box.x);
printf("Expected: 1, Actual: %d\n", b[1].box.y);
printf("Expected: 5, Actual: %d\n", b[1].box.width);
printf("Expected: 4, Actual: %d\n", b[1].box.height);
free(b);
cvReleaseMemStorage(&storage);
}
