c++ - layers - Obtenga una representación de una sola línea para múltiples líneas cercanas agrupadas juntas en opencv

opencv masking an image

Question

Detecté líneas en una imagen y las dibujé en un archivo de imagen separado en OpenCv C ++ usando el método HoughLinesP. Lo siguiente es una parte de esa imagen resultante. En realidad, hay cientos de líneas finas y pequeñas que forman una gran línea única.

Pero quiero unas pocas líneas que representen todas esas líneas. Las líneas más cercanas deberían fusionarse para formar una sola línea. Por ejemplo, arriba del conjunto de líneas debería representarse por solo 3 líneas separadas como se muestra a continuación.

El resultado esperado es como el anterior. Cómo lograr esta tarea.

Hasta ahora el progreso es el resultado de la respuesta de akarsakov.

(Las clases separadas de líneas resultantes se dibujan en diferentes colores). Tenga en cuenta que este resultado es la imagen completa original en la que estoy trabajando, pero no la sección de muestra que utilicé en la pregunta

Answer 1

Aquí hay un refinamiento basado en la respuesta de @akarsakov. Un problema básico con:

La distancia entre los centros de los segmentos debe ser menor que la mitad de la longitud máxima de dos segmentos.

es que las líneas largas paralelas que están visualmente lejos pueden terminar en la misma clase de equivalencia (como se demostró en la edición de OP).

Por lo tanto, el enfoque que encontré fue razonable para mí:

1. Construya una ventana (rectángulo delimitador) alrededor de una line1 .
2. line2 ángulo de la line2 está lo suficientemente cerca de la line1 1 y al menos un punto de la line2 está dentro del rectángulo delimitador de la línea 1

A menudo, una característica lineal larga en la imagen que es bastante débil terminará reconocida (HoughP, LSD) por un conjunto de segmentos de línea con brechas considerables entre ellos. Para aliviar esto, nuestro rectángulo delimitador se construye alrededor de la línea extendida en ambas direcciones, donde la extensión se define por una fracción del ancho de línea original.

bool extendedBoundingRectangleLineEquivalence(const Vec4i& _l1, const Vec4i& _l2, float extensionLengthFraction, float maxAngleDiff, float boundingRectangleThickness){
Vec4i l1(_l1), l2(_l2);
// extend lines by percentage of line width
float len1 = sqrtf((l1[2] - l1[0])*(l1[2] - l1[0]) + (l1[3] - l1[1])*(l1[3] - l1[1]));
float len2 = sqrtf((l2[2] - l2[0])*(l2[2] - l2[0]) + (l2[3] - l2[1])*(l2[3] - l2[1]));
Vec4i el1 = extendedLine(l1, len1 * extensionLengthFraction);
Vec4i el2 = extendedLine(l2, len2 * extensionLengthFraction);
// reject the lines that have wide difference in angles
float a1 = atan(linearParameters(el1)[0]);
float a2 = atan(linearParameters(el2)[0]);
if(fabs(a1 - a2) > maxAngleDiff * M_PI / 180.0){
return false;
}
// calculate window around extended line
// at least one point needs to inside extended bounding rectangle of other line,
std::vector<Point2i> lineBoundingContour = boundingRectangleContour(el1, boundingRectangleThickness/2);
return
pointPolygonTest(lineBoundingContour, cv::Point(el2[0], el2[1]), false) == 1 ||
pointPolygonTest(lineBoundingContour, cv::Point(el2[2], el2[3]), false) == 1;
}

donde linearParameters, extendedLine, boundingRectangleContour son los siguientes:

