def draw_warped_image(self, index):
self.refresh_buttons_number()
# print("Warp arguments=============================================")
# for i in range(self.N_WARP):
# self.target[i].print()
dewarped = self.image
if self.grid_mode:
dewarped = np.array(self.grid_image)
dewarped = self.dewarp_image(dewarped,
self.warps[index],
self.img_size,
ratio=self.img_size[0] /
self.img_plane_size[0])
row = int(index / self.DIVISION_COL)
col = index % self.DIVISION_COL
# Divide image
x = int(self.img_division_size[X] * col)
y = int(self.img_division_size[Y] * row)
width = self.img_division_size[X]
height = self.img_division_size[Y]
self.warped_img[index] = dewarped[y:y + height, x:x + width]
division_pos = self.division_pos(index)
cu.copy_to(
cv2.resize(
self.warped_img[index],
tuple(
(self.img_division_size *
(self.img_plane_size / self.img_size)).astype(np.int32)),
cv2.INTER_LINEAR), self.canvas, division_pos)
warp = self.warps[self.selected_division][self.selected_warp]
self.pos_buttons[self.selected_warp][0].left_top = \
(self.img_plane_size[1] + int(warp.CDC[6] - 10),
int(warp.CDC[9] - 10) + 150)
self.pos_buttons[self.selected_warp][0].right_bottom = \
(self.img_plane_size[1] + int(warp.CDC[6] + 10),
int(warp.CDC[9] + 10) + 150)
self.pos_buttons[self.selected_warp][1].left_top = \
(self.img_plane_size[1] + int(warp.CDC[15] - 7),
int(warp.CDC[18] - 7) + 150)
self.pos_buttons[self.selected_warp][1].right_bottom = \
(self.img_plane_size[1] + int(warp.CDC[15] + 7),
int(warp.CDC[18] + 7) + 150)
self.pos_buttons[self.selected_warp][0].draw()
self.pos_buttons[self.selected_warp][1].draw()
def load_image(self):
path = self.img_path + self.image_files[self.image_index]
self.image = cv2.imread(path, cv2.IMREAD_COLOR)
if self.image is None:
print('Cannot read image \'' + path + '\'')
return False
print('Load ', self.image_files[self.image_index])
cu.copy_to(self.resize_img(self.image), self.canvas, (0, 150))
return True
def toggle_grid(self):
self.grid_mode = not self.grid_mode
if self.grid_mode:
grid_image = np.array(self.resize_img(self.image))
self.draw_grid(grid_image)
cu.copy_to(src_image=grid_image,
dst_image=self.canvas,
position=(0, 150))
else:
cu.copy_to(src_image=self.resize_img(self.image),
dst_image=self.canvas,
position=(0, 150))
def refresh_warped_image(self, except_img_idx=-1):
for i in range(self.DIVISION_SIZE):
if i is not except_img_idx:
row = int(i / self.DIVISION_COL)
col = i % self.DIVISION_COL
cu.copy_to(
cv2.resize(
self.warped_img[i],
self.img_division_size *
(self.img_size / self.img_plane_size),
cv2.INTER_LINEAR), self.canvas,
(self.img_plane_size[Y] +
int(self.img_division_size[X] * col),
150 + int(self.img_division_size[Y] * row)))
def load_image(self):
self.image = cv2.imread(self.original_path + '/' +
self.original_files[self.file_index])
self.segmentation = cv2.imread(
self.segmentation_path + '/' +
self.segmentation_files[self.file_index])
augment_img = cv2.resize(src=self.image * (1 - self.seg_ratio) +
self.segmentation * self.seg_ratio,
dsize=self.image_plane_size)
# augment_img = self.image * 0.7 + self.segmentation * 0.3
self.check_button.draw(text=str(self.check_seg[self.file_index][1]))
cu.copy_to(src_image=augment_img,
dst_image=self.canvas,
position=(0, 0))
print(self.segmentation_files[self.file_index])
cv2.imshow('DB Checker', self.canvas)
def __init__(self, window_name, image_path):
self.image_index = 0
self.N_WARP = 3
self.selected_division = 0
self.selected_warp = 0
self.symmetric_mode = False
self.grid_mode = False
self.perspective_mode = True
self.sym_select = 0
self.DIVISION_ROW = 1
self.DIVISION_COL = 1
self.DIVISION_SIZE = self.DIVISION_ROW * self.DIVISION_COL
self.window_name = window_name
self.image = None
self.grid_image = None
self.canvas = np.zeros((1150, 2000, 3), np.uint8)
self.number_of_grid = 10
self.grid_points_per_line = 300
self.img_size = np.array([1920, 1920])
self.img_plane_size = np.array([1000, 1000])
self.img_margin = 23
self.img_division_size = np.array([
int(self.img_size[0] / self.DIVISION_COL),
int(self.img_size[1] / self.DIVISION_ROW)
])
self.warp_buttons = []
self.warp_select_buttons = []
self.pos_buttons = []
self.lmouse_pressed = False
self.video_play = False
self.warps = []
self.warped_img = []
self.target = []
self.sym_target = []
self.grid_points = []
# Load image
self.img_path = image_path
self.image_files = listdir(self.img_path)
self.img_save_path = "dewarpedImage/" + image_path
self.load_image()
# Draw grid image
r = self.img_plane_size[X] / 2.0 - self.img_margin
for g in range(self.number_of_grid):
k = (g + 1) * 0.1
temp_pts = []
for i in range(4):
temp_pts.append([])
# (x - w/2)^2 + k(y - h/2)^2 = r
for pt in range(self.grid_points_per_line + 1):
x = (r * 2) / self.grid_points_per_line * pt
y = math.sqrt((pow(r, 2.0) - pow(x - (r * 2) / 2.0, 2.0)) *
k) + (r * 2) / 2.0
temp_pts[0].append((self.img_margin + x, self.img_margin + y))
temp_pts[1].append((self.img_margin + y, self.img_margin + x))
temp_pts[2].append(
(self.img_margin + x, self.img_margin + (r * 2) - y))
temp_pts[3].append(
(self.img_margin + (r * 2) - y, self.img_margin + x))
for i in range(4):
temp_pts[i] = np.array(temp_pts[i], np.int32)
temp_pts[i] = temp_pts[i].reshape((-1, 1, 2))
self.grid_points.append(temp_pts[i])
self.grid_image = np.array(self.image)
self.draw_grid(self.grid_image)
# Make Warp objects
for d in range(self.DIVISION_SIZE):
self.warps.append([])
for w in range(self.N_WARP):
self.warps[d].append(
cu.Warp(self.img_division_size[X],
self.img_division_size[Y]))
file_name = 'warp_attr' + str(d) + '_' + str(w) + '.npy'
if os.path.isfile(file_name):
self.warps[d][w].set_attr_array(np.load(file_name))
# Set target division
for w in range(self.N_WARP):
self.target.append(self.warps[0][w])
self.sym_target.append(self.warps[0][w])
warp = self.warps[0][0]
# Draw buttons at canvas
for i in range(warp.CDC.size):
off = 0
if i >= warp.D.size:
off = 1
if i >= warp.C.size + warp.D.size:
off = 2
if i >= warp.D.size + warp.C.size + warp.Cnew.size:
off = 3
button = []
for w in range(self.N_WARP):
button.append(
cu.Button(canvas=self.canvas,
left_top=(50 * i, 50 * w),
size=(50, 50),
color=(i * 2 + 20 * off + 30 * w,
i * 5 + 20 * off + 20 * w,
i * 7 + 30 * off + 5 * w * w)))
button[w].draw()
self.warp_buttons.append(button)
self.save_button = cu.Button(canvas=self.canvas,
left_top=(2000 - 50, 0),
size=(50, 50),
color=(50, 50, 255),
text='Save')
self.save_button.set_function(self.save_warp_attr)
self.save_button.draw()
self.symmetry_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(200, 50, 10),
text='Sym')
self.symmetry_button.locate_left(self.save_button)
self.symmetry_button.set_function(self.toggle_symmetric)
self.symmetry_button.toggle = True
self.symmetry_button.draw()
self.grid_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(50, 200, 10),
text='Grid')
self.grid_button.locate_left(self.symmetry_button)
self.grid_button.set_function(self.toggle_grid)
self.grid_button.toggle = True
self.grid_button.draw()
self.perspective_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(100, 100, 100),
text='Persp')
self.perspective_button.locate_left(self.grid_button)
self.perspective_button.set_function(self.toggle_perspective)
self.perspective_button.toggle = True
self.perspective_button.draw()
self.play_pause_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(100, 100, 100),
text='||')
self.play_pause_button.locate_left(self.perspective_button)
self.play_pause_button.set_function(self.toggle_play_pause)
self.play_pause_button.toggle = True
self.play_pause_button.draw()
self.position_button = cu.Button(canvas=self.canvas,
left_top=(self.canvas.shape[1] - 150,
100),
size=(150, 50),
color=(0, 0, 0),
text='0/0')
self.grid_button.draw()
self.next_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(150, 150, 150),
text='>')
self.next_button.locate_left(self.position_button)
self.next_button.set_function(self.load_next_file)
self.next_button.draw()
self.prev_button = cu.Button(canvas=self.canvas,
size=(50, 50),
color=(150, 150, 150),
text='<')
self.prev_button.locate_left(self.next_button)
self.prev_button.set_function(self.load_prev_file)
self.prev_button.draw()
# Make buttons
for w in range(self.N_WARP):
cam_pos_button = cu.Button(canvas=self.canvas,
left_top=(self.img_plane_size[1] +
int(warp.CDC[6] - 10),
int(warp.CDC[9]) + 150),
size=(10, 10),
color=(0, 255, 0))
new_cam_pos_button = cu.Button(canvas=self.canvas,
left_top=(self.img_plane_size[1] +
int(warp.CDC[15]),
int(warp.CDC[18]) + 150),
size=(10, 10),
color=(255, 0, 0))
self.pos_buttons.append((cam_pos_button, new_cam_pos_button))
warp_select_button = cu.Button(
canvas=self.canvas,
left_top=(50 *
(warp.D.size + warp.C.size + warp.Cnew.size + 1),
50 * w),
size=(50, 50),
color=(125, 125, 0),
text=str(w + 1))
warp_select_button.toggle = True
warp_select_button.draw()
self.warp_select_buttons.append(warp_select_button)
self.warp_select_buttons[0].press()
self.warp_select_buttons[0].release()
# Draw number on buttons
self.refresh_buttons_number()
# # Load video
# self.video_path = "D:/Samsung Heavy Industry Dataset/2017-10-28_12-00_PORTx6.mkv"
# self.video_capture = cv2.VideoCapture(self.video_path)
self.perspective_pts1 = np.float32([[40, 450], [150, 900], [960, 450],
[850, 900]])
self.perspective_pts2 = np.float32([[0, 300], [300, 800], [1000, 300],
[700, 800]])
self.perspective_pts3 = np.float32([[0, 500], [0, 1000], [1000, 500],
[1000, 1000]])
self.perspective_pts4 = np.float32([[0, 500], [300, 1000], [1000, 500],
[700, 1000]])
# Make dewarp image
for i in range(0, self.DIVISION_SIZE):
self.warped_img.append(None)
self.draw_warped_image(i)
# Draw red box at selected division
self.draw_division_box(self.selected_division)
# fps = 120 # int(self.video_capture.get(cv2.CAP_PROP_FPS))
# video_length = int(self.video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
# width = int(self.video_capture.get(cv2.CAP_PROP_FRAME_WIDTH))
# height = int(self.video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
# end = False
# print(fps, video_length, width, height)
# while not end:
# frame_number = 0
# self.video_capture.set(cv2.CAP_PROP_POS_FRAMES, 0)
# while True:
# frame_number += 1
# print(frame_number, '/', video_length)
# ret, frame = self.video_capture.read()
# if ret is False:
# break
#
# dewarped = frame
#
# dewarped = self.dewarp_image(dewarped, self.warps[0], self.img_size, 1.92)
#
# division_pos = self.division_pos(0)
# cu.copy_to(
# cv2.resize(dewarped, tuple(self.img_plane_size), cv2.INTER_LINEAR),
# self.canvas,
# division_pos
# )
#
# cu.copy_to(self.resize_img(frame), self.canvas, [0, 150])
# cv2.imshow(self.window_name, self.canvas)
#
# # 50 fps.
# while not self.video_play:
# k = cv2.waitKey(int(20))
# if k == 27:
# cv2.destroyAllWindows()
# end = True
# break
# if end:
# break
#
# k = cv2.waitKey(int(1000 / fps))
# if k == 27:
# cv2.destroyAllWindows()
# end = True
# break
# if 48 <= k <= 57:
# self.video_capture.set(cv2.CAP_PROP_POS_FRAMES, int((k - 48) * (video_length / 10)))
# frame_number = int((k - 48) * (video_length / 10))
# k = cv2.waitKey()
# Draw and show image
cu.show_image(content=self.canvas,
window_name=self.window_name,
option=cv2.WINDOW_AUTOSIZE,
mouse_callback=self.mouse_callback)
# Save dewarped image
for i in range(self.DIVISION_SIZE):
row = int(i / self.DIVISION_COL)
col = i % self.DIVISION_COL
cu.copy_to(self.warped_img[i], self.image,
(self.img_division_size[X] * col,
self.img_division_size[Y] * row))
cv2.imwrite(self.img_save_path, self.image)
self.threads_kill = True
# self.video_capture.release()
cv2.destroyAllWindows()