zqjia
/
Semantic-Postprocess
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Semantic-Postprocess/main.py

1388 lines
54 KiB
Python
Raw Normal View History

上传文件至 /
2024-06-11 19:07:52 +08:00
import copy
import math
import cv2
import numpy as np
from matplotlib import pyplot
from numpy import where, mean
from scipy import optimize
from skimage import morphology
from sklearn.cluster import OPTICS
from config import opt
# 图片预处理
def process_map(img, opt):
def get_wall_area(map, area):
'''
. map 获取墙壁的图像
. stats 连通域信息
. area 面积
'''
map_ = copy.copy(map)
map_[map != 255] = 0
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(map_, connectivity=8)
temp = []
for i in range(1, num_labels):
if stats[i, 4] > area:
temp.append(i)
wall_area = np.zeros((map.shape[0], map.shape[1]), np.uint8)
for i in range(0, len(temp)):
mask = labels == temp[i]
wall_area[:, :][mask] = 255
return wall_area
def get_NONwall_area(map, stats, area, num_labels, labels):
'''
. map 获取墙壁的图像
. stats 连通域信息
. area 面积
'''
temp = []
for i in range(1, num_labels):
mask = labels == i
if stats[i, 4] < area:
temp.append(i)
elif np.max(map[:, :][mask]) in Intensity_value:
temp.append(i)
NONwall_area = np.zeros((map.shape[0], map.shape[1]), np.uint8)
for i in range(0, len(temp)):
mask = labels == temp[i]
NONwall_area[:, :][mask] = 255
return NONwall_area
def get_rotate_angle(wall_area, length, opt):
temp = copy.copy(wall_area)
# temp = cv2.pyrUp(temp)
# temp = cv2.pyrUp(temp)
edges = cv2.Canny(temp, 50, 150, apertureSize=5)
lines = cv2.HoughLines(edges, 1, np.pi / 180, length)
# if (lines == None):
# return wall_area
temp = np.zeros((wall_area.shape[0], wall_area.shape[1]))
np.zeros((wall_area.shape[0], wall_area.shape[1]))
alfa = 0
theta_temp = [0]
for line in lines:
n = 0
rho = line[0][0]
theta = line[0][1]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
# alfa = alfa + np.mod(theta, 90 / 360 * np.pi)
# alfa = theta
theta_array = np.array(theta_temp)
n = 0
for i in range(theta_array.shape[0]):
x = np.abs(theta - theta_array[i])
if (0 < x < 0.15 * np.pi):
n = 1
break
if (n == 1):
continue
theta_temp.append(theta)
wall_area = rotate_bound(wall_area, -np.mod(theta, 180 / 360 * np.pi) / np.pi * 180) # 摆正图像
temp = rotate_bound(temp, -np.mod(theta, 180 / 360 * np.pi) / np.pi * 180) # 摆正图像
# wall_area_ = cv2.dilate(wall_area_, kernel) # 腐蚀膨胀，去除墙上语义点
temp_ = connect_door(wall_area, opt.k, opt.m) # 封闭区域
temp[temp_ > 0] = 0
temp = temp_ + temp
wall_area = rotate_bound(wall_area, np.mod(theta, 180 / 360 * np.pi) / np.pi * 180)
temp = rotate_bound(temp, np.mod(theta, 180 / 360 * np.pi) / np.pi * 180)
wall_area[temp > 0] = 255
return wall_area
def rotate_bound(image, angle):
'''
. 旋转图片
. @param image opencv读取后的图像
. @param angle (逆)旋转角度
'''
# img = cv2.imread("img/1.jpg")
(h, w) = image.shape[:2] # 返回(高,宽,色彩通道数),此处取前两个值返回
# 抓取旋转矩阵(应用角度的负值顺时针旋转)。参数1为旋转中心点;参数2为旋转角度,正的值表示逆时针旋转;参数3为各向同性的比例因子
M = cv2.getRotationMatrix2D((w / 2, h / 2), -angle, 1.0)
# 计算图像的新边界维数
# 调整旋转矩阵以考虑平移
# 执行实际的旋转并返回图像
return cv2.warpAffine(image, M, (image.shape[1], image.shape[0])) # borderValue 缺省，默认是黑色
# return M
def get_map(img, ratio):
"""
:param img:
:param ratio: 获取地图，2表示有效面积的2倍
:return:
"""
ratio = (ratio - 1) / 2
# b = np.nonzero(img)
# x_min = np.min(b[0])
# y_min = np.min(b[1])
# x_max = np.max(b[0])
# y_max = np.max(b[1])
# x_l = x_max - x_min
# y_l = y_max - y_min
# if x_l < 150:
# ratio = ratio + 0.5
# map = np.zeros((x_max - x_min, y_max - y_min))
# temp = img[int(max(x_min - ratio * x_l, 0)):int(min(x_max + x_l * ratio, img.shape[1])),
# int(max(0, y_min - ratio * y_l)):int(min(img.shape[0], ratio * y_l + y_max))]
'''
去掉未占用区域
'''
temp_x = np.zeros((img.shape[0], 50), np.uint8)
map = np.hstack((temp_x, img))
temp_y = np.zeros((50, map.shape[1]), np.uint8)
map = np.vstack((temp_y, map))
# map = np.zeros((img.shape[0], 50), np.uint8)
temp_x = np.zeros((map.shape[0], 40), np.uint8)
map = np.hstack((map, temp_x))
temp_y = np.zeros((40, map.shape[1]), np.uint8)
map = np.vstack((map, temp_y))
# map = copy.copy(img)
map[map < 70] = 255
map[map <= 100] = 0
map[map == 0] = 1
map[map == 255] = 0
map[map == 1] = 255
"墙壁灰度值为1"
return map
def draw_rgb(map):
def rgb_semantics(number):
output = np.array((5, 5, 5), np.uint8)
if number == 115:
'0号物体'
output[0] = 232
output[1] = 221
output[2] = 203
elif number == 116:
'1号物体'
output[0] = 205
output[1] = 179
output[2] = 128
elif number == 117:
'2号物体'
output[0] = 3
output[1] = 101
output[2] = 100
elif number == 118:
'3号物体'
output[0] = 3
output[1] = 54
output[2] = 73
elif number == 119:
'4号物体'
output[0] = 3
output[1] = 22
output[2] = 52
elif number == 120:
'5号物体'
output[0] = 237
output[1] = 222
output[2] = 139
elif number == 121:
'6号物体'
output[0] = 251
output[1] = 178
output[2] = 23
elif number == 150:
'7号物体'
output[0] = 96
output[1] = 143
output[2] = 159
elif number == 151:
'8号物体'
output[0] = 1
output[1] = 77
output[2] = 103
elif number == 152:
'9号物体'
output[0] = 254
output[1] = 67
output[2] = 101
elif number == 153:
'10号物'
output[0] = 252
output[1] = 157
output[2] = 154
elif number == 154:
'11号物体'
output[0] = 249
output[1] = 205
output[2] = 173
elif number == 155:
'12号物体'
output[0] = 200
output[1] = 200
output[2] = 169
elif number == 156:
'13号物体'
output[0] = 131
output[1] = 175
output[2] = 155
elif number == 200:
'14号物体'
output[0] = 229
output[1] = 187
output[2] = 129
elif number == 201:
'15号物体'
output[0] = 161
output[1] = 23
output[2] = 21
elif number == 202:
'16号物体'
output[0] = 118
output[1] = 77
output[2] = 57
elif number == 203:
'17号物体'
output[0] = 17
output[1] = 63
output[2] = 61
elif number == 204:
'18号物体'
output[0] = 60
output[1] = 79
output[2] = 57
elif number == 205:
'19号物体'
output[0] = 95
output[1] = 92
output[2] = 51
elif number == 206:
'20号物体'
output[0] = 179
output[1] = 214
output[2] = 110
elif number == 207:
'21号物体'
output[0] = 227
output[1] = 160
output[2] = 93
elif number == 208:
'22号物体'
output[0] = 178
output[1] = 190
output[2] = 126
elif number == 209:
'23号物体'
output[0] = 56
output[1] = 13
output[2] = 49
else:
output[0] = 5
output[1] = 5
output[2] = 5
return output
output = np.zeros((map.shape[0], map.shape[1], 3), np.uint8)
output_b = copy.copy(map)
output_g = copy.copy(map)
output_r = copy.copy(map)
for i in range(np.array(Intensity_value).shape[0]):
intensity = Intensity_value[i]
output_r[map == intensity] = rgb_semantics(intensity)[0]
output_g[map == intensity] = rgb_semantics(intensity)[1]
output_b[map == intensity] = rgb_semantics(intensity)[2]
output[:, :, 0] = output_b
output[:, :, 1] = output_g
output[:, :, 2] = output_r
return output
# 行扫描，间隔k时，进行填充，填充值为1
# 将门口连起来
def connect_door(wall_area, k, m):
"""
:param wall_area:
:param k: 门宽
:param m: 墙壁长度
:return:
"""
def edge_connection(img, size, k, m):
for i in range(size):
Yi = np.where(img[i, :] > 220)
if len(Yi[0]) >= m: # 可调整 (墙壁长度)
for j in range(0, len(Yi[0]) - 1):
if Yi[0][j + 1] - Yi[0][j] <= k:
# img[min(i - 1, img.shape[0] - 1), Yi[0][j]:Yi[0][j + 1]] = 255
img[min(i, img.shape[0] - 1), Yi[0][j]:Yi[0][j + 1]] = 255
# img[i, Yi[0][j]:Yi[0][j + 1]] = 255
# img[min(i + 1, img.shape[0]-1), Yi[0][j]:Yi[0][j + 1]] = 255
return img
img = copy.copy(wall_area)
g = edge_connection(img, img.shape[0], k, m) # k设的是门的宽度, m是判为墙壁的长度
g = cv2.rotate(g, 0)
g = edge_connection(g, img.shape[1], k, m)
g = cv2.rotate(g, 2)
g = g.astype(np.uint8)
return g
'''
用于绘制地图及物体形状绘制
'''
'定义语义强度'
Intensity_value = [115, 116, 117, 118, 119, 120, 121, 150, 151, 152, 153,
154, 155, 156, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209]
# Intensity_value = [153]
map = get_map(img, 4)
'插值处理，提高分辨率'
map = cv2.resize(map, (map.shape[1] * 2, map.shape[0] * 2), interpolation=cv2.INTER_NEAREST)
map_ori = copy.copy(map)
wall_area = get_wall_area(map, opt.acreage) # 获取墙壁区域
NON_wall_area = map - wall_area
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
wall_area = cv2.dilate(wall_area, kernel)
connect_line = get_rotate_angle(wall_area, opt.length, opt) # 连接
connect_line = cv2.erode(connect_line, kernel, iterations=3)
connect_line[connect_line < 150] = 0
connect_line[connect_line > 0] = 255
temp1 = copy.copy(connect_line)
temp2 = copy.copy(NON_wall_area)
temp1[temp1 > 0] = 1
temp = temp1 * temp2
NON_wall_area[temp != 0] = 0
result = connect_line + NON_wall_area
result[result > 255] = 255
result = result.astype(np.uint8)
result[result == 0] = 254
result[result == 255] = 0
result[result == 254] = 255
# cv2.imwrite("result.png", result)
'''
用于提取区域
'''
map_ = copy.copy(map) # 用于封闭区域
map_[map_ > 0] = 255
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(map_, connectivity=8)
wall_area_ = get_wall_area(map_, opt.acreage) # 获取墙壁区域
NON_wall_area_ = map_ - wall_area_
wall_area_ = cv2.dilate(wall_area_, kernel)
connect_line_ = get_rotate_angle(wall_area_, opt.length, opt) # 连接
connect_line_[connect_line_ < 150] = 0
connect_line_[connect_line_ > 0] = 255
temp1_ = copy.copy(connect_line_)
temp2_ = copy.copy(NON_wall_area_)
temp1_[temp1_ > 0] = 1
temp_ = temp1_ * temp2_
NON_wall_area[temp_ != 0] = 0
result_ = connect_line_ + NON_wall_area_
result_[result_ > 255] = 255
result_ = result_.astype(np.uint8)
result_[result_ == 0] = 254
result_[result_ == 255] = 0
result_[result_ == 254] = 255
# wall_area_ = rotate_bound(wall_area, -alfa / np.pi * 180) # 摆正图像
# # wall_area_ = cv2.dilate(wall_area_, kernel) # 腐蚀膨胀，去除墙上语义点
#
# connect_line = connect_door(wall_area_, opt.k, opt.m) # 封闭区域
# connect_line_ = rotate_bound(connect_line, alfa / np.pi * 180)
map_ori[map_ori == 0] = 254
map_ori[map_ori == 255] = 0
map_ori[map_ori == 254] = 255
return result, result_, map_ori
# 绘制物体形状
def obj_outline(map, opt, map_ori):
'''
. 绘制物体形状
. @param map 语义地图
. @param Semantic_map 场景分类图
. @param opt 参数
'''
def rotate_bound(image, angle):
'''
. 旋转图片
. @param image opencv读取后的图像
. @param angle (逆)旋转角度
'''
# img = cv2.imread("img/1.jpg")
(h, w) = image.shape[:2] # 返回(高,宽,色彩通道数),此处取前两个值返回
# 抓取旋转矩阵(应用角度的负值顺时针旋转)。参数1为旋转中心点;参数2为旋转角度,正的值表示逆时针旋转;参数3为各向同性的比例因子
M = cv2.getRotationMatrix2D((w / 2, h / 2), -angle, 1.0)
# 计算图像的新边界维数
# 调整旋转矩阵以考虑平移
# 执行实际的旋转并返回图像
return cv2.warpAffine(image, M, (image.shape[1], image.shape[0])) # borderValue 缺省，默认是黑色
# return M
# 根据不同语义物体得到不同参数
def get_parameter(item, opt):
'''
. 得到物体参数
. @param item 物体的强度值
. @param opt 物体参数
'''
if (item == 115):
min_samples = opt.min_samples_115
max_eps = opt.max_eps_115
shape = opt.shape_115 # 0是圆形，1是矩形
size = opt.size_115 # 0是按轮廓，1是直接画正矩形
color = [232, 221, 203]
filter_point_num = 0
elif (item == 116):
min_samples = opt.min_samples_116
max_eps = opt.max_eps_116
shape = opt.shape_116 # 0是圆形，1是矩形
size = opt.size_116 # 0是按轮廓，1是直接画正矩形
color = [205, 179, 128]
filter_point_num = 0
elif (item == 117):
min_samples = opt.min_samples_117
max_eps = opt.max_eps_117
shape = opt.shape_117 # 0是圆形，1是矩形
size = opt.size_117 # 0是按轮廓，1是直接画正矩形
color = [3, 101, 100]
filter_point_num = 0
elif (item == 118):
min_samples = opt.min_samples_118
max_eps = opt.max_eps_118
shape = opt.shape_118 # 0是圆形，1是矩形
size = opt.size_118 # 0是按轮廓，1是直接画正矩形
color = [3, 54, 73]
filter_point_num = 0
elif (item == 119):
min_samples = opt.min_samples_119
max_eps = opt.max_eps_119
shape = opt.shape_119 # 0是圆形，1是矩形
size = opt.size_119 # 0是按轮廓，1是直接画正矩形
color = [3, 22, 52]
filter_point_num = 0
elif (item == 120):
min_samples = opt.min_samples_120
max_eps = opt.max_eps_120
shape = opt.shape_120 # 0是圆形，1是矩形
size = opt.size_120 # 0是按轮廓，1是直接画正矩形
color = [237, 22, 139]
filter_point_num = 0
elif (item == 121):
min_samples = opt.min_samples_121
max_eps = opt.max_eps_121
shape = opt.shape_121 # 0是圆形，1是矩形
size = opt.size_121 # 0是按轮廓，1是直接画正矩形
color = [251, 178, 23]
filter_point_num = 0
elif (item == 150):
min_samples = opt.min_samples_150
max_eps = opt.max_eps_150
shape = opt.shape_150 # 0是圆形，1是矩形
size = opt.size_150 # 0是按轮廓，1是直接画正矩形
color = [96, 143, 159]
filter_point_num = 0
elif (item == 151):
min_samples = opt.min_samples_151
max_eps = opt.max_eps_151
shape = opt.shape_151 # 0是圆形，1是矩形
size = opt.size_151 # 0是按轮廓，1是直接画正矩形
color = [1, 77, 103]
filter_point_num = 0
elif (item == 152):
min_samples = opt.min_samples_152
max_eps = opt.max_eps_152
shape = opt.shape_152 # 0是圆形，1是矩形
size = opt.size_152 # 0是按轮廓，1是直接画正矩形
color = [254, 67, 101]
filter_point_num = 0
elif (item == 153):
min_samples = opt.min_samples_153
max_eps = opt.max_eps_153
shape = opt.shape_153 # 0是圆形，1是矩形
size = opt.size_153 # 0是按轮廓，1是直接画正矩形
color = [252, 157, 154]
filter_point_num = 0
elif (item == 154):
min_samples = opt.min_samples_154
max_eps = opt.max_eps_154
shape = opt.shape_154 # 0是圆形，1是矩形
size = opt.size_154 # 0是按轮廓，1是直接画正矩形
color = [249, 205, 173]
filter_point_num = 0
elif (item == 155):
min_samples = opt.min_samples_155
max_eps = opt.max_eps_155
shape = opt.shape_155 # 0是圆形，1是矩形
size = opt.size_155 # 0是按轮廓，1是直接画正矩形
color = [200, 200, 169]
filter_point_num = 0
elif (item == 156):
min_samples = opt.min_samples_156
max_eps = opt.max_eps_156
shape = opt.shape_156 # 0是圆形，1是矩形
size = opt.size_156 # 0是按轮廓，1是直接画正矩形
color = [131, 175, 155]
filter_point_num = 0
elif (item == 200):
min_samples = opt.min_samples_200
max_eps = opt.max_eps_200
shape = opt.shape_200 # 0是圆形，1是矩形
size = opt.size_200 # 0是按轮廓，1是直接画正矩形
color = [229, 187, 129]
filter_point_num = 0
elif (item == 201):
min_samples = opt.min_samples_201
max_eps = opt.max_eps_201
shape = opt.shape_201 # 0是圆形，1是矩形
size = opt.size_201 # 0是按轮廓，1是直接画正矩形
color = [161, 23, 21]
filter_point_num = 0
elif (item == 202):
min_samples = opt.min_samples_202
max_eps = opt.max_eps_202
shape = opt.shape_202 # 0是圆形，1是矩形
size = opt.size_202 # 0是按轮廓，1是直接画正矩形
color = [118, 77, 57]
filter_point_num = 0
elif (item == 203):
min_samples = opt.min_samples_203
max_eps = opt.max_eps_203
shape = opt.shape_203 # 0是圆形，1是矩形
size = opt.size_203 # 0是按轮廓，1是直接画正矩形
color = [17, 63, 61]
filter_point_num = 0
elif (item == 204):
min_samples = opt.min_samples_204
max_eps = opt.max_eps_204
shape = opt.shape_204 # 0是圆形，1是矩形
size = opt.size_204 # 0是按轮廓，1是直接画正矩形
color = [60, 79, 57]
filter_point_num = 0
elif (item == 205):
min_samples = opt.min_samples_205
max_eps = opt.max_eps_205
shape = opt.shape_205 # 0是圆形，1是矩形
size = opt.size_205 # 0是按轮廓，1是直接画正矩形
color = [95, 92, 51]
filter_point_num = 0
elif (item == 209):
min_samples = opt.min_samples_209
max_eps = opt.max_eps_209
shape = opt.shape_209 # 0是圆形，1是矩形
size = opt.size_209 # 0是按轮廓，1是直接画正矩形
color = [56, 13, 49]
filter_point_num = 0
return min_samples, max_eps, shape, size, color, filter_point_num
def filter_point(X, filter_point_num):
obj_collect = np.zeros((map.shape[0], map.shape[1]), np.uint8)
row = X[:, 0].astype(int)
col = X[:, 1].astype(int)
obj_collect[row, col] = 1
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(obj_collect, connectivity=8)
if (item == 204):
for i in range(num_labels):
if (stats[i, 4] <= filter_point_num):
mask = labels == i
obj_collect[:, :][mask] = 0
y, x = np.where(obj_collect == 1) # y是行，x是列
X = np.zeros((x.shape[0], 2))
X[:, 0] = y
X[:, 1] = x
return X
# 画物体轮廓
def draw_outline(X, item, min_samples, max_eps, shape, color, size, filter_point_num, output):
'''
. 得到物体参数
. @param X 语义物体的行列坐标
. @param item 语义物体的强度值
. @param min_samples 聚类的最小样本数
. @param max_eps 聚类的最大半径
. @param shape 语义物体绘制形状参数（ 0代表绘制圆形，1代表绘制矩形）
. @param color 语义物体的色彩
. @param size 语义物体绘制轮廓的参数（0代表按轮廓绘制，1代表绘制正矩形）
. @param output 已经绘制过某个物体形状的 map图片
'''
# 聚类（OPTICS算法）
# X = X.astype(np.uint8)
yhat = OPTICS(min_samples=min_samples, max_eps=max_eps, cluster_method='dbscan').fit_predict(X)
# 检索唯一群集
clusters = np.unique(yhat)
'''
画散点图
为每个群集的样本创建散点图
'''
# for cluster in clusters: # 获取此群集的示例的行索引
# row_ix = where(yhat == cluster) # 创建这些样本的散布
# pyplot.scatter(X[row_ix, 0], X[row_ix, 1]) # 绘制散点图
# pyplot.show()
'''
找最小外接矩形 (绘制形状)
'''
color = color[::-1]
for cluster in clusters:
n = 0
# 获取此群集的示例的行索引，将每个物体从map中提取出来
if (cluster == -1):
n = 1
continue
row_ix = where(yhat == cluster)
if row_ix[0].shape[0] <= 1:
continue
obj = np.zeros((map.shape[0], map.shape[1]), np.uint8)
row = X[row_ix, 0].astype(int)
col = X[row_ix, 1].astype(int)
obj[row, col] = 1
if (item == 118 or item == 119 or item == 153 or item == 202):
# if (item == 899):
skeleton0 = morphology.skeletonize(obj)
skeleton = skeleton0.astype(np.uint8) * 255
temps = copy.copy(skeleton)
temp_outline = np.zeros((output.shape[0], output.shape[1], 3), np.uint8)
for i in range(60, 0,-1):
lines = cv2.HoughLines(skeleton, 1, np.pi / 180, i)
if (lines is not None):
if lines.shape[0] >0:
break
if (lines is None):
n = 1
continue
alfa = 0
for line in lines:
rho = line[0][0]
theta = line[0][1]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
theta = np.mod(theta, 90 / 180 * np.pi)
if (theta > 45 / 180 * np.pi):
theta = abs(theta - 90 / 180 * np.pi)
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
# cv2.line(temps, (x1, y1), (x2, y2), 255, 2)
alfa = theta + alfa
alfa = alfa / lines.shape[0]
skeleton = rotate_bound(skeleton, np.mod(alfa, 90 / 180 * np.pi) / np.pi * 180) # 摆正图像 角度为正值的时候，是顺时针旋转
skeleton_ = copy.copy(skeleton)
# skeleton_[skeleton_ != 0] = 9
skeleton_ = (skeleton_ / 255 * 9).astype(np.uint8)
# output = rotate_bound(output, -np.mod(alfa, 90 / 360 * np.pi) / np.pi * 180)
img_blur = cv2.blur(copy.copy(skeleton_), (3, 3))
# img_blur = img_blur * 9
img_blur[img_blur != 2] = 0
img_blur[img_blur == 2] = 255
# img_blur[img_blur == 2] = 255
# img_blur[img_blur != 255] = 0
img_blur[skeleton == 0] = 0
corners = np.where(img_blur != 0)
corners = np.array(corners)
#
corners = cv2.goodFeaturesToTrack(skeleton, 50, 0.1, 10)
corners = np.int0(corners)
temp_x = []
temp_y = []
for i in corners:
x, y = i.ravel() # x是行，y是列
temp_x.append(x)
temp_y.append(y)
temp_X = np.array(temp_x)
temp_Y = np.array(temp_y)
a = np.min(temp_X)
b = np.min(temp_Y)
c = np.max(temp_X)
d = np.max(temp_Y)
cv2.rectangle(temp_outline, (a, b), (c, d), color, -1)
temp_outline = rotate_bound(temp_outline, -np.mod(alfa, 90 / 180 * np.pi) / np.pi * 180)
temp = cv2.cvtColor(temp_outline, cv2.COLOR_BGR2GRAY) # 方便用mask
temp[temp > 0] = 255
output[temp_outline > 0] = 0
mask = 255 == temp
output[:, :, 0][mask] = color[0]
output[:, :, 1][mask] = color[1]
output[:, :, 2][mask] = color[2]
continue
if (shape == 1):
# 计算外接矩形
box = outer_rectangle(obj, size)
# color = color[::-1]
# 画图
if (size == 0):
# 外接矩形缩放
# vertices = shrink_rectangle(box)
vertices = box
output = cv2.drawContours(output, [vertices], 0, color, -1, lineType=cv2.LINE_4)
elif (size == 1):
# 外接矩形缩放
# vertices = shrink_rectangle(box)
vertices = box
cv2.rectangle(output, (vertices[0, 0], vertices[0, 1]), (vertices[2, 0], vertices[2, 1]), color, -1)
elif (shape == 0):
# 计算最小拟合圆
circle_x = col
circle_y = row
center, radius = fit_circle(circle_x, circle_y)
# binary, contours, hierarchy = cv2.findContours(obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# center, radius = outer_circle(obj)
cv2.circle(output, center, radius, color, -1)
# else:
# ellipse = outer_ellipse(obj)
# if (len(ellipse) != 0):
# cv2.ellipse(output, ellipse, color, -1)
return output, n
# 计算最小外接矩形
def outer_rectangle(obj, size):
'''
. 计算最小外接矩形
. @param obj 语义物体的位置信息
. @param size 语义物体绘制轮廓的参数（0代表按轮廓绘制，1代表绘制正矩形）
'''
binary, contours, hierarchy = cv2.findContours(obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contour = []
for cont in contours:
contour.extend(cont)
if (size == 0):
min_rect = cv2.minAreaRect(np.array(contour))
box = cv2.boxPoints(min_rect)
# box = np.round(box)
box = np.int0(box)
# 排序
temp = np.where(box == np.min(box[:, 0])) # box的第0列是列，第1列是行
if temp[0].shape[0] > 1:
left = np.min(box[:, 0])
right = np.max(box[:, 0])
up = np.min(box[:, 1])
down = np.max(box[:, 1])
top_point_x = left
top_point_y = up
right_point_x = right
right_point_y = up
bottom_point_x = right
bottom_point_y = down
left_point_x = left
left_point_y = down
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
return vertices
left_point_x = np.min(box[:, 0])
right_point_x = np.max(box[:, 0])
top_point_y = np.min(box[:, 1])
bottom_point_y = np.max(box[:, 1])
left_point_y = box[:, 1][np.where(box[:, 0] == left_point_x)][0]
right_point_y = box[:, 1][np.where(box[:, 0] == right_point_x)][0]
top_point_x = box[:, 0][np.where(box[:, 1] == top_point_y)][0]
bottom_point_x = box[:, 0][np.where(box[:, 1] == bottom_point_y)][0]
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
return vertices
elif (size == 1):
x, y, w, h = cv2.boundingRect(np.array(contour))
vertices = np.array([[x, y], [x + w, y], [x + w, y + h],
[x, y + h]])
return vertices
# 计算最小拟合椭圆
def outer_ellipse(obj):
'''
. 计算最小拟合椭圆
. @param obj 语义物体的位置信息
'''
binary, contours, hierarchy = cv2.findContours(obj, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contour = []
for cont in contours:
contour.extend(cont)
if (len(contour) < 6):
ellipse = ()
else:
ellipse = cv2.fitEllipse(np.array(contour))
return ellipse
# 计算最小外接圆
def outer_circle(obj):
'''
. 计算最小外接圆
. @param obj 语义物体的位置信息
'''
binary, contours, hierarchy = cv2.findContours(obj, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contour = []
for cont in contours:
contour.extend(cont)
(x, y), radius = cv2.minEnclosingCircle(np.array(contour))
center = (int(round(x)), int(round(y)))
radius = int(round(radius))
return center, radius
# 计算最小拟合圆
def calc_R(xc, yc, x, y):
return np.sqrt((x - xc) ** 2 + (y - yc) ** 2)
def f_2(c, x, y):
Ri = calc_R(*c, x, y)
return Ri - Ri.mean()
def fit_circle(x, y):
'''
. 计算最小外接圆
. @param x 语义物体的所在列
. @param x 语义物体的所在行
'''
x_m = mean(x)
y_m = mean(y)
x = x.ravel()
y = y.ravel()
center_estimate = x_m, y_m
center_2, _ = optimize.leastsq(f_2, center_estimate, args=(x, y))
xc_2, yc_2 = center_2
Ri_2 = calc_R(xc_2, yc_2, x, y)
# 拟合圆的半径
R_2 = Ri_2.mean()
center = (int(round(xc_2)), int(round(yc_2)))
radius = int(round(R_2))
return center, radius
# 外接矩形内缩
def shrink_rectangle(box):
'''
. 外接矩形内缩
. @param box 语义物体的轮廓信息
'''
temp = np.where(box == np.min(box[:, 0])) # box的第0列是列，第1列是行
if temp[0].shape[0] > 1:
left = np.min(box[:, 0])
right = np.max(box[:, 0])
up = np.min(box[:, 1])
down = np.max(box[:, 1])
top_point_x = left + 1
top_point_y = up + 1
right_point_x = right - 1
right_point_y = up + 1
bottom_point_x = right - 1
bottom_point_y = down - 1
left_point_x = left + 1
left_point_y = down - 1
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
return vertices
left_point_x = np.min(box[:, 0])
right_point_x = np.max(box[:, 0])
top_point_y = np.min(box[:, 1])
bottom_point_y = np.max(box[:, 1])
left_point_y = box[:, 1][np.where(box[:, 0] == left_point_x)][0]
right_point_y = box[:, 1][np.where(box[:, 0] == right_point_x)][0]
top_point_x = box[:, 0][np.where(box[:, 1] == top_point_y)][0]
bottom_point_x = box[:, 0][np.where(box[:, 1] == bottom_point_y)][0]
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
if top_point_x > bottom_point_x:
vertices[0, 0] = vertices[0, 0] - 1
vertices[0, 1] = vertices[0, 1] + 1
vertices[2, 0] = vertices[2, 0] + 1
vertices[2, 1] = vertices[2, 1] - 1
if top_point_x < bottom_point_x:
vertices[0, 0] = vertices[0, 0] + 1
vertices[0, 1] = vertices[0, 1] + 1
vertices[2, 0] = vertices[2, 0] - 1
vertices[2, 1] = vertices[2, 1] - 1
if right_point_y > left_point_y:
vertices[1, 0] = vertices[1, 0] - 1
vertices[1, 1] = vertices[1, 1] - 1
vertices[3, 0] = vertices[3, 0] + 1
vertices[3, 1] = vertices[3, 1] + 1
if right_point_y < left_point_y:
vertices[1, 0] = vertices[1, 0] - 1
vertices[1, 1] = vertices[1, 1] + 1
vertices[3, 0] = vertices[3, 0] + 1
vertices[3, 1] = vertices[3, 1] - 1
return vertices
# 添加图例
def draw_legend(img, item, color, k):
obj_name = {'115': 'Dog basin', '116': 'Bar chair base', '117': 'Fan base', '118': 'Washing machine',
'119': 'Refrigerator', '120': 'Toilet', '121': 'Weighing scale', '150': 'Wire', '151': 'TV',
'152': 'Desk',
'153': 'Carpet', '154': 'Rag', '155': 'Tea table', '156': 'TV cabinet', '200': 'Slippers',
'201': 'Sock', '202': 'Wardrobe', '203': 'Bed', '204': 'Sofa', '205': 'Chair', '209': 'Pet feces'}
color = color[::-1]
text = obj_name[str(item)]
font = cv2.FONT_HERSHEY_TRIPLEX
# cv2.rectangle(img, (output.shape[1] - 140, 10 + k * 17), (output.shape[1] - 120, 20 + k * 17), color, -1)
# cv2.putText(img, text, (output.shape[1] - 100, 20 + k * 17), font, 0.4, color, 1, cv2.LINE_AA)
cv2.rectangle(img, (10, 10 + k * 17), (30, 20 + k * 17), color, -1)
cv2.putText(img, text, (40, 20 + k * 17), font, 0.5, color, 1, cv2.LINE_8)
return img
# 语义物体的强度值
# obj_value = [152, 121, 200, 115, 205, 117, 203]
obj_value = [115, 116, 117, 118, 119, 120, 121, 150, 151, 152, 153,
154, 155, 156, 200, 201, 202, 203, 204, 205, 209]
# obj_value = [153]
obj_legend = []
# output是最后画上物体形状的总图
# output = Semantic_map
# output = np.zeros((map.shape[0], map.shape[1], 3), np.uint8)
# output[:, :, 0] = map
# output[:, :, 1] = map
# output[:, :, 2] = map
k = 0
output = np.zeros((map.shape[0], map.shape[1], 3), np.uint8)
legend_color = np.zeros((map.shape[0], map.shape[1], 3), np.uint8)
# output[:, :, 0] = map
# output[:, :, 1] = map
# output[:, :, 2] = map
# 对每个物体绘制形状
for item in iter(obj_value):
if ((map == item).any()):
# min_samples, max_eps, shape, size, color = get_parameter(item)
min_samples, max_eps, shape, size, color, filter_point_num = get_parameter(item, opt)
# num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(map, connectivity=8)
y, x = np.where(map == item) # y是行，x是列
X = np.zeros((x.shape[0], 2))
X[:, 0] = y
X[:, 1] = x
X = filter_point(X, filter_point_num)
if ((X.shape[0] == 0) or (min_samples > X.shape[0])):
continue
else:
n = 0
output, n = draw_outline(X, item, min_samples, max_eps, shape, color, size, filter_point_num, output)
if n != 1:
if item not in obj_legend:
obj_legend.append(item)
legend_color = draw_legend(legend_color, item, color, k)
k = k + 1
output = output + legend_color
# legend_color[legend_color == 0] = 255
# img1 = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY) # 方便统计尺寸
return output
# 场景识别
def get_labels(img, semantic, opt, img_, map_ori):
def get_wall_area(map, num_labels, labels, stats, area):
'''
. map 获取墙壁的图像
. stats 连通域信息
. area 面积
'''
temp = []
for i in range(1, num_labels):
if stats[i, 4] > area: # 第i个区域的面积大于阈值，则为墙壁
temp.append(i)
wall_area = np.zeros((map.shape[0], map.shape[1]), np.uint8)
for i in range(0, len(temp)):
mask = labels == temp[i]
wall_area[:, :][mask] = 255
return wall_area
# def draw_legend(img,scene,color,k):
# obj_name = {'0':'Dog basin','1':'Fan base','2':'Weighing scale','3':'Desk','4':'Slippers'}
# color = color[::-1]
# text = obj_name[str(scene)]
# font = cv2.FONT_HERSHEY_DUPLEX
# cv2.rectangle(img, (output.shape[1] - 140, 50+k*17), (output.shape[1] - 120, 60+k*17), color, -1)
# cv2.putText(img, text, (output.shape[1] - 100, 60+k*17), font, 0.4, color, 1, cv2.LINE_AA)
# return img
def Scene(obj_label):
'''
:param obj_label:
:return: index "bedroom","livingroom","bathroom","kitchen" ,"unknow"
'''
Intensity_value = [115, 116, 117, 118, 119, 120, 121, 150, 151, 152, 153,
154, 155, 156, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209]
p_sce = np.ones((1, 5)) * 0.25
p_sce[0][4] = 0
p_obj_sce = np.array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0.01, 0.04, 0.8, 0],
[0.02, 0.2, 0, 0.8],
[0, 0, 0.99, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0.4, 0.4, 0, 0],
[0.2, 0.4, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0.1, 0.4, 0, 0],
[0.4, 0.6, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0.8, 0, 0, 0],
[0.99, 0, 0, 0],
[0.05, 0.5, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]
])
p_temp = 1.0
p_obj = 0.3 # 目标检测出的置信度
pre_scene = np.zeros((1, 5))
if (len(obj_label) == 0):
pre_scene[0][4] = 1
else:
for i in range(4):
for j in range(len(obj_label)):
k = obj_label[j]
sum_temp = np.sum(p_obj_sce[k])
if (sum_temp == 0):
pre_scene[0][4] = 1
continue
m = p_obj_sce[k, i]
p_temp = (1.0 - (m / sum_temp * p_obj)) * p_temp
pre_scene[0][i] = 1 - p_temp
p_temp = 1.0
if np.max(pre_scene[0, 0:4]) > 0.1:
pre_scene[0][4] = 0
sce_index = np.argmax(pre_scene)
return sce_index
def connect(pic, opt):
hahaha = copy.copy(pic)
# hahaha[hahaha == 0] = 254
# hahaha[hahaha == 255] = 0
hahaha[hahaha == 255] = 1
skeleton0 = morphology.skeletonize(hahaha)
skeleton_ = skeleton0.astype(np.uint8) * 9
skeleton = skeleton0.astype(np.uint8) * 255
img_blur = cv2.blur(copy.copy(skeleton_), (3, 3))
# img_blur = img_blur * 9
img_blur[img_blur != 2] = 0
img_blur[img_blur == 2] = 255
img_blur[skeleton_ == 0] = 0
corners = np.where(img_blur != 0)
corners = np.array(corners)
# corners = cv2.goodFeaturesToTrack(skeleton, 200, 0.01, 3)
# corners = np.int0(corners)
# skeleton = skeleton / 255
# kernel = np.ones((1, 9))
temp_x = []
temp_y = []
for i in range(corners.shape[1]):
x = corners[0, i]
y = corners[1, i]
# cov_corner = np.array([[skeleton[y - 1, x - 1], skeleton[y, x - 1], skeleton[y + 1, x - 1]],
# [skeleton[y - 1, x], skeleton[y, x], skeleton[y + 1, x]],
# [skeleton[y - 1, x + 1], skeleton[y, x + 1], skeleton[y + 1, x + 1]]])
# cov_corner[cov_corner > 0] = 1
# cov_corner = cov_corner.reshape(9, 1)
# a3 = np.dot(kernel, cov_corner)
# if a3 == 2:
temp_x.append(x)
temp_y.append(y)
cv2.circle(skeleton, (y, x), 3, 255, -1)
temp_X = np.array(temp_x)
temp_Y = np.array(temp_y)
temp = np.vstack((temp_X, temp_Y)).transpose()
distance = 10000 * np.ones((temp.shape[0], temp.shape[0]))
for i in range(temp.shape[0]):
for j in range(i, temp.shape[0]):
distance[i, j] = np.sqrt((temp[i][0] - temp[j][0]) ** 2 + (temp[i][1] - temp[j][1]) ** 2)
distance[distance == 0] = 10000
if distance[i, j] < opt.distance:
# z = np.argmin(distance[i, :])
cv2.line(pic, (temp[i, 1], temp[i, 0]), (temp[j, 1], temp[j, 0]), 255, 3)
return pic
# 计算最小外接矩形
def outer_rectangle(obj):
'''
. 计算最小外接矩形
. @param obj 语义物体的位置信息
. @param size 语义物体绘制轮廓的参数（0代表按轮廓绘制，1代表绘制正矩形）
'''
binary, contours, hierarchy = cv2.findContours(obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contour = []
for cont in contours:
contour.extend(cont)
min_rect = cv2.minAreaRect(np.array(contour))
box = cv2.boxPoints(min_rect)
# box = np.round(box)
box = np.int0(box)
# 排序
temp = np.where(box == np.min(box[:, 0])) # box的第0列是列，第1列是行
if temp[0].shape[0] > 1:
left = np.min(box[:, 0])
right = np.max(box[:, 0])
up = np.min(box[:, 1])
down = np.max(box[:, 1])
top_point_x = left
top_point_y = up
right_point_x = right
right_point_y = up
bottom_point_x = right
bottom_point_y = down
left_point_x = left
left_point_y = down
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
return vertices
left_point_x = np.min(box[:, 0])
right_point_x = np.max(box[:, 0])
top_point_y = np.min(box[:, 1])
bottom_point_y = np.max(box[:, 1])
left_point_y = box[:, 1][np.where(box[:, 0] == left_point_x)][0]
right_point_y = box[:, 1][np.where(box[:, 0] == right_point_x)][0]
top_point_x = box[:, 0][np.where(box[:, 1] == top_point_y)][0]
bottom_point_x = box[:, 0][np.where(box[:, 1] == bottom_point_y)][0]
vertices = np.array(
[[top_point_x, top_point_y], [right_point_x, right_point_y], [bottom_point_x, bottom_point_y],
[left_point_x, left_point_y]])
return vertices
img1 = cv2.cvtColor(semantic, cv2.COLOR_BGR2GRAY) # 方便统计尺寸
img1[img1 > 0] = 1 # 提取语义
img2 = img * img1 # 提取语义
Intensity_value = [115, 116, 117, 118, 119, 120, 121, 150, 151, 152, 153,
154, 155, 156, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209]
'只保留墙壁空间'
temp = copy.copy(img)
temp[temp == 0] = 254
temp[temp == 255] = 0
temp[temp == 254] = 255
temp[temp < 254] = 0
img3 = copy.copy(temp) # 提取非语义非墙壁区域
img3[img3 > 0] = 1
img3[img1 > 0] = 0
Semantic_map = np.zeros((img.shape[0], img.shape[1], 3), np.uint8)
temp = temp.astype(np.uint8)
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(temp, connectivity=8)
wall_area = get_wall_area(img, num_labels, labels, stats, opt.length)
img_[img_ == 0] = 254
img_[img_ == 255] = 0
img_[img_ == 254] = 255
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(img_, connectivity=8)
wall_area_ = get_wall_area(img_, num_labels, labels, stats, opt.length)
"pic 为分割区域的结果，作为一张区域分割后的地图，将分割结果传给后续场景识别，场景识别结果绘制在图Semantic_map，"
pic = copy.copy(wall_area_)
pic = connect(pic, opt)
img3[wall_area > 0] = 0
img3 = img3 * 255
img3[img3 == 0] = 254
img3[img3 == 255] = 0
img3[img3 == 254] = 255
wall_area[wall_area == 0] = 254
wall_area[wall_area == 255] = 0
wall_area[wall_area == 254] = 255
pic[pic == 0] = 254
pic[pic == 255] = 0
pic[pic == 254] = 255
wall_area_color = np.zeros((wall_area.shape[0], wall_area.shape[1], 3), np.uint8)
wall_area_color[:, :, 0] = wall_area
wall_area_color[:, :, 1] = wall_area
wall_area_color[:, :, 2] = wall_area
'提取房间'
room_num_labels, room_labels, room_stats, room_centroids = cv2.connectedComponentsWithStats(pic,
connectivity=8)
k = 0
scene_legend = []
for i in range(2, room_num_labels):
if room_stats[i, 4] < 200:
continue
room = np.zeros((wall_area.shape[0], wall_area.shape[1]))
obj_label = []
mask = room_labels == i
room[:, :][mask] = 1
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
room = cv2.dilate(room, kernel, iterations=1)
room_temp = copy.copy(room)
room_temp = room_temp.astype(np.uint8)
room_box = outer_rectangle(room_temp)
room_outline_RGB = np.zeros((room_temp.shape[0], room_temp.shape[1], 3), np.uint8)
room_outline_RGB = cv2.drawContours(room_outline_RGB, [room_box], 0, (0, 255, 0), -1, lineType=cv2.LINE_4)
room_outline = cv2.cvtColor(room_outline_RGB, cv2.COLOR_BGR2GRAY)
room_outline[room_outline > 0] = 1
room = room_outline
# Semantic_area = room_outline * img2
Semantic_area = room * img2
Semantic_area = list(Semantic_area.flatten())
Semantic_area = list(set(Semantic_area))
Semantic_area.sort()
for i in range(len(Semantic_area)):
if Semantic_area[i] in Intensity_value:
obj_label.append(Intensity_value.index(Semantic_area[i]))
# obj_label_test = [] # 用于测试
# cv2.imshow("room",room*255)
# cv2.waitKey(0)
scene = Scene(obj_label)
if scene == 0:
Semantic_map[:, :, 0][room > 0] = 70
Semantic_map[:, :, 1][room > 0] = 80
Semantic_map[:, :, 2][room > 0] = 90
color = [70, 80, 90]
if scene == 1:
Semantic_map[:, :, 0][room > 0] = 100
Semantic_map[:, :, 1][room > 0] = 180
Semantic_map[:, :, 2][room > 0] = 120
color = [100, 180, 120]
if scene == 2:
Semantic_map[:, :, 0][room > 0] = 210
Semantic_map[:, :, 1][room > 0] = 67
Semantic_map[:, :, 2][room > 0] = 170
color = [210, 67, 170]
if scene == 3:
Semantic_map[:, :, 0][room > 0] = 150
Semantic_map[:, :, 1][room > 0] = 48
Semantic_map[:, :, 2][room > 0] = 88
color = [150, 48, 88]
# if scene == 4:
# Semantic_map[:, :, 0][mask] = 134
# Semantic_map[:, :, 1][mask] = 231
# Semantic_map[:, :, 2][mask] = 143
# color = [134, 231, 143]
# if scene not in scene_legend:
# scene_legend.append(scene)
# Semantic_map = draw_legend(Semantic_map, scene, color, k)
# k = k + 1
# img3[img3 > 0] = 255
Semantic_map = Semantic_map + wall_area_color
Semantic_map[img1 > 0] = 0
# semantic[img1 < 1] = 0
Semantic_map = Semantic_map + semantic
Semantic_map[img3 == 0] = 0
p = cv2.cvtColor(copy.copy(Semantic_map), cv2.COLOR_BGR2GRAY) # 方便统计尺寸
map_ori_RGB = np.zeros((map_ori.shape[0], map_ori.shape[1], 3), np.uint8)
map_ori_RGB[:, :, 0][map_ori > 0] = 255
map_ori_RGB[:, :, 1][map_ori > 0] = 255
map_ori_RGB[:, :, 2][map_ori > 0] = 255
map_ori[p > 0] = 0
map_ori_RGB = map_ori_RGB + Semantic_map
map_ori_RGB[img1 > 0] = 0
map_ori_RGB = map_ori_RGB + semantic
map_ori_RGB[img3 == 0] = 0
return map_ori_RGB
if __name__ == "__main__":
img = cv2.imread("path/map/map6.png", 0)
cv2.flip(img, 0, img) # 图片翻转
map, map_, map_ori = process_map(img, opt) # map:仅把门连起来； map_:把门连起来，成片语义点当成墙； map_ori: 无处理原图
# map_test = cv2.imread("mappp.jpg", 0)
output = obj_outline(map_ori, opt, map_ori) # 参考map，画map_ori上
Semantic_map = get_labels(map, output, opt, map_, map_ori)
cv2.imwrite("/path/result/Semantic_map.png",Semantic_map)
cv2.imshow("Semantic_map",Semantic_map)
cv2.waitKey(0)