Compare column by column - c++

Question

In this method I would like to find die biggest distance between two (adjecent) points for each column in a cv::Mat. In the end the corresponding points (which have the biggest distance to each other) should be returned.
To achive this, I already researched a lot and now I stuck at this code snippet:
cv::Mat mat;
std::vector<cv::Point> pointVec, finalPointVec;
std::vector<float> allDist;
for (int i = 0; i < mat.rows; i++) {
for (int j = 0; j < mat.cols; j++) {
c = mat.col(j);
if (c.at<Vec3b>(i, j)[0] == 0
&& c.at<Vec3b>(i, j)[1] == 0
&& c.at<Vec3b>(i, j)[2] == 255) {
cv::Point diPoint(j, i);
pointVec.push_back(diPoint);
if (pointVec[j].x == pointVec[j + 1].x) {
//std::cout << pointVec[j].y << "\n";
float diffY = pointVec[j].y - pointVec[j + 1].y;
float diffX = pointVec[j].x - pointVec[j + 1].x;
float dist = sqrt((diffY * diffY) + (diffX * diffX));
for (int d = 0; d < pointVec[j].x; d++) {
allDist.push_back(dist);
}
}
}
}
So I already iterate through the cv::Mat and also calculate the distance. Now I would like to implement finding the biggest distance for each column. Here I'm asking for your help, how I could realize it. Although I thought if (pointVec[j].x == pointVec[j + 1].x) should be fine to find the same columns, but it seems to be the wrong implementation. Also - how may I return those points, which have the largest distance to each other?
Maybe for some me clarification, here an image, how it should look like (the circled points should be those, which has to be returned):
I'm happy about any answer!

Answer 1

If I understood the task correctly, you need to divide your algorithm into two phases as I think you can't do these two things efficiently within the same loops:
Populating pointVec
Iterating through pointVec and calculating distances
Populating pointVec
cv::Mat mat;
std::vector<cv::Point> pointVec;
const cv::Vec3b sought_value(0, 0, 255);
for (int i = 0; i < mat.rows; i++) {
for (int j = 0; j < mat.cols; j++) {
if (mat.at<Vec3b>(i, j) == sought_value) {
pointVec.emplace_back(cv::Point(i, j));
}
}
}
I used emplace_back() instead of push_back() and eliminated the temporary variable for storing the point, even though in this case the performance difference might be little due to optimizations. I've also introduced sought_value because I think it's easier to read that way, but it's up to you which version you choose.
Iterating through pointVec and calculating distances
Step 2 is going to be much easier if we sort pointVec with respect to columns, and then to rows, beforehand. That way we know that consecutive points are usually adjacent to each other and belong to the same column. Also, I'm going to use std::tuple<int, float, std::pair<cv::Point, cv::Point>> for storing the max distance of each column together with column number and points to which the distance refers since that way we can easily locate the points and search maximum distance for each column as you wanted.
// keeps the results - column number, distance and points respectively:
using ColDistPointsTuple = std::tuple<int, float, std::pair<cv::Point, cv::Point>>;
std::vector <ColDistPointsTuple> column_maxes;
std::sort(column_maxes.begin(), column_maxes.end(),
[](const cv::Point& a, const cv::Point& b) -> bool
{
if (a.x < b.x)
return true;
else if (a.x == b.x)
return a.y < b.y;
else
return false;
}
);
for (int j = 0; j < pointVec.size() - 1; ++j) // note '-1' here - otherwise you'll get out of bounds exception
{
if (pointVec[j].x == pointVec[j + 1].x) {
float diffY = pointVec[j].y - pointVec[j + 1].y;
float diffX = pointVec[j].x - pointVec[j + 1].x;
float dist = sqrt((diffY * diffY) + (diffX * diffX));
if (!column_maxes.empty())
{
if (std::get<0>(column_maxes.back()) == pointVec[j].x) // belongs to the same column
{
if (dist > std::get<1>(column_maxes.back())) // distance greater than the one stored for that column
{
column_maxes.back() =
std::make_tuple( pointVec[j].x, dist, pointVec[j], pointVec[j + 1] );
continue;
}
}
}
column_maxes.emplace_back( pointVec[j].x, dist, pointVec[j], pointVec[j+1] );
}
}
column_maxes holds column number, dist, and points respectively. I could have skipped the column number, but I think searching for elements based e.g. on the first coordinate of a point belonging to a pair belonging to a tuple (ugh!) in a vector would be really ugly and counterintuitive. The tuple above is not the prettiest thing in terms of syntax, but I think matches the way you want to use the results.
I had no chance to test this solution so it might contain some minor errors, but the general idea should work.
If you are going to do a lot of searching based on the column number, consider using std::map with the column number as a key, and a tuple consisting of distance and a pair of cv::Points as values. The basic algorithm would look the same, but you'd have to replace calls to operator[] with map iterators then. Also points insertion would be slower, so this solution has its pros and cons just like the one shown above.