Vec2d linearParameters(Vec4i line){
Mat a = (Mat_<double>(2, 2) <<
line[0], 1,
line[2], 1);
Mat y = (Mat_<double>(2, 1) <<
line[1],
line[3]);
Vec2d mc; solve(a, y, mc);
return mc;
}
Vec4i extendedLine(Vec4i line, double d){
// oriented left-t-right
Vec4d _line = line[2] - line[0] < 0 ? Vec4d(line[2], line[3], line[0], line[1]) : Vec4d(line[0], line[1], line[2], line[3]);
double m = linearParameters(_line)[0];
// solution of pythagorean theorem and m = yd/xd
double xd = sqrt(d * d / (m * m + 1));
double yd = xd * m;
return Vec4d(_line[0] - xd, _line[1] - yd , _line[2] + xd, _line[3] + yd);
}
std::vector<Point2i> boundingRectangleContour(Vec4i line, float d){
// finds coordinates of perpendicular lines with length d in both line points
// https://math.stackexchange.com/a/2043065/183923
Vec2f mc = linearParameters(line);
float m = mc[0];
float factor = sqrtf(
(d * d) / (1 + (1 / (m * m)))
);
float x3, y3, x4, y4, x5, y5, x6, y6;
// special case(vertical perpendicular line) when -1/m -> -infinity
if(m == 0){
x3 = line[0]; y3 = line[1] + d;
x4 = line[0]; y4 = line[1] - d;
x5 = line[2]; y5 = line[3] + d;
x6 = line[2]; y6 = line[3] - d;
} else {
// slope of perpendicular lines
float m_per = - 1/m;
// y1 = m_per * x1 + c_per
float c_per1 = line[1] - m_per * line[0];
float c_per2 = line[3] - m_per * line[2];
// coordinates of perpendicular lines
x3 = line[0] + factor; y3 = m_per * x3 + c_per1;
x4 = line[0] - factor; y4 = m_per * x4 + c_per1;
x5 = line[2] + factor; y5 = m_per * x5 + c_per2;
x6 = line[2] - factor; y6 = m_per * x6 + c_per2;
}
return std::vector<Point2i> {
Point2i(x3, y3),
Point2i(x4, y4),
Point2i(x6, y6),
Point2i(x5, y5)
};
}

Para partion, llame:

std::vector<int> labels;
int equilavenceClassesCount = cv::partition(linesWithoutSmall, labels, [](const Vec4i l1, const Vec4i l2){
return extendedBoundingRectangleLineEquivalence(
l1, l2,
// line extension length - as fraction of original line width
0.2,
// maximum allowed angle difference for lines to be considered in same equivalence class
2.0,
// thickness of bounding rectangle around each line
10);
});

Ahora, para reducir cada clase de equivalencia a una sola línea, construimos una nube de puntos y buscamos una línea adecuada:

// fit line to each equivalence class point cloud
std::vector<Vec4i> reducedLines = std::accumulate(pointClouds.begin(), pointClouds.end(), std::vector<Vec4i>{}, [](std::vector<Vec4i> target, const std::vector<Point2i>& _pointCloud){
std::vector<Point2i> pointCloud = _pointCloud;
//lineParams: [vx,vy, x0,y0]: (normalized vector, point on our contour)
// (x,y) = (x0,y0) + t*(vx,vy), t -> (-inf; inf)
Vec4f lineParams; fitLine(pointCloud, lineParams, CV_DIST_L2, 0, 0.01, 0.01);
// derive the bounding xs of point cloud
decltype(pointCloud)::iterator minXP, maxXP;
std::tie(minXP, maxXP) = std::minmax_element(pointCloud.begin(), pointCloud.end(), [](const Point2i& p1, const Point2i& p2){ return p1.x < p2.x; });
// derive y coords of fitted line
float m = lineParams[1] / lineParams[0];
int y1 = ((minXP->x - lineParams[2]) * m) + lineParams[3];
int y2 = ((maxXP->x - lineParams[2]) * m) + lineParams[3];
target.push_back(Vec4i(minXP->x, y1, maxXP->x, y2));
return target;
});

Demostración:

Línea particionada detectada (con líneas pequeñas filtradas):

Reducido:

Código de demostración:

