Ask Your Question

Revision history [back]

click to hide/show revision 1
initial version

Switching from BRISK to FREAK detector causes only wrong matches

I'm into a CV project where I need to extract some matched keypoints between two very similar images. Not a lot, only 30-50 for my purposes. So far I used the combination of two (three) algorithms:

1) BRISK to detect keypoints in both images

BRISK briskObj = BRISK(50, 0);
briskObj.detect(img1, keyp1);
briskObj.detect(img2, keyp2);

2) BRISK, again, to compute descriptors

briskObj.compute(img1, keyp1, descr1);
briskObj.compute(img2, keyp2, descr2);

3) BruteForceMatcher to match (then I filter by myself using the distance field)

BFMatcher matcher(NORM_HAMMING, true);
matcher.match(descr1, descr2, matches);
// ..... 
if (thisMatch.distance < 40) {
     filtered.push_back(thisMatch);
}

Result are REALLY good. I must quote BRISK as one of the best detector/descriptors because it produces several "perfect" matches. But it has a limit: its descriptor module is too much memory consuming for my needs (I want to port it on a device with not so much RAM).

For this, I decided to change only the second method with another lighter descriptor: FREAK.

FREAK freakObj = FREAK(true, true, 60);
freakObj.compute(img1, keyp1, descr1);
freakObj.compute(img2, keyp2, descr2);

The problem, now, is that none of the matched keypoints is right. Every match is far from the right position by 10-30 pixels (and this is because I've filtered them, otherwise it would be worse). I tried changing its parameters, like testing patternScale from 30 to 80, normalization booleans or my own filtering method. All of my matches are wrong...

So, how can I reach the performances of the BRISK descriptor with FREAK? I really need it because of its speed

Switching from BRISK to FREAK detector descriptor causes only wrong matches

I'm into a CV project where I need to extract some matched keypoints between two very similar images. Not a lot, only 30-50 for my purposes. So far I used the combination of two (three) algorithms:

1) BRISK to detect keypoints in both images

BRISK briskObj = BRISK(50, 0);
briskObj.detect(img1, keyp1);
briskObj.detect(img2, keyp2);

2) BRISK, again, to compute descriptors

briskObj.compute(img1, keyp1, descr1);
briskObj.compute(img2, keyp2, descr2);

3) BruteForceMatcher to match (then I filter by myself using the distance field)

BFMatcher matcher(NORM_HAMMING, true);
matcher.match(descr1, descr2, matches);
// ..... 
if (thisMatch.distance < 40) {
     filtered.push_back(thisMatch);
}

Result are REALLY good. I must quote BRISK as one of the best detector/descriptors because it produces several "perfect" matches. But it has a limit: its descriptor module is too much memory consuming for my needs (I want to port it on a device with not so much RAM).

For this, I decided to change only the second method with another lighter descriptor: FREAK.

FREAK freakObj = FREAK(true, true, 60);
freakObj.compute(img1, keyp1, descr1);
freakObj.compute(img2, keyp2, descr2);

The problem, now, is that none of the matched keypoints is right. Every match is far from the right position by 10-30 pixels (and this is because I've filtered them, otherwise it would be worse). I tried changing its parameters, like testing patternScale from 30 to 80, normalization booleans or my own filtering method. All of my matches are wrong...

So, how can I reach the performances of the BRISK descriptor with FREAK? I really need it because of its speed

Switching from BRISK to FREAK descriptor causes only wrong matches

I'm into a CV project where I need to extract some matched keypoints between two very similar images. Not a lot, only 30-50 for my purposes. So far I used the combination of two (three) algorithms:

1) BRISK to detect keypoints in both images

BRISK briskObj = BRISK(50, 0);
briskObj.detect(img1, keyp1);
briskObj.detect(img2, keyp2);

2) BRISK, again, to compute descriptors

briskObj.compute(img1, keyp1, descr1);
briskObj.compute(img2, keyp2, descr2);

3) BruteForceMatcher to match (then I filter by myself using the distance field)

BFMatcher matcher(NORM_HAMMING, true);
matcher.match(descr1, descr2, matches);
// ..... 
if (thisMatch.distance < 40) {
     filtered.push_back(thisMatch);
}

Result are REALLY good. I must quote BRISK as one of the best detector/descriptors because it produces several "perfect" matches. But it has a limit: its descriptor module is too much memory consuming for my needs (I want to port it on a device with not so much RAM).

For this, I decided to change only the second method with another lighter descriptor: FREAK.

FREAK freakObj = FREAK(true, true, 60);
freakObj.compute(img1, keyp1, descr1);
freakObj.compute(img2, keyp2, descr2);

The problem, now, is that none of the matched keypoints is right. Every match is far from the right position by 10-30 pixels (and this is because I've filtered them, otherwise it would be worse). I tried changing its parameters, like testing patternScale from 30 to 80, normalization booleans or my own filtering method. All of my matches are wrong...

So, how can I reach the performances of the BRISK descriptor with FREAK? I really need it because of its speedlightness

Switching from BRISK to FREAK descriptor causes only wrong matches

I'm into a CV project where I need to extract some matched keypoints between two very similar images. Not a lot, only 30-50 "only" 20-30 for my purposes. So far I used the combination of two (three) algorithms:

1) BRISK to detect keypoints in both images

BRISK briskObj = BRISK(50, 0);
briskObj.detect(img1, keyp1);
briskObj.detect(img2, keyp2);

2) BRISK, again, to compute descriptors

briskObj.compute(img1, keyp1, descr1);
briskObj.compute(img2, keyp2, descr2);

3) BruteForceMatcher to match (then I filter by myself using the distance field)

BFMatcher matcher(NORM_HAMMING, true);
matcher.match(descr1, descr2, matches);
// ..... 
if (thisMatch.distance < 40) {
     filtered.push_back(thisMatch);
}

Result are REALLY good. I must quote BRISK as one of the best detector/descriptors because it produces several "perfect" matches. But it has a limit: its descriptor module is too much memory consuming for my needs (I want to port it on a device with not so much RAM).

For this, I decided to change only the second method with another lighter descriptor: FREAK.

FREAK freakObj = FREAK(true, true, 60);
freakObj.compute(img1, keyp1, descr1);
freakObj.compute(img2, keyp2, descr2);

The problem, now, is that none of the matched keypoints is right. Every match is far from the right position by 10-30 pixels (and this is because I've filtered them, otherwise it would be worse). I tried changing its parameters, like testing patternScale from 30 to 80, normalization booleans or my own filtering method. All of my matches are wrong...

So, how can I reach the performances of the BRISK descriptor with FREAK? I really need it because of its lightness