def Point_differnce(image, step, points, state):
height, width = image.shape[:]
if state == 1: #在竖直方向上进行比较
diff_list = []
for i in range(len(points)):
point = points[i]
Point_up = (point[0], point[1]-step)
Point_down = (point[0], point[1]+step)
Point_up = np.uint0(Point_up)
Point_down = np.uint0(Point_down)
if Point_up[1] >= 0 and Point_down[1] <= height-1:
diff = abs(image[Point_up[1]][Point_up[0]] - image[Point_down[1]][Point_down[0]])
diff_list.append(diff)
arr_var = np.var(diff_list) #计算方差
return arr_var
if state == 0: #在水平方向上进行比较
diff_list = []
for i in range(len(points)):
point = points[i]
Point_right = (point[0] + step, point[1])
Point_left = (point[0] - step, point[1])
Point_right = np.uint0(Point_right)
Point_left = np.uint0(Point_left)
if Point_left[0] >= 0 and Point_right[0] <= width-1:
diff = abs(image[Point_left[1]][Point_left[0]] - image[Point_right[1]][Point_right[0]])
diff_list.append(diff)
arr_var = np.var(diff_list) #计算方差
return arr_var
def image_to_saliency_map_mdf(image, mean, seg_param_path, fuseweights, sess,
s3cnn, sp_in, nn_in, pic_in):
t_preprocess = 0
eps = sys.float_info.epsilon
t_seg = time.time()
segdata = mult_seg(image, seg_param_path)
t_seg = time.time() - t_seg
print('segmentation duration: %f' % t_seg)
salmap_temp = np.zeros(image.shape[0:2])
t_net = 0
for i in range(0, segdata.__len__()):
t_preprocess_temp = time.time()
temp = np.zeros(image.shape[0:2])
seg = segdata[str(i)]
sp, nn, pic = im2mdfin2(image, mean, seg['segmap'], seg['seglist'],
seg['neighbour_mat'])
t_preprocess = t_preprocess + time.time() - t_preprocess_temp
#sp = np.reshape(np.ravel(mdfin[0:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
#nn = np.reshape(np.ravel(mdfin[1:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
#pic = np.reshape(np.ravel(mdfin[2:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
t_net_temp = time.time()
labels = np.uint0([])
prob = np.float32([])
for j in range(
0,
np.uint16(1 + seg['seglist'].__len__() / mdf.MAX_BATCH_SIZE)):
if j * mdf.MAX_BATCH_SIZE == seg['seglist'].__len__():
continue
tensors = [s3cnn.nnout]
xdim = (227, 227, 3)
feed_dict = {
sp_in: sp[j * mdf.MAX_BATCH_SIZE:(1 + j) * mdf.MAX_BATCH_SIZE],
nn_in: nn[j * mdf.MAX_BATCH_SIZE:(1 + j) * mdf.MAX_BATCH_SIZE],
pic_in:
pic[j * mdf.MAX_BATCH_SIZE:(1 + j) * mdf.MAX_BATCH_SIZE]
}
with tf.device('/gpu:0'):
up = sess.run(tensors, feed_dict=feed_dict)
labels_temp = np.uint0(np.argmax(up[0], 1))
labels = np.concatenate((labels, labels_temp))
prob_temp = np.float32(np.max(up[0], 1))
prob = np.concatenate((prob, prob_temp))
t_net = t_net + time.time() - t_net_temp
for j in range(0, seg['seglist'].__len__()):
if labels[j] == 1:
prob[j] = 1 - prob[j]
temp = temp + (prob[j]) * (seg['segmap'] == seg['seglist'][j])
salmap_temp = fuseweights[i] * temp + salmap_temp
salmap = np.uint8((salmap_temp - np.min(salmap_temp)) /
(np.max(salmap_temp) - np.min(salmap_temp) + eps) * 255)
return t_preprocess, t_net, salmap
def Line_Difference_v2(image, step, interal, point_number, state):
height, width = image.shape[:]
if state == 1:
sum_line_difference = []
for i in range(int(height / 2) // 2):
if (i + 1) * interal < int(height / 2):
Pt1 = (1, interal * (i + 1))
Pt2 = (width - 1, interal * (i + 1))
Pt3 = (1, height - 1 - interal * (i + 1))
Pt4 = (width - 1, height - 1 - interal * (i + 1))
Points12 = np.uint0(np.linspace(Pt1, Pt2, point_number))
Points34 = np.uint0(np.linspace(Pt3, Pt4, point_number))
diff_var12 = Point_differnce(image,
step=step,
points=Points12,
state=state)
diff_var34 = Point_differnce(image,
step=step,
points=Points34,
state=state)
diff_var = (diff_var12 + diff_var34) / 2
sum_line_difference.append([diff_var, Pt1, Pt2, Pt3, Pt4])
sum_diff = [x[0] for x in sum_line_difference]
max_index = sum_diff.index(max(sum_diff))
return [sum_line_difference[max_index][1], sum_line_difference[max_index][2], \
sum_line_difference[max_index][3], sum_line_difference[max_index][4]]
if state == 0:
sum_line_difference = []
for i in range(int(width / 2) // 2):
if (i + 1) * interal < int(width / 2):
Pt1 = (interal * (i + 1), 1)
Pt2 = (interal * (i + 1), height - 1)
Pt3 = (width - 1 - interal * (i + 1), 1)
Pt4 = (width - 1 - interal * (i + 1), height - 1)
Points12 = np.uint0(np.linspace(Pt1, Pt2, point_number))
Points34 = np.uint0(np.linspace(Pt3, Pt4, point_number))
diff_var12 = Point_differnce(image,
step=step,
points=Points12,
state=state)
diff_var34 = Point_differnce(image,
step=step,
points=Points34,
state=state)
diff_var = (diff_var12 + diff_var34) / 2
sum_line_difference.append([diff_var, Pt1, Pt2, Pt3, Pt4])
sum_diff = [x[0] for x in sum_line_difference]
max_index = sum_diff.index(max(sum_diff))
return [sum_line_difference[max_index][1], sum_line_difference[max_index][2], \
sum_line_difference[max_index][3], sum_line_difference[max_index][4]]
def save_SLIC_segmentations_MSRA(images, in_dir, out_dir, NSP):
if 'SLIC_Segs' not in os.listdir(out_dir):
os.mkdir(out_dir + '/SLIC_Segs')
if str(NSP) not in os.listdir(out_dir + 'SLIC_Segs'):
os.mkdir(out_dir + '/SLIC_Segs/' + str(NSP))
for fimg in images:
img = sio.imread(in_dir + fimg)
gt = sio.imread(in_dir + fimg[0:-3] + 'png') / 255
SLIC_seg = np.uint16(
slic_wrap(img, NSP, 10, sigma=1, enforce_connectivity=True))
saliency = []
segments = []
segments_temp = np.unique(SLIC_seg)
for segment in segments_temp:
sal_temp = calc_saliency_score(segment, SLIC_seg, gt)
if sal_temp >= 0:
segments.append(segment)
saliency.append(np.uint0(sal_temp))
fslic = open(
out_dir + '/SLIC_Segs/' + str(NSP) + '/' + fimg[0:-4] + '.slic',
'wb')
dill.dump(SLIC_seg, fslic)
dill.dump(segments, fslic)
dill.dump(saliency, fslic)
fslic.close()
def save_fseg_segmentations_MSRA(images,in_dir,out_dir,param_path,train = False):
fparams = np.load(param_path).item()
if 'f_Segs' not in os.listdir(out_dir):
os.mkdir(out_dir+'/f_Segs')
for fimg in images :
img = sio.imread(in_dir+fimg)
gt = sio.imread(in_dir+fimg[0:-3]+'png')/255
segs = {}
for g in range(0,15):
f_seg = np.zeros(img.shape[0:2],dtype=np.int32)
felseg(img,f_seg,fparams['sigma'][g],np.float(fparams['scale'][g]),np.int(fparams['min_size'][g]))
saliency = []
segments = []
f_seg+=1
segments_temp = np.unique(f_seg)
for segment in segments_temp:
sal_temp = calc_saliency_score(segment,f_seg,gt)
if (not(train) or (sal_temp >= 0)) :
segments.append(segment)
saliency.append(np.uint0(sal_temp))
segs[str(g)]={}
segs[str(g)]['segmap']= f_seg
segs[str(g)]['seglist']= segments
segs[str(g)]['labels']= saliency
np.save(out_dir+'/f_Segs/'+fimg[0:-4],segs)
def save_fseg_segmentations_MSRA(images,
in_dir,
out_dir,
param_path,
train=False):
fparams = np.load(param_path).item()
if 'f_Segs' not in os.listdir(out_dir):
os.mkdir(out_dir + '/f_Segs')
for fimg in images:
img = sio.imread(in_dir + fimg)
gt = sio.imread(in_dir + fimg[0:-3] + 'png') / 255
segs = {}
for g in range(0, 15):
f_seg = np.zeros(img.shape[0:2], dtype=np.int32)
felseg(img, f_seg, fparams['sigma'][g],
np.float(fparams['scale'][g]),
np.int(fparams['min_size'][g]))
saliency = []
segments = []
f_seg += 1
segments_temp = np.unique(f_seg)
for segment in segments_temp:
sal_temp = calc_saliency_score(segment, f_seg, gt)
if (not (train) or (sal_temp >= 0)):
segments.append(segment)
saliency.append(np.uint0(sal_temp))
segs[str(g)] = {}
segs[str(g)]['segmap'] = f_seg
segs[str(g)]['seglist'] = segments
segs[str(g)]['labels'] = saliency
np.save(out_dir + '/f_Segs/' + fimg[0:-4], segs)
def image_to_saliency_map_mdf(image,mean,seg_param_path,fuseweights,sess,s3cnn,sp_in,nn_in,pic_in):
t_preprocess =0
eps = sys.float_info.epsilon
t_seg = time.time()
segdata = mult_seg(image,seg_param_path)
t_seg = time.time() - t_seg
print('segmentation duration: %f' % t_seg)
salmap_temp = np.zeros(image.shape[0:2])
t_net = 0
for i in range(0,segdata.__len__()):
t_preprocess_temp = time.time()
temp = np.zeros(image.shape[0:2])
seg = segdata[str(i)]
sp,nn,pic = im2mdfin2(image,mean,seg['segmap'],seg['seglist'],seg['neighbour_mat'])
t_preprocess = t_preprocess+time.time()-t_preprocess_temp
#sp = np.reshape(np.ravel(mdfin[0:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
#nn = np.reshape(np.ravel(mdfin[1:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
#pic = np.reshape(np.ravel(mdfin[2:mdfin.__len__():3]),[np.uint16(mdfin.__len__()/3),227,227,3])
t_net_temp = time.time()
labels = np.uint0([])
prob = np.float32([])
for j in range(0,np.uint16(1+seg['seglist'].__len__()/mdf.MAX_BATCH_SIZE)):
if j*mdf.MAX_BATCH_SIZE == seg['seglist'].__len__() :
continue
tensors = [s3cnn.nnout]
xdim = (227,227,3)
feed_dict = {sp_in :sp[j*mdf.MAX_BATCH_SIZE:(1+j)*mdf.MAX_BATCH_SIZE], nn_in : nn[j*mdf.MAX_BATCH_SIZE:(1+j)*mdf.MAX_BATCH_SIZE], pic_in : pic[j*mdf.MAX_BATCH_SIZE:(1+j)*mdf.MAX_BATCH_SIZE]}
with tf.device('/gpu:0'):
up = sess.run(tensors, feed_dict=feed_dict)
labels_temp = np.uint0(np.argmax(up[0],1))
labels = np.concatenate((labels,labels_temp))
prob_temp = np.float32(np.max(up[0],1))
prob = np.concatenate((prob,prob_temp))
t_net = t_net+time.time()-t_net_temp
for j in range(0,seg['seglist'].__len__()):
if labels[j] == 1:
prob[j]=1-prob[j]
temp = temp+ (prob[j])*(seg['segmap'] == seg['seglist'][j])
salmap_temp = fuseweights[i]*temp+salmap_temp
salmap = np.uint8((salmap_temp-np.min(salmap_temp))/(np.max(salmap_temp)-np.min(salmap_temp)+eps)*255)
return t_preprocess, t_net,salmap
def gen_random_locations(size):
''' generate random locations that are not over dark parts of the screen '''
im = np.mean(pyautogui.screenshot(), axis=2)
sample = np.uint0(np.random.rand(size * 2, 2) * SIZE)
try:
return sample[im[tuple(sample.T[::-1])] > 3][:size]
except IndexError:
# if there are a lot of black pixels try with larger sample
return gen_random_locations(size * 2)[:size]
def generate(self):
yield 1
yield 2
yield 10
yield 100
if USE_NUMPY:
yield np.int16(10)
yield np.int8(4)
yield np.int64(5)
yield np.uint0(1)
def calc_saliency_score(segment, slic, gt):
mask = np.uint0(slic == segment)
pixels = np.sum(mask)
sal = -1
sal_temp = np.sum(mask * gt) / pixels
sal = -1
if sal_temp > 0.7:
sal = 1
elif sal_temp < 0.3:
sal = 0
return sal
def Box_inside_detect(image, top_left_x, bottom_right_x): #输入图像必须是单通道的灰度图
roi = image[top_left_x[1]:bottom_right_x[1],
top_left_x[0]:bottom_right_x[0]]
h, w = roi.shape[:]
#sobel算子检测
x = cv2.Sobel(roi, cv2.CV_16S, 1, 0)
y = cv2.Sobel(roi, cv2.CV_16S, 0, 1)
absX = cv2.convertScaleAbs(x) # 转回uint8
absY = cv2.convertScaleAbs(y)
mask = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
ret, mask = cv2.threshold(mask, 50, 250, cv2.THRESH_BINARY)
#对sobel算子的结果进行腐蚀
kernel = np.ones((2, 2), np.uint8)
mask = cv2.dilate(mask, kernel)
new_Pt_1 = Line_Difference_v2(mask,
step=2,
interal=5,
point_number=10,
state=1)
new_Pt_2 = Line_Difference_v2(mask,
step=1,
interal=5,
point_number=10,
state=0)
height_pt = abs(new_Pt_1[0][1] - new_Pt_1[2][1])
width_pt = abs(new_Pt_2[0][0] - new_Pt_2[2][0])
# 输出面积占比
area = (height_pt * width_pt) / (w * h) * 100
rect_corner = []
if area > 50.0:
for i in range(len(new_Pt_1) // 2):
j = i * 2
line1 = (new_Pt_1[j][0], new_Pt_1[j][1], new_Pt_1[j + 1][0],
new_Pt_1[j + 1][1])
line2 = (new_Pt_2[j][0], new_Pt_2[j][1], new_Pt_2[j + 1][0],
new_Pt_2[j + 1][1])
point_corner = np.uint0(cross_point(line1, line2))
rect_corner.append(point_corner)
if len(rect_corner) == 2:
#cv2.rectangle(roi, (rect_corner[0][0], rect_corner[0][1]), (rect_corner[1][0], rect_corner[1][1]), (0, 0, 255),2)
rect_corner[0][0] += top_left_x[0]
rect_corner[0][1] += top_left_x[1]
rect_corner[1][0] += top_left_x[0]
rect_corner[1][1] += top_left_x[1]
return rect_corner
else:
return None
def generate(self):
yield -100
yield -1
yield 0
yield 1
yield 100
if USE_NUMPY:
yield np.int16(-10)
yield np.int8(-1)
yield np.int64(0)
yield np.uint0(1)
def calc_saliency_score(segment,slic,gt):
mask = np.uint0(slic == segment)
pixels = np.sum(mask)
sal = -1
sal_temp = np.sum(mask*gt)/pixels
sal = -1
if sal_temp > 0.7 :
sal = 1
elif sal_temp < 0.3:
sal = 0
return sal
def im2mdfin(img,mean,segmap,segments):
result = MDFInData()
mean_image = sp.misc.imresize(mean,img.shape)
#Superpixel segmentation - to be replaced by other segmentation if necessary
#SLIC_seg = slic_wrap(img, nsp, 10, sigma=1, enforce_connectivity=True)
#segments = np.unique(SLIC_seg)
#numSP = 0
for SPi in range(0,segments.__len__()):
pair = MDFInRecord()
curr_sp = segments[SPi]
sp_mask= np.uint0(segmap == curr_sp)
indices = np.where((segmap == curr_sp)!=0)
bb = np.array([[np.min(indices[0]),np.max(indices[0])],[np.min(indices[1]),np.max(indices[1])]])
#extracting only the superpixel
seg_img = np.copy(img[bb[0,0]:bb[0,1],bb[1,0]:bb[1,1]])
mean_seg = np.copy(mean_image[bb[0,0]:bb[0,1],bb[1,0]:bb[1,1]])
local_seg = segmap[bb[0,0]:bb[0,1],bb[1,0]:bb[1,1]]
#zeroing area around superpixel
seg_img[local_seg != curr_sp,:]=0
mean_seg[local_seg != curr_sp,:]=0
#num_pixels = np.sum(local_seg == curr_sp)
seg_img = seg_img-mean_seg
#GT_label = np.copy(gt[bb[0,0]:bb[0,1],bb[1,0]:bb[1,1]])
#GT_label[local_seg != curr_sp]=0
#saliency_score = np.sum(GT_label/255)/num_pixels
#Saliency score is deemed reliant so we can add it here
#if saliency_score > 0.7 or saliency_score < 0.3:
#numSP = numSP+1
#finding the neighbor segments
neighbors = np.unique(local_seg)
#extracting locations of neighbor segments in image
ix = np.where(np.in1d(segmap.ravel(),neighbors).reshape(segmap.shape))
#calculating a bounding box over neghbor superpixels
bb_mid= np.array([[np.min(ix[0]),np.max(ix[0])],[np.min(ix[1]),np.max(ix[1])]])
#cropping the bounding box - this is the input to the 2nd mini CNN
bounding_box_second = np.copy(img[bb_mid[0,0]:bb_mid[0,1],bb_mid[1,0]:bb_mid[1,1]])
#mean subtraction on region B
bounding_box_second = bounding_box_second - mean_image[bb_mid[0,0]:bb_mid[0,1],bb_mid[1,0]:bb_mid[1,1]]
#resizing superpixel to net input size
pair.SP_Region= np.array(sp.misc.imresize(seg_img,[227,227,3]))#,dtype = np.uint8)
#resizing neighborhood to net input size
pair.SP_Neighbor = np.array(sp.misc.imresize(bounding_box_second,[227,227,3]))#,dtype = np.uint8)
#picture with segment masked
picture = np.copy(img)-mean_image
picture[segmap == curr_sp,:]=0
pair.Pic = np.array(sp.misc.imresize(picture,[227,227,3]))#,dtype = np.uint8)
#pair.saliency = round(saliency_score)
pair.SP_mask = sp.misc.imresize(sp_mask,[227,227,3])
result.segments.append(pair)
return result
def shi_tomasi(image):
gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
corners = cv.goodFeaturesToTrack(gray, 25, 0.01, 10)
corners = np.uint0(corners)
print(corners.shape)
for corner in corners:
x, y = corner.ravel()
cv.circle(image, (x, y), 3, (0, 0, 255), -1)
cv.imshow("corner", image)
def _getLineImg(length, direction='h', lineWidth=5):
"""Crea una imagen con una linea, para realizar la convolución
es más una función interna del script que otra cosa.
input args:
length : entero, largo de la imagen en la dirección que se extiende la linea
direction: char 'v' o 'h' dirección vertical u horizontal respectivamente.
linewidth: ancho de la linea que creará"""
cover = 3 # ancho alrededor de linea
cen = np.uint0(cover + lineWidth / 2)
if direction == 'h':
imageShape = [lineWidth + 2 * cover, length]
args = [(0, cen), (imageShape[1], cen)]
if direction == 'v':
imageShape = [length, lineWidth + 2 * cover]
args = [(cen, 0), (cen, imageShape[0])]
blackImage = np.zeros(imageShape)
return cv2.line(blackImage, *args, 255, lineWidth)
def save_SLIC_segmentations_MSRA(images,in_dir,out_dir,NSP):
if 'SLIC_Segs' not in os.listdir(out_dir):
os.mkdir(out_dir+'/SLIC_Segs')
if str(NSP) not in os.listdir(out_dir+'SLIC_Segs'):
os.mkdir(out_dir+'/SLIC_Segs/'+str(NSP))
for fimg in images :
img = sio.imread(in_dir+fimg)
gt = sio.imread(in_dir+fimg[0:-3]+'png')/255
SLIC_seg = np.uint16(slic_wrap(img,NSP, 10, sigma=1, enforce_connectivity=True))
saliency = []
segments = []
segments_temp = np.unique(SLIC_seg)
for segment in segments_temp:
sal_temp = calc_saliency_score(segment,SLIC_seg,gt)
if sal_temp >= 0 :
segments.append(segment)
saliency.append(np.uint0(sal_temp))
fslic = open(out_dir+'/SLIC_Segs/'+str(NSP)+'/'+fimg[0:-4]+'.slic','wb')
dill.dump(SLIC_seg,fslic)
dill.dump(segments,fslic)
dill.dump(saliency,fslic)
fslic.close()
def deal_contours_image(image_path):
# image = cv2.imread(image_path, 1)
image = cv2.imdecode(np.fromfile(image_path, dtype=np.uint8),
cv2.IMREAD_UNCHANGED)
if opt.show_image:
cv2.imshow('crc', image)
# cv2.imshow("ori", image)
#保留原图，用于显示图像
img = image.copy()
# #保存原图，用于裁剪图片
img1 = image.copy()
image = image[:, :, 2]
image_name = os.path.split(image_path)[-1]
# 阈值处理后的图片
# thresh_image = threshTwoPeaks1(image)
# cv2.imshow('thresh_image',thresh_image)
print(image_name)
# 高斯平滑
image = cv2.GaussianBlur(image, (3, 3), 0.5)
# 膨胀处理，过滤细小竖直边线
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 1))
image = cv2.dilate(image, kernel)
# cv2.imshow("dilate", image)
# 边缘检测，找出明显轮廓。
image = cv2.Canny(image, 60, 80)
if opt.show_image:
cv2.namedWindow("Canny", flags=1)
cv2.imshow("Canny", image)
# 膨胀处理，将紧挨着的边线合并，用于后续寻找外轮廓
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 20))
image = cv2.dilate(image, kernel)
# cv2.imshow('canny', image)
#寻找外轮廓
hc = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = hc[1]
#print('轮廓数：', len(contours))
error_image_list = []
total_num = 0
for i in range(len(contours)):
# 绘制轮廓
# cv2.drawContours(img, contours, i, 255, 2)
# 获取最小旋转矩形
# points = cv2.minAreaRect(contours[i])
# # 计算旋转矩形4个顶点坐标
# rect = cv2.boxPoints(points)
#计算最小外包直立矩形
rect = cv2.boundingRect(contours[i])
# 数据类型转换
rect = np.uint0(rect)
# 绘制矩形
#旋转矩形4个顶点
# cv2.drawContours(img, [rect], 0, (0, 255, 0), 2)
# 直立矩形对角点
x1 = rect[0]
x2 = rect[0] + rect[2]
y1 = rect[1]
y2 = rect[1] + rect[3]
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 1)
global num
num = num + 1
if rect[3] > 600:
continue
flag = do_onnx_predict(img1[y1:y2, x1:x2])
if flag == 1:
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 0, 255), 1)
error_image_list.append(img1[y1:y2, x1:x2])
total_num += 1
if opt.show_image:
show_image(image_name, img)
error_num = len(error_image_list)
print("出错区域数量：{}/{}".format(error_num, total_num))
if error_num > 0:
cv2.imshow("原图", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
reveal_type(np.object0()) # E: numpy.object_
reveal_type(np.void0(0)) # E: numpy.void
reveal_type(np.byte()) # E: {byte}
reveal_type(np.short()) # E: {short}
reveal_type(np.intc()) # E: {intc}
reveal_type(np.intp()) # E: {intp}
reveal_type(np.int0()) # E: {intp}
reveal_type(np.int_()) # E: {int_}
reveal_type(np.longlong()) # E: {longlong}
reveal_type(np.ubyte()) # E: {ubyte}
reveal_type(np.ushort()) # E: {ushort}
reveal_type(np.uintc()) # E: {uintc}
reveal_type(np.uintp()) # E: {uintp}
reveal_type(np.uint0()) # E: {uintp}
reveal_type(np.uint()) # E: {uint}
reveal_type(np.ulonglong()) # E: {ulonglong}
reveal_type(np.half()) # E: {half}
reveal_type(np.single()) # E: {single}
reveal_type(np.double()) # E: {double}
reveal_type(np.float_()) # E: {double}
reveal_type(np.longdouble()) # E: {longdouble}
reveal_type(np.longfloat()) # E: {longdouble}
reveal_type(np.csingle()) # E: {csingle}
reveal_type(np.singlecomplex()) # E: {csingle}
reveal_type(np.cdouble()) # E: {cdouble}
reveal_type(np.complex_()) # E: {cdouble}
reveal_type(np.cfloat()) # E: {cdouble}
return_schema=True)
assert actual == {"a": [1, 4], "b": ([2, 5], [3, 6])}
assert schema == {"a": None, "b": (None, None)}
@pytest.mark.parametrize(
"value",
[
np.int0(1),
np.int8(-2),
np.int16(-5),
np.int32(+32),
np.int64(120),
np.uint0(1),
np.uint8(2),
np.uint16(5),
np.uint32(+32),
np.uint64(120),
np.float16(-2.0),
np.float32(-2.0),
np.float64(-2.0),
np.float128(-2.0),
np.array(2.0),
np.array([1, 2, 3]),
np.array([[1], [2], [3]]),
],
)
def test_json_nump_default__roundtrip(value):
actual = json.loads(json.dumps(value, default=json_numpy_default))
np.object0() np.void0(0) np.byte() np.short() np.intc() np.intp() np.int0() np.int_() np.longlong() np.ubyte() np.ushort() np.uintc() np.uintp() np.uint0() np.uint() np.ulonglong() np.half() np.single() np.double() np.float_() np.longdouble() np.longfloat() np.csingle() np.singlecomplex() np.cdouble() np.complex_() np.cfloat()
reveal_type(np.unicode_()) # E: numpy.str_ reveal_type(np.str0()) # E: numpy.str_ reveal_type(np.byte()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.short()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.intc()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.intp()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.int0()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.int_()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.longlong()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.ubyte()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.ushort()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uintc()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uintp()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uint0()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uint()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.ulonglong()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.half()) # E: numpy.floating[numpy.typing._ reveal_type(np.single()) # E: numpy.floating[numpy.typing._ reveal_type(np.double()) # E: numpy.floating[numpy.typing._ reveal_type(np.float_()) # E: numpy.floating[numpy.typing._ reveal_type(np.longdouble()) # E: numpy.floating[numpy.typing._ reveal_type(np.longfloat()) # E: numpy.floating[numpy.typing._ reveal_type(np.csingle()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.singlecomplex()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.cdouble()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.complex_()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.cfloat()) # E: numpy.complexfloating[numpy.typing._
def im2mdfin(img, mean, segmap, segments):
result = MDFInData()
mean_image = sp.misc.imresize(mean, img.shape)
#Superpixel segmentation - to be replaced by other segmentation if necessary
#SLIC_seg = slic_wrap(img, nsp, 10, sigma=1, enforce_connectivity=True)
#segments = np.unique(SLIC_seg)
#numSP = 0
for SPi in range(0, segments.__len__()):
pair = MDFInRecord()
curr_sp = segments[SPi]
sp_mask = np.uint0(segmap == curr_sp)
indices = np.where((segmap == curr_sp) != 0)
bb = np.array([[np.min(indices[0]),
np.max(indices[0])],
[np.min(indices[1]),
np.max(indices[1])]])
#extracting only the superpixel
seg_img = np.copy(img[bb[0, 0]:bb[0, 1], bb[1, 0]:bb[1, 1]])
mean_seg = np.copy(mean_image[bb[0, 0]:bb[0, 1], bb[1, 0]:bb[1, 1]])
local_seg = segmap[bb[0, 0]:bb[0, 1], bb[1, 0]:bb[1, 1]]
#zeroing area around superpixel
seg_img[local_seg != curr_sp, :] = 0
mean_seg[local_seg != curr_sp, :] = 0
#num_pixels = np.sum(local_seg == curr_sp)
seg_img = seg_img - mean_seg
#GT_label = np.copy(gt[bb[0,0]:bb[0,1],bb[1,0]:bb[1,1]])
#GT_label[local_seg != curr_sp]=0
#saliency_score = np.sum(GT_label/255)/num_pixels
#Saliency score is deemed reliant so we can add it here
#if saliency_score > 0.7 or saliency_score < 0.3:
#numSP = numSP+1
#finding the neighbor segments
neighbors = np.unique(local_seg)
#extracting locations of neighbor segments in image
ix = np.where(np.in1d(segmap.ravel(), neighbors).reshape(segmap.shape))
#calculating a bounding box over neghbor superpixels
bb_mid = np.array([[np.min(ix[0]), np.max(ix[0])],
[np.min(ix[1]), np.max(ix[1])]])
#cropping the bounding box - this is the input to the 2nd mini CNN
bounding_box_second = np.copy(img[bb_mid[0, 0]:bb_mid[0, 1],
bb_mid[1, 0]:bb_mid[1, 1]])
#mean subtraction on region B
bounding_box_second = bounding_box_second - mean_image[bb_mid[
0, 0]:bb_mid[0, 1], bb_mid[1, 0]:bb_mid[1, 1]]
#resizing superpixel to net input size
pair.SP_Region = np.array(sp.misc.imresize(
seg_img, [227, 227, 3])) #,dtype = np.uint8)
#resizing neighborhood to net input size
pair.SP_Neighbor = np.array(
sp.misc.imresize(bounding_box_second,
[227, 227, 3])) #,dtype = np.uint8)
#picture with segment masked
picture = np.copy(img) - mean_image
picture[segmap == curr_sp, :] = 0
pair.Pic = np.array(sp.misc.imresize(
picture, [227, 227, 3])) #,dtype = np.uint8)
#pair.saliency = round(saliency_score)
pair.SP_mask = sp.misc.imresize(sp_mask, [227, 227, 3])
result.segments.append(pair)
return result
import cv2
import numpy as np
img = cv2.imread('pic1.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(gray, 25, 0.01, 10) #(img, max_no_of_Corners, quality_level, min_distance)
corners = np.uint0(corners) # int64
for i in corners:
x, y = i.ravel()
cv2.circle(img, (x,y), 3, 255, -1)
cv2.imshow('dst', img)
if cv2.waitKey(0) &0xFF ==27:
cv2.destroyAllWindows()
def deal_contours_image(image_path):
# image = cv2.imread(image_path, 1)
image = cv2.imdecode(np.fromfile(image_path, dtype=np.uint8),
cv2.IMREAD_UNCHANGED)
if opt.show_image:
cv2.imshow('crc', image)
# cv2.imshow("ori", image)
#保留原图，用于显示图像
img = image.copy()
# #保存原图，用于裁剪图片
img1 = image.copy()
image = image[:, :, 2]
image_name = os.path.split(image_path)[-1]
# 阈值处理后的图片
# thresh_image = threshTwoPeaks1(image)
# cv2.imshow('thresh_image',thresh_image)
print(image_name)
# 高斯平滑
image = cv2.GaussianBlur(image, (3, 3), 0.5)
#中值滤波,消除椒盐噪声。速度慢
# image = mediaBlur(image,(3,3))
# 膨胀处理，过滤细小竖直边线
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 1))
image = cv2.dilate(image, kernel)
# cv2.imshow("dilate", image)
# 边缘检测，找出明显轮廓。
image = cv2.Canny(image, 60, 80)
if opt.show_image:
cv2.namedWindow("Canny", flags=1)
cv2.imshow("Canny", image)
# 膨胀处理，将紧挨着的边线合并，用于后续寻找外轮廓
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 20))
image = cv2.dilate(image, kernel)
# cv2.imshow('canny', image)
#寻找外轮廓
hc = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = hc[1]
print('轮廓数：', len(contours))
for i in range(len(contours)):
# 绘制轮廓
# cv2.drawContours(img, contours, i, 255, 2)
# 获取最小旋转矩形
# points = cv2.minAreaRect(contours[i])
# # 计算旋转矩形4个顶点坐标
# rect = cv2.boxPoints(points)
#计算最小外包直立矩形
rect = cv2.boundingRect(contours[i])
print(rect)
# 数据类型转换
rect = np.uint0(rect)
# 绘制矩形
#旋转矩形4个顶点
# cv2.drawContours(img, [rect], 0, (0, 255, 0), 2)
# 直立矩形对角点
x1 = rect[0]
x2 = rect[0] + rect[2]
y1 = rect[1]
y2 = rect[1] + rect[3]
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 1)
global num
num = num + 1
if rect[3] > 600:
continue
cv2.imwrite('./datas/{}_A.jpg'.format(num),
img1[y1:y2, x1:x2]) ######修改图片保存路径
if opt.show_image:
show_image(image_name, img)
img_contour, contours, hierarchys = cv2.findContours(
img_dilate, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) #查找轮廓
"""================轮廓处理，通过轮廓外包矩行，符合一定长宽比的前提下取最大矩形面积即为二维码区域=============="""
Area = 0
for i in range(len(contours)):
x, y, w, h = cv2.boundingRect(contours[i]) #轮廓外包矩形
if ((w / h > 0.8) & (h / w > 0.8)): #符合一定长宽比前提下取最大面积
if (Area < w * h):
Area = w * h
index = i
"""绘制了二维码的外包矩形以及最小外包矩形"""
x, y, w, h = cv2.boundingRect(contours[index]) #轮廓外包正矩形
cv2.rectangle(img_color, (x, y), (x + w, y + h), (0, 0, 255), 2)
rect = cv2.minAreaRect(contours[index]) #轮廓最小外包矩形
box = cv2.boxPoints(rect) #矩形点转成四个矩形的四个顶点表示
box = np.uint0(box)
cv2.drawContours(img_color, [box], 0, (255, 0, 0), 2)
"""创建只有二维码区域的mask,然后在mask再进行一次查找轮廓，通过层级关系定位出三个定位点，并绘制矩形和连接三个定位点"""
img_mask = np.zeros(img_ostu.shape, np.uint8)
img_mask[y:y + h, x:x + w] = img_ostu[y:y + h, x:x + w]
mask_contour, contours_mask, hierarchys_mask = cv2.findContours(
img_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
hierarchys_mask = hierarchys_mask[0]
#筛选出包含一个子层级的轮廓
found = []
for i in range(len(contours_mask)):
k = i
count = 0
while hierarchys_mask[k][2] != -1:
k = hierarchys_mask[k][2]
count += 1