int main(int argc, const char* argv[]){
if(argc < 2){
std::cout << "img filepath should be present in args" << std::endl;
}
Mat image = imread(argv[1]);
Mat smallerImage; resize(image, smallerImage, cv::Size(), 0.5, 0.5, INTER_CUBIC);
Mat target = smallerImage.clone();
namedWindow("Detected Lines", WINDOW_NORMAL);
namedWindow("Reduced Lines", WINDOW_NORMAL);
Mat detectedLinesImg = Mat::zeros(target.rows, target.cols, CV_8UC3);
Mat reducedLinesImg = detectedLinesImg.clone();
// delect lines in any reasonable way
Mat grayscale; cvtColor(target, grayscale, CV_BGRA2GRAY);
Ptr<LineSegmentDetector> detector = createLineSegmentDetector(LSD_REFINE_NONE);
std::vector<Vec4i> lines; detector->detect(grayscale, lines);
// remove small lines
std::vector<Vec4i> linesWithoutSmall;
std::copy_if (lines.begin(), lines.end(), std::back_inserter(linesWithoutSmall), [](Vec4f line){
float length = sqrtf((line[2] - line[0]) * (line[2] - line[0])
+ (line[3] - line[1]) * (line[3] - line[1]));
return length > 30;
});
std::cout << "Detected: " << linesWithoutSmall.size() << std::endl;
// partition via our partitioning function
std::vector<int> labels;
int equilavenceClassesCount = cv::partition(linesWithoutSmall, labels, [](const Vec4i l1, const Vec4i l2){
return extendedBoundingRectangleLineEquivalence(
l1, l2,
// line extension length - as fraction of original line width
0.2,
// maximum allowed angle difference for lines to be considered in same equivalence class
2.0,
// thickness of bounding rectangle around each line
10);
});
std::cout << "Equivalence classes: " << equilavenceClassesCount << std::endl;
// grab a random colour for each equivalence class
RNG rng(215526);
std::vector<Scalar> colors(equilavenceClassesCount);
for (int i = 0; i < equilavenceClassesCount; i++){
colors[i] = Scalar(rng.uniform(30,255), rng.uniform(30, 255), rng.uniform(30, 255));;
}
// draw original detected lines
for (int i = 0; i < linesWithoutSmall.size(); i++){
Vec4i& detectedLine = linesWithoutSmall[i];
line(detectedLinesImg,
cv::Point(detectedLine[0], detectedLine[1]),
cv::Point(detectedLine[2], detectedLine[3]), colors[labels[i]], 2);
}
// build point clouds out of each equivalence classes
std::vector<std::vector<Point2i>> pointClouds(equilavenceClassesCount);
for (int i = 0; i < linesWithoutSmall.size(); i++){
Vec4i& detectedLine = linesWithoutSmall[i];
pointClouds[labels[i]].push_back(Point2i(detectedLine[0], detectedLine[1]));
pointClouds[labels[i]].push_back(Point2i(detectedLine[2], detectedLine[3]));
}
// fit line to each equivalence class point cloud
std::vector<Vec4i> reducedLines = std::accumulate(pointClouds.begin(), pointClouds.end(), std::vector<Vec4i>{}, [](std::vector<Vec4i> target, const std::vector<Point2i>& _pointCloud){
std::vector<Point2i> pointCloud = _pointCloud;
//lineParams: [vx,vy, x0,y0]: (normalized vector, point on our contour)
// (x,y) = (x0,y0) + t*(vx,vy), t -> (-inf; inf)
Vec4f lineParams; fitLine(pointCloud, lineParams, CV_DIST_L2, 0, 0.01, 0.01);
// derive the bounding xs of point cloud
decltype(pointCloud)::iterator minXP, maxXP;
std::tie(minXP, maxXP) = std::minmax_element(pointCloud.begin(), pointCloud.end(), [](const Point2i& p1, const Point2i& p2){ return p1.x < p2.x; });
// derive y coords of fitted line
float m = lineParams[1] / lineParams[0];
int y1 = ((minXP->x - lineParams[2]) * m) + lineParams[3];
int y2 = ((maxXP->x - lineParams[2]) * m) + lineParams[3];
target.push_back(Vec4i(minXP->x, y1, maxXP->x, y2));
return target;
});
for(Vec4i reduced: reducedLines){
line(reducedLinesImg, Point(reduced[0], reduced[1]), Point(reduced[2], reduced[3]), Scalar(255, 255, 255), 2);
}
imshow("Detected Lines", detectedLinesImg);
imshow("Reduced Lines", reducedLinesImg);
waitKey();
return 0;
}

Answer 2

En primer lugar, quiero señalar que su imagen original está en un ligero ángulo, por lo que su salida esperada parece un poco desagradable para mí. Supongo que estás de acuerdo con las líneas que no son 100% verticales en tu salida porque están un poco apagadas en tu entrada.

Mat image;
Mat binary = image > 125; // Convert to binary image
// Combine similar lines
int size = 3;
Mat element = getStructuringElement( MORPH_ELLIPSE, Size( 2*size + 1, 2*size+1 ), Point( size, size ) );
morphologyEx( mask, mask, MORPH_CLOSE, element );

Hasta ahora, esto produce esta imagen:

Estas líneas no están en ángulos de 90 grados porque la imagen original no lo es.

También puede optar por cerrar la brecha entre las líneas con:

Mat out = Mat::zeros(mask.size(), mask.type());
vector<Vec4i> lines;
HoughLinesP(mask, lines, 1, CV_PI/2, 50, 50, 75);
for( size_t i = 0; i < lines.size(); i++ )
{
Vec4i l = lines[i];
line( out, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255), 5, CV_AA);
}

Si estas líneas son demasiado gordas, he tenido éxito diluyéndolas con:

size = 15;
Mat eroded;
cv::Mat erodeElement = getStructuringElement( MORPH_ELLIPSE, cv::Size( size, size ) );
erode( mask, eroded, erodeElement );

Answer 3

Le recomendaría que use HoughLines de OpenCV.

void HoughLines (imagen InputArray, líneas OutputArray, double rho, theta doble, umbral int, srn doble = 0, stn doble = 0)

Puede ajustar con rho y theta la posible orientación y posición de las líneas que desea observar. En su caso, theta = 90 ° estaría bien (solo líneas verticales y horizontales).

Después de esto, puede obtener ecuaciones de línea únicas con coordenadas de Plücker. Y a partir de ahí, puede aplicar una K-media con 3 centros que deberían ajustarse aproximadamente a sus 3 líneas en la segunda imagen.

PD: veré si puedo probar todo el proceso con tu imagen

Answer 4

Si no conoce el número de líneas en la imagen, puede usar la función cv::partition para dividir líneas en el grupo de equivalencia.

Te sugiero el siguiente procedimiento:

1. Divida sus líneas usando cv::partition . Necesita especificar una buena función de predicado. Realmente depende de las líneas que extraigas de la imagen, pero creo que debería verificar las siguientes condiciones:

   • El ángulo entre líneas debe ser bastante pequeño (menos 3 grados, por ejemplo). Use producto de puntos para calcular el coseno del ángulo.
   • La distancia entre los centros de los segmentos debe ser menor que la mitad de la longitud máxima de dos segmentos.

Por ejemplo, se puede implementar de la siguiente manera:

bool isEqual(const Vec4i& _l1, const Vec4i& _l2)
{
Vec4i l1(_l1), l2(_l2);
float length1 = sqrtf((l1[2] - l1[0])*(l1[2] - l1[0]) + (l1[3] - l1[1])*(l1[3] - l1[1]));
float length2 = sqrtf((l2[2] - l2[0])*(l2[2] - l2[0]) + (l2[3] - l2[1])*(l2[3] - l2[1]));
float product = (l1[2] - l1[0])*(l2[2] - l2[0]) + (l1[3] - l1[1])*(l2[3] - l2[1]);
if (fabs(product / (length1 * length2)) < cos(CV_PI / 30))
return false;
float mx1 = (l1[0] + l1[2]) * 0.5f;
float mx2 = (l2[0] + l2[2]) * 0.5f;
float my1 = (l1[1] + l1[3]) * 0.5f;
float my2 = (l2[1] + l2[3]) * 0.5f;
float dist = sqrtf((mx1 - mx2)*(mx1 - mx2) + (my1 - my2)*(my1 - my2));
if (dist > std::max(length1, length2) * 0.5f)
return false;
return true;
}

Supongo que tienes tus líneas en líneas vector<Vec4i> lines; . A continuación, debe llamar a cv::partition siguiente manera:

vector<Vec4i> lines;
std::vector<int> labels;
int numberOfLines = cv::partition(lines, labels, isEqual);

cv::partition llamar a cv::partition una vez y agrupará todas las líneas. Las labels vectores se almacenarán para cada etiqueta de línea del clúster al que pertenece. Ver cv::partition para cv::partition

2. Después de obtener todos los grupos de líneas, debe fusionarlos. Sugiero calcular el ángulo promedio de todas las líneas en el grupo y estimar los puntos "fronterizos". Por ejemplo, si el ángulo es cero (es decir, todas las líneas son casi horizontales) serían los puntos más a la izquierda y más a la derecha. Solo resta dibujar una línea entre estos puntos.

Noté que todas las líneas en sus ejemplos son horizontales o verticales. En tal caso, puede calcular el punto que es el promedio de todos los centros del segmento y los puntos del "borde", y luego dibujar la línea horizontal o vertical limitada por los puntos del "borde" a través del punto central.

Tenga en cuenta que la cv::partition toma O (N ^ 2) tiempo, por lo que si procesa una gran cantidad de líneas, puede tomar mucho tiempo.

Espero que ayude Usé ese enfoque para una tarea similar.