使用 C# 检测平面图中的门形状
Detect Door Shape in Floor plan using C#
我正在绘制光栅图像，所以我的目标是只检测门的形状
我正在使用 Emgu C# 并应用 Haris Corner 算法，阈值 = 50
然后检测角点矩阵然后计算两点之间的距离以近似地认为这两个点是门形状的起点和终点
问题：
我无法过滤图像以获得最佳检测效果，例如如何删除所有文本和噪音只保留粗体墙
[![在此处输入图片描述][1]][1]
[![在此处输入图片描述][2]][2]
var img = imgList["Input"].Clone();
var gray = img.Convert<Gray, byte>().ThresholdBinaryInv(new Gray(100), new Gray(100)); ;
imageBoxEx2.Image = gray.ToBitmap();
var corners = new Mat();
CvInvoke.CornerHarris(gray, corners,2);
CvInvoke.Normalize(corners, corners, 255, 0, Emgu.CV.CvEnum.NormType.MinMax);
Matrix<float> matrix = new Matrix<float>(corners.Rows, corners.Cols);
corners.CopyTo(matrix);
dt.Rows.Clear();
List<Point> LstXpoints = new List<Point>();
List<Point> LstYpoints = new List<Point>();
List<PointF> LstF = new List<PointF>();
for (int i = 0; i < matrix.Rows; i++)
{
for (int j = 0; j < matrix.Cols; j++)
{
if (matrix[i, j] > threshold)
{
LstXpoints.Add(new Point ( j, i));
LstYpoints.Add(new Point(i, j));
// CvInvoke.Circle(img, new Point(j, i), 5, new MCvScalar(0, 0, 255), 3);
}
}
}
[编辑 - 完全扩展的答案以提供完整的解决方案]
前言
我通常不会提供 "solution"，因为我觉得它远远超出了一个有用的、可重复使用的问答格式...但这是一个有趣的问题。
回答
以下详细介绍了一种基本算法，用于检测平面图中的潜在 个门开口。除了提供的单个案例之外，它没有进行性能优化或测试。由于 OP 仅将门定义为 "an opening of specified width"，因此它也容易出现错误指示。该算法只能检测原理，正交门。
示例结果：
方法
做法如下：
- 输入图像中的反转和阈值，以便将最暗的元素转换为白色（完整字节值）。
- 计算轮廓检测，以识别现在白色区域的边界。
- 仅在大于 selected 阈值的区域过滤 select 轮廓（从而去除文本元素噪声）。
- "Walk" selected 轮廓以确定 "corner" 发生的节点。角点定义为 angular 高于阈值的变化。
- 分析检测到的符合 "doors".
配对的角点
- [多余渲染] 最后，在过滤后的轮廓的矩形angular 边界内进行光栅化，以便将它们填充到合成图像中。 （注意： 这不是计算高效或优雅的，但是用于轮廓填充的 EmguCV 方法仅支持凸轮廓）。 "doors" 也呈现为红色。
算法
// Open the image
Image<Gray, byte> baseImage = new Image<Gray, byte>(@"TestLayout.jpg");
// Invert the image
Image<Gray, byte> invBaseImage = baseImage.Not();
// Threshold the image so as "close to white" is maintained, all else is black
Image<Gray, byte> blackOnlyImage = invBaseImage.ThresholdBinary(new Gray(200), new Gray(255));
// An output image of the same size to contain the walls
Image<Gray, byte> wallsOnlyImage = new Image<Gray, byte>(blackOnlyImage.Size);
// A set of dected contours
VectorOfVectorOfPoint inputContours = new VectorOfVectorOfPoint();
// A set of validated contours
List<VectorOfPoint> validContours = new List<VectorOfPoint>();
// Perform contour detection
Mat hierarchy = new Mat();
CvInvoke.FindContours(blackOnlyImage, inputContours, hierarchy, RetrType.External, ChainApproxMethod.ChainApproxSimple);
// Filter out to select only contours bounding more that 500 pixels
int areaThreshold = 500;
for (int c = 0; c < inputContours.Size; c++)
{
if (CvInvoke.ContourArea(inputContours[c]) >= areaThreshold)
{
validContours.Add(inputContours[c]);
}
}
// Find all the corner points in the valid contours
List<Point> contourCorners = new List<Point>();
foreach(VectorOfPoint contour in validContours)
{
contourCorners.AddRange(CornerWalk(contour, 80));
}
// Sort the contour corners by proximity to origin in order to optimise following loops
contourCorners.OrderBy(p => Math.Sqrt(Math.Pow(p.X, 2) + Math.Pow(p.Y, 2)));
// Extract all door candidate point pairs from all detected corners
List<Tuple<Point, Point>> doorCandidates = FindDoors(contourCorners, 2, 30, 45);
// Pixels contained within the filtered contours are walls, fill them white
RasterFill(wallsOnlyImage, validContours);
// Output Image
Image<Rgb, byte> outputImage = new Image<Rgb, byte>(wallsOnlyImage.Size);
CvInvoke.CvtColor(wallsOnlyImage, outputImage, ColorConversion.Gray2Rgb);
// Draw the doors
foreach (Tuple<Point,Point> door in doorCandidates)
{
outputImage.Draw(new LineSegment2D(door.Item1, door.Item2), new Rgb(255,0,0), 1);
}
// Display generated output and save it to file
CvInvoke.NamedWindow("TestOutput");
CvInvoke.Imshow("TestOutput", outputImage);
CvInvoke.WaitKey();
outputImage.Save(@"OutputImage.bmp");
角提取
static List<Point> CornerWalk(VectorOfPoint contour, int threshold)
{
// Create a resultant list of points
List<Point> result = new List<Point>();
// Points are used to store 2D vectors as dx,dy (i,j)
Point reverseVector, forwardVector;
double theta;
// For each point on the contour
for(int p = 1; p < contour.Size; p++)
{
// Determine the vector to the prior point
reverseVector = new Point()
{
X = contour[p].X - contour[p - 1].X,
Y = contour[p].Y - contour[p - 1].Y,
};
// Determine the vector to the next point
forwardVector = p == contour.Size - 1 ?
new Point()
{
X = contour[0].X - contour[p].X,
Y = contour[0].Y - contour[p].Y,
} :
new Point()
{
X = contour[p + 1].X - contour[p].X,
Y = contour[p + 1].Y - contour[p].Y,
};
// Compute the angular delta between the two vectors (Radians)
theta = Math.Acos(((reverseVector.X * forwardVector.X) + (reverseVector.Y * forwardVector.Y)) /
(Math.Sqrt(Math.Pow(reverseVector.X, 2) + Math.Pow(reverseVector.Y, 2)) *
Math.Sqrt(Math.Pow(forwardVector.X, 2) + Math.Pow(forwardVector.Y, 2))));
// Convert the angle to degrees
theta *= 180 / Math.PI;
// If the angle is above or equal the threshold, the point is a corner
if (theta >= threshold) result.Add(contour[p]);
}
// Return the result
return result;
}
门检测
static List<Tuple<Point, Point>> FindDoors(
List<Point> cornerPoints,
int inLineTolerance,
int minDoorWidth,
int maxDoorWidth)
{
// Create a resultant list of pairs of points
List<Tuple<Point, Point>> results = new List<Tuple<Point, Point>>();
Point p1, p2;
// For every point in the list
for (int a = 0; a < cornerPoints.Count; a++)
{
p1 = cornerPoints[a];
// Against every other point in the list
for (int b = 0; b < cornerPoints.Count; b++)
{
// Don't compare a point to it's self...
if (a == b) continue;
p2 = cornerPoints[b];
// If p1 to p2 qualifies as a door:
// Vertical Doors - A vertical door will have to points of the same X value, within tolerance, and a Y value delta within the
// min-max limits of a door width.
if (((Math.Abs(p1.X - p2.X) < inLineTolerance) && (Math.Abs(p1.Y - p2.Y) > minDoorWidth) && (Math.Abs(p1.Y - p2.Y) < maxDoorWidth)) ||
// Horizontal Doors - A horizontal door will have to points of the same Y value, within tolerance, and a X value delta within the
// min-max limits of a door width.
((Math.Abs(p1.Y - p2.Y) < inLineTolerance) && (Math.Abs(p1.X - p2.X) > minDoorWidth) && (Math.Abs(p1.X - p2.X) < maxDoorWidth)))
{
// Add the point pair to the result
results.Add(new Tuple<Point, Point>(p1, p2));
// Remove them from further consideration
cornerPoints.Remove(p1);
cornerPoints.Remove(p2);
// Decrement the looping indexes and start over with a new p1
b--; a--;
break;
}
}
}
// Finally return the result
return results;
}
轮廓填充（渲染实用程序 - 不起作用）
static void RasterFill(Image<Gray,byte> dstImg, List<VectorOfPoint> contours)
{
Rectangle contourBounds;
PointF testPoint;
// For each contour detected
foreach(VectorOfPoint contour in contours)
{
// Within the bounds of this contour
contourBounds = CvInvoke.BoundingRectangle(contour);
for (int u = contourBounds.X; u < contourBounds.X + contourBounds.Width; u++)
{
for (int v = contourBounds.Y; v < contourBounds.Y + contourBounds.Height; v++)
{
// Test to determine whether the point is within the contour
testPoint = new PointF(u, v);
// If it is inside the contour, OR on the contour
if (CvInvoke.PointPolygonTest(contour, testPoint, false) >= 0)
{
// Set it white
dstImg.Data[v, u, 0] = 255;
}
}
}
}
}
抱歉 python 代码。但这也许有助于解决您的问题。
查看评论。
import cv2
img = cv2.imread('NHoXn.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# convert to binary image
thresh=cv2.threshold(gray, 220, 255, cv2.THRESH_BINARY )[1]
# Morphological reconstruction (delete labels)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7,7))
kernel2 = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
marker = cv2.dilate(thresh,kernel,iterations = 1)
while True:
tmp=marker.copy()
marker=cv2.erode(marker, kernel2)
marker=cv2.max(thresh, marker)
difference = cv2.subtract(tmp, marker)
if cv2.countNonZero(difference) == 0:
break
# only walls
se=cv2.getStructuringElement(cv2.MORPH_RECT, (4,4))
walls=cv2.morphologyEx(marker, cv2.MORPH_CLOSE, se)
walls=cv2.erode(walls, kernel2,iterations=2)
# other objects
other=cv2.compare(marker,walls, cv2.CMP_GE)
other=cv2.bitwise_not(other)
# find connected components and select by size and area
output = cv2.connectedComponentsWithStats(other, 4, cv2.CV_32S)
num_labels = output[0]
labels = output[1]
stats=output[2]
centroids = output[3]
for i in range(num_labels):
left,top,width,height,area=stats[i]
if abs(width-40)<12 and abs(height-40)<12 and area>85:
cv2.rectangle(img,(left, top), (left+width, top+height), (0,255,0))
cv2.imwrite('doors.png', img)
结果：
- 图中显示的内容：墙壁、门、windows、家具、文字标签。
- 要找到的门总是碰壁。
- 墙壁与其他物体有何不同？粗，这些线条很粗。因此，用所需结构元件进行的扩张可以仅留下部分壁。然后，通过形态学重建，恢复墙壁以及与其相关的元素：首先是门，windows。图纸上所有不接触墙壁的东西都会被清除。
- 如果进一步进行膨胀和侵蚀，那么将只剩下墙，薄元素，如 windows 和门将消失。
- 从第三阶段减去（或逻辑运算）第四阶段我们得到一张只包含门、windows 和触及墙壁的家具的图片。
- 门的图纸和windows有什么区别？事实上，它们的 BB 几乎是方形的，图中所有门的尺寸大致相同，它们的长度大约等于 r*(1+pi/4)。
在代码中还有对此类标志的选择。在此阶段，您可以添加更多标志，以更准确地将门与其他元素分开。
我正在绘制光栅图像，所以我的目标是只检测门的形状
我正在使用 Emgu C# 并应用 Haris Corner 算法，阈值 = 50
然后检测角点矩阵然后计算两点之间的距离以近似地认为这两个点是门形状的起点和终点
问题：
我无法过滤图像以获得最佳检测效果，例如如何删除所有文本和噪音只保留粗体墙
[![在此处输入图片描述][1]][1]
[![在此处输入图片描述][2]][2]
var img = imgList["Input"].Clone();
var gray = img.Convert<Gray, byte>().ThresholdBinaryInv(new Gray(100), new Gray(100)); ;
imageBoxEx2.Image = gray.ToBitmap();
var corners = new Mat();
CvInvoke.CornerHarris(gray, corners,2);
CvInvoke.Normalize(corners, corners, 255, 0, Emgu.CV.CvEnum.NormType.MinMax);
Matrix<float> matrix = new Matrix<float>(corners.Rows, corners.Cols);
corners.CopyTo(matrix);
dt.Rows.Clear();
List<Point> LstXpoints = new List<Point>();
List<Point> LstYpoints = new List<Point>();
List<PointF> LstF = new List<PointF>();
for (int i = 0; i < matrix.Rows; i++)
{
for (int j = 0; j < matrix.Cols; j++)
{
if (matrix[i, j] > threshold)
{
LstXpoints.Add(new Point ( j, i));
LstYpoints.Add(new Point(i, j));
// CvInvoke.Circle(img, new Point(j, i), 5, new MCvScalar(0, 0, 255), 3);
}
}
}
[编辑 - 完全扩展的答案以提供完整的解决方案]
前言
我通常不会提供 "solution"，因为我觉得它远远超出了一个有用的、可重复使用的问答格式...但这是一个有趣的问题。
回答
以下详细介绍了一种基本算法，用于检测平面图中的潜在 个门开口。除了提供的单个案例之外，它没有进行性能优化或测试。由于 OP 仅将门定义为 "an opening of specified width"，因此它也容易出现错误指示。该算法只能检测原理，正交门。
示例结果：
方法
做法如下：
- 输入图像中的反转和阈值，以便将最暗的元素转换为白色（完整字节值）。
- 计算轮廓检测，以识别现在白色区域的边界。
- 仅在大于 selected 阈值的区域过滤 select 轮廓（从而去除文本元素噪声）。
- "Walk" selected 轮廓以确定 "corner" 发生的节点。角点定义为 angular 高于阈值的变化。
- 分析检测到的符合 "doors". 配对的角点
- [多余渲染] 最后，在过滤后的轮廓的矩形angular 边界内进行光栅化，以便将它们填充到合成图像中。 （注意： 这不是计算高效或优雅的，但是用于轮廓填充的 EmguCV 方法仅支持凸轮廓）。 "doors" 也呈现为红色。
算法
// Open the image
Image<Gray, byte> baseImage = new Image<Gray, byte>(@"TestLayout.jpg");
// Invert the image
Image<Gray, byte> invBaseImage = baseImage.Not();
// Threshold the image so as "close to white" is maintained, all else is black
Image<Gray, byte> blackOnlyImage = invBaseImage.ThresholdBinary(new Gray(200), new Gray(255));
// An output image of the same size to contain the walls
Image<Gray, byte> wallsOnlyImage = new Image<Gray, byte>(blackOnlyImage.Size);
// A set of dected contours
VectorOfVectorOfPoint inputContours = new VectorOfVectorOfPoint();
// A set of validated contours
List<VectorOfPoint> validContours = new List<VectorOfPoint>();
// Perform contour detection
Mat hierarchy = new Mat();
CvInvoke.FindContours(blackOnlyImage, inputContours, hierarchy, RetrType.External, ChainApproxMethod.ChainApproxSimple);
// Filter out to select only contours bounding more that 500 pixels
int areaThreshold = 500;
for (int c = 0; c < inputContours.Size; c++)
{
if (CvInvoke.ContourArea(inputContours[c]) >= areaThreshold)
{
validContours.Add(inputContours[c]);
}
}
// Find all the corner points in the valid contours
List<Point> contourCorners = new List<Point>();
foreach(VectorOfPoint contour in validContours)
{
contourCorners.AddRange(CornerWalk(contour, 80));
}
// Sort the contour corners by proximity to origin in order to optimise following loops
contourCorners.OrderBy(p => Math.Sqrt(Math.Pow(p.X, 2) + Math.Pow(p.Y, 2)));
// Extract all door candidate point pairs from all detected corners
List<Tuple<Point, Point>> doorCandidates = FindDoors(contourCorners, 2, 30, 45);
// Pixels contained within the filtered contours are walls, fill them white
RasterFill(wallsOnlyImage, validContours);
// Output Image
Image<Rgb, byte> outputImage = new Image<Rgb, byte>(wallsOnlyImage.Size);
CvInvoke.CvtColor(wallsOnlyImage, outputImage, ColorConversion.Gray2Rgb);
// Draw the doors
foreach (Tuple<Point,Point> door in doorCandidates)
{
outputImage.Draw(new LineSegment2D(door.Item1, door.Item2), new Rgb(255,0,0), 1);
}
// Display generated output and save it to file
CvInvoke.NamedWindow("TestOutput");
CvInvoke.Imshow("TestOutput", outputImage);
CvInvoke.WaitKey();
outputImage.Save(@"OutputImage.bmp");
角提取
static List<Point> CornerWalk(VectorOfPoint contour, int threshold)
{
// Create a resultant list of points
List<Point> result = new List<Point>();
// Points are used to store 2D vectors as dx,dy (i,j)
Point reverseVector, forwardVector;
double theta;
// For each point on the contour
for(int p = 1; p < contour.Size; p++)
{
// Determine the vector to the prior point
reverseVector = new Point()
{
X = contour[p].X - contour[p - 1].X,
Y = contour[p].Y - contour[p - 1].Y,
};
// Determine the vector to the next point
forwardVector = p == contour.Size - 1 ?
new Point()
{
X = contour[0].X - contour[p].X,
Y = contour[0].Y - contour[p].Y,
} :
new Point()
{
X = contour[p + 1].X - contour[p].X,
Y = contour[p + 1].Y - contour[p].Y,
};
// Compute the angular delta between the two vectors (Radians)
theta = Math.Acos(((reverseVector.X * forwardVector.X) + (reverseVector.Y * forwardVector.Y)) /
(Math.Sqrt(Math.Pow(reverseVector.X, 2) + Math.Pow(reverseVector.Y, 2)) *
Math.Sqrt(Math.Pow(forwardVector.X, 2) + Math.Pow(forwardVector.Y, 2))));
// Convert the angle to degrees
theta *= 180 / Math.PI;
// If the angle is above or equal the threshold, the point is a corner
if (theta >= threshold) result.Add(contour[p]);
}
// Return the result
return result;
}
门检测
static List<Tuple<Point, Point>> FindDoors(
List<Point> cornerPoints,
int inLineTolerance,
int minDoorWidth,
int maxDoorWidth)
{
// Create a resultant list of pairs of points
List<Tuple<Point, Point>> results = new List<Tuple<Point, Point>>();
Point p1, p2;
// For every point in the list
for (int a = 0; a < cornerPoints.Count; a++)
{
p1 = cornerPoints[a];
// Against every other point in the list
for (int b = 0; b < cornerPoints.Count; b++)
{
// Don't compare a point to it's self...
if (a == b) continue;
p2 = cornerPoints[b];
// If p1 to p2 qualifies as a door:
// Vertical Doors - A vertical door will have to points of the same X value, within tolerance, and a Y value delta within the
// min-max limits of a door width.
if (((Math.Abs(p1.X - p2.X) < inLineTolerance) && (Math.Abs(p1.Y - p2.Y) > minDoorWidth) && (Math.Abs(p1.Y - p2.Y) < maxDoorWidth)) ||
// Horizontal Doors - A horizontal door will have to points of the same Y value, within tolerance, and a X value delta within the
// min-max limits of a door width.
((Math.Abs(p1.Y - p2.Y) < inLineTolerance) && (Math.Abs(p1.X - p2.X) > minDoorWidth) && (Math.Abs(p1.X - p2.X) < maxDoorWidth)))
{
// Add the point pair to the result
results.Add(new Tuple<Point, Point>(p1, p2));
// Remove them from further consideration
cornerPoints.Remove(p1);
cornerPoints.Remove(p2);
// Decrement the looping indexes and start over with a new p1
b--; a--;
break;
}
}
}
// Finally return the result
return results;
}
轮廓填充（渲染实用程序 - 不起作用）
static void RasterFill(Image<Gray,byte> dstImg, List<VectorOfPoint> contours)
{
Rectangle contourBounds;
PointF testPoint;
// For each contour detected
foreach(VectorOfPoint contour in contours)
{
// Within the bounds of this contour
contourBounds = CvInvoke.BoundingRectangle(contour);
for (int u = contourBounds.X; u < contourBounds.X + contourBounds.Width; u++)
{
for (int v = contourBounds.Y; v < contourBounds.Y + contourBounds.Height; v++)
{
// Test to determine whether the point is within the contour
testPoint = new PointF(u, v);
// If it is inside the contour, OR on the contour
if (CvInvoke.PointPolygonTest(contour, testPoint, false) >= 0)
{
// Set it white
dstImg.Data[v, u, 0] = 255;
}
}
}
}
}
抱歉 python 代码。但这也许有助于解决您的问题。 查看评论。
import cv2
img = cv2.imread('NHoXn.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# convert to binary image
thresh=cv2.threshold(gray, 220, 255, cv2.THRESH_BINARY )[1]
# Morphological reconstruction (delete labels)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7,7))
kernel2 = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
marker = cv2.dilate(thresh,kernel,iterations = 1)
while True:
tmp=marker.copy()
marker=cv2.erode(marker, kernel2)
marker=cv2.max(thresh, marker)
difference = cv2.subtract(tmp, marker)
if cv2.countNonZero(difference) == 0:
break
# only walls
se=cv2.getStructuringElement(cv2.MORPH_RECT, (4,4))
walls=cv2.morphologyEx(marker, cv2.MORPH_CLOSE, se)
walls=cv2.erode(walls, kernel2,iterations=2)
# other objects
other=cv2.compare(marker,walls, cv2.CMP_GE)
other=cv2.bitwise_not(other)
# find connected components and select by size and area
output = cv2.connectedComponentsWithStats(other, 4, cv2.CV_32S)
num_labels = output[0]
labels = output[1]
stats=output[2]
centroids = output[3]
for i in range(num_labels):
left,top,width,height,area=stats[i]
if abs(width-40)<12 and abs(height-40)<12 and area>85:
cv2.rectangle(img,(left, top), (left+width, top+height), (0,255,0))
cv2.imwrite('doors.png', img)
结果：
- 图中显示的内容：墙壁、门、windows、家具、文字标签。
- 要找到的门总是碰壁。
- 墙壁与其他物体有何不同？粗，这些线条很粗。因此，用所需结构元件进行的扩张可以仅留下部分壁。然后，通过形态学重建，恢复墙壁以及与其相关的元素：首先是门，windows。图纸上所有不接触墙壁的东西都会被清除。
- 如果进一步进行膨胀和侵蚀，那么将只剩下墙，薄元素，如 windows 和门将消失。
- 从第三阶段减去（或逻辑运算）第四阶段我们得到一张只包含门、windows 和触及墙壁的家具的图片。
- 门的图纸和windows有什么区别？事实上，它们的 BB 几乎是方形的，图中所有门的尺寸大致相同，它们的长度大约等于 r*(1+pi/4)。 在代码中还有对此类标志的选择。在此阶段，您可以添加更多标志，以更准确地将门与其他元素分开。