tischenkoalex's profile - activity

Thanks, this makes perfect sense for me. I tried with KAZE and it looks much better.

Hello, I'm using BOWKMeansTrainer to cluster ORB keypoints with FREAK descriptors. This combination of detector and matcher show good results for drawing-style images, which I trying to analyze, however BOWKMeansTrainer makes some problems...

After training, when I process an image with BOWImgDescriptorExtractor and get its image descriptor, I see that often words (clusters) consist of keypoints, which are too far from each other.

Here are highlighted keypoints of one of the words. Of course there are other words, which are localized enough, but I'm curious why it happens when they're not localized?

Weird words in my bag Hello, I'm using BOWKMeansTrainer to cluster ORB keypoints with FREAK descriptors. This combinatio

I switched to use ARUCO Board and it improved accuracy a lot. findHomography() and getPerspectiveTransform() provide the following result for me.

Yes, I plan to switch to subpixel accuracy too. Just wanted first to make sure that I'm not going in wrong direction by not calculating desired coordinates from vectors. I didn't check the homography topic yet though... I believe it will give me more understanding.

I added source images and corner coordinates. Will read more on homography. Thanks!

It looks like these could help, I'll try to play with them after I solve the problem which most likely gives the most distortion for me - http://answers.opencv.org/question/13...

I need to warp the image to fix its perspective distortion based on detected marker. In other words - to get the plane where the marker lays become parallel to the camera plane.

In general it works for me, when I simply map points of perspective-distorted marker to its orthogonal position (Sketch) with getPerspectiveTranfrorm() and then warpPerspective(), which warps whole image:

The following are sample params for getPerspectiveTransform()

src1 (100, 100) => dst1 (100, 100)
src2 (110, 190) => dst2 (100, 200)
src3: (190, 190) => dst3 (200, 200)
src4: (200, 100) => dst4 (200, 100)

The result looks OK, but not always, so I think that this way is wrong.

My assumption that since for detected marker I can get its pose estimation (which shows its relation to camera) I can calculate required marker position (or camera position?) using marker points and rotation/translation vectors.

Now I'm stuck basically not understanding the math solution. Could you advise?

UPDATE

The following is a source image with detected markers. The white circles represent the desired position of marker that will be used in getPerspectiveTransform().

Source corners: [479, 335; 530, 333; 528, 363; 475, 365]
Result corners: [479, 335; 529, 335; 529, 385; 479, 385]

The following is the result image, which is still distorted:

Hi, unfortunately the link in answer doesn't follow to any function now. Could you post function name or, maybe, code that worked for you?

Yeah... that's blurring makes such result, just tested with the same size, just blurred image. Now wondering how to fix this situation, because in real photo there is always some portion of blurring.

Only detection box. Here are both source images: https://www.dropbox.com/s/mbvtjvc5pl3...

The second image is a result (on the right). 1.png ans 2.png are two attempts, where 2.png is just a little bit smaller. I just got idea to play with detection params.

It is the first time I worked with ArUco markers and was disappointed by weird distortion after perspective transformation based on recognized markers. I assumed that its because of camera calibration errors and decided to test with "ideal" markers.

I calibrated camera with pattern file (not printed and photographed, but just from a source file). Then I generated my marker and put it on JPG image without any distortions. My program found the marker, I generated new position for marked and warped the image:

    int side = 100;
    resultCorners.push_back(corners[0][0]);
    resultCorners.push_back(Point2f(corners[0][0].x + side, corners[0][0].y));
    resultCorners.push_back(Point2f(corners[0][0].x + side, corners[0][0].y + side));
    resultCorners.push_back(Point2f(corners[0][0].x, corners[0][0].y + side));
    Mat w = getPerspectiveTransform(corners[0], resultCorners);
    warpPerspective(img_copy, result, w, img_copy.size());

That worked OK: 1.PNG

Then I minimized source image with one pyrDown call and tried to recognize marker again:

2.PNG

Could you please explain, why this weird distortion happens and how I can avoid it in real situation with photo or video stream?

UPDATE: On the left is a source image, on the right - a destination. I find marker on both to make sure that code above turns source image in orthogonal projection to camera. I assume I should use vectors that I receive from estimatePoseSingleMarkers here, but for now I'm just confused with distortion of markers detected in source image.

Thanks! I expected that rotation will be centered in resulting mat, but now I see it couldn't without explicitly specified offset:

Mat rot = getRotationMatrix2D(center, 90, 1);
rot.at<double>(0, 2) += 0; // x
rot.at<double>(1, 2) += size/2; // y

Hi, I'm rotating the 10x1 image by specifying center at 5,0:

[255, 255, 255, 255, 255, 255, 255, 255, 255, 255]

int size = 10;
Mat test = Mat::zeros(Size(size, 1), CV_8U);
line(test, Point(0, 0), Point(size, 0), Scalar(255));

Mat rot = getRotationMatrix2D(Point(test.cols/2, test.rows/2), 90, 1);
Mat dest;
warpAffine(test, dest, rot, Size(size, size));

imshow("Source", test);
imshow("Result", dest);

I assume that result will be the vertical line at center of 10x10 Mat, but it is shifted and cropped to the top:

[  0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0, 255,   0,   0,   0,   0;
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0;
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0;
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0;
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0]

I'm trying to understand why it happens?

I have 3-dimension matrix:

const int n_mat_size = 5;
const int n_mat_sz[] = { n_mat_size , n_mat_size, n_mat_size };
cv::Mat m1(3, n_mat_sz, CV_32FC1);

Now I'd like to iterate its planes and expect that it should be three two-dimensional matrices:

const cv::Mat* arrays[] = { &m1, 0 };
cv::Mat planes[3];
cv::NAryMatIterator it(arrays, planes);
std::cout << it.nplanes << ", " << it.planes[0].rows << ", " << it.planes[0].cols;

I expect to get output "3, 5, 5", but instead I get "1, 1, 125". Where is the slice of matrix?