def __init__(self) -> None:
'''Initialize new Target class instance'''
# camera settings
self.run = True
self.camera = cv.VideoCapture(0, cv.CAP_DSHOW)
self.key_cap = ord('s')
# work images and its parameters
self.image = self.camera.read()[1]
self.result = self.image.copy()
self.mask = self.image.copy()
self.hsv = cv.cvtColor(self.image, cv.COLOR_BGR2HSV)
self.width, self.height = self.image.shape[:2]
# gui window parameters
self.window_name = 'GUI'
self.window = cv.namedWindow(self.window_name)
# calibration trackbar
self.calibrate, _ = 0, cv.createTrackbar('Calibrate', self.window_name,
0, 1, self.on_trackbar)
cv.setTrackbarMin('Calibrate', self.window_name,
0), cv.setTrackbarPos('Calibrate', self.window_name,
0)
# sensivity trackbar
self.sensitivity, _ = 18, cv.createTrackbar('Sensitivity',
self.window_name, 0, 40,
self.on_trackbar)
cv.setTrackbarMax('Sensitivity', self.window_name,
40), cv.setTrackbarPos('Sensitivity',
self.window_name, 18)
# other parameters
self.target_min_area = 700
def TargetWindow(self):
if len(self.target_image_list) > 0:
title = 'Tagets'
cv.namedWindow(title)
cv.createTrackbar('index', title, 0, len(self.target_image_list)-1, self._onChange)
while True:
index = cv.getTrackbarPos('index',title)
cv.imshow(title, self.target_image_list[index])
key = cv.waitKey(1)
if key == 27 or cv.getWindowProperty(title, cv.WND_PROP_VISIBLE) < 1:
break
elif key == ord('d') or key == ord('D'):
self.DeleteTarget(index)
if len(self.target_image_list) > 0:
cv.setTrackbarMax('index', title, len(self.target_image_list)-1)
cv.setTrackbarPos('index', title, 0)
else:
break
elif key == 9:
index = cv.getTrackbarPos('index', title)
if index < (len(self.target_image_list)-1):
cv.setTrackbarPos('index', title, index+1)
else:
cv.setTrackbarPos('index', title, 0)
cv.destroyWindow(title)
def adjust_trackbar(self):
# check whether current frame outside focus
if not self.frame_current_batch == self.check_batchnum(
self.current_frame):
print("reloading frames")
self.frame_current_batch = self.check_batchnum(self.current_frame)
self.load_frames(
self.frame_buffer * self.frame_current_batch,
self.frame_buffer * (self.frame_current_batch + 1),
)
self.current_mask_focus = 0
cv2.setTrackbarPos("Global Slider", self.window_name,
self.current_frame)
if (not self.local_slider_lower_window < self.current_frame <
self.local_slider_higher_window):
self.local_slider_lower_window = (self.current_frame -
self.local_slider_window)
self.local_slider_higher_window = (self.current_frame +
self.local_slider_window)
cv2.setTrackbarMin(
"Local Slider",
winname=self.window_name,
minval=self.local_slider_lower_window,
)
cv2.setTrackbarMax(
"Local Slider",
winname=self.window_name,
maxval=self.local_slider_higher_window,
)
cv2.setTrackbarPos("Local Slider", self.window_name,
self.current_frame)
def last_slice_tbcb(self, x):
if x <= self.first_slice:
x = self.first_slice + 1
cv2.setTrackbarPos('last', self.window_name, x)
self.last_slice = x
cv2.setTrackbarMax('slices', self.window_name, x)
cv2.setTrackbarPos('slices', self.window_name, x)
def AddSlider(sliderName, windowName, minSlider, maxSlider, valDefault,
update):
cv.createTrackbar(sliderName, windowName, valDefault,
maxSlider - minSlider + 1, update)
cv.setTrackbarMin(sliderName, windowName, minSlider)
cv.setTrackbarMax(sliderName, windowName, maxSlider)
cv.setTrackbarPos(sliderName, windowName, valDefault)
def update_category(category_id):
global g_image_filenames, g_category_id
g_category_id = category_id
g_image_filenames = glob.glob(category_folders[category_id] + '/*.jpg')
cv.createTrackbar("image", 'marker', 0,
len(g_image_filenames) - 1, update_image)
cv.setTrackbarMax('image', 'marker', len(g_image_filenames) - 1)
update_image(0)
def update_image(_):
hist_shape = f[keys[cv2.getTrackbarPos('bins',
'Histogram lines')]].shape
cv2.setTrackbarMax('range start x', 'Histogram lines',
hist_shape[1] - 1)
cv2.setTrackbarPos(
'range start x', 'Histogram lines',
min(cv2.getTrackbarPos('range start x', 'Histogram lines'),
hist_shape[1] - 1))
cv2.setTrackbarMax('range stop x', 'Histogram lines',
hist_shape[1] - 1)
cv2.setTrackbarPos(
'range stop x', 'Histogram lines',
min(cv2.getTrackbarPos('range stop x', 'Histogram lines'),
hist_shape[1] - 1))
cv2.setTrackbarMax('range start y', 'Histogram lines',
hist_shape[0] - 1)
cv2.setTrackbarPos(
'range start y', 'Histogram lines',
min(cv2.getTrackbarPos('range start y', 'Histogram lines'),
hist_shape[0] - 1))
cv2.setTrackbarMax('range stop y', 'Histogram lines',
hist_shape[0] - 1)
cv2.setTrackbarPos(
'range stop y', 'Histogram lines',
min(cv2.getTrackbarPos('range stop y', 'Histogram lines'),
hist_shape[0] - 1))
update(42)
def ajouter_glissiere(nom_glissiere,
nom_fenetre,
min_glissiere,
max_glissiere,
val_defaut,
fct_glissiere=None):
if fct_glissiere:
cv.createTrackbar(nom_glissiere, nom_fenetre, val_defaut,
max_glissiere - min_glissiere + 1, fct_glissiere)
else:
cv.createTrackbar(nom_glissiere, nom_fenetre, val_defaut,
max_glissiere - min_glissiere + 1,
lambda *args: None)
cv.setTrackbarMin(nom_glissiere, nom_fenetre, min_glissiere)
cv.setTrackbarMax(nom_glissiere, nom_fenetre, max_glissiere)
cv.setTrackbarPos(nom_glissiere, nom_fenetre, val_defaut)
def findroi():
write_video = False
# Giving name to the window with Track Bars
# And specifying that window is resizable
cv2.namedWindow('Track Bars', cv2.WINDOW_NORMAL)
cv2.createTrackbar('x', 'Track Bars', 0, 255, do_nothing)
cv2.createTrackbar('y', 'Track Bars', 0, 255, do_nothing)
cv2.createTrackbar('width', 'Track Bars', 0, 720, do_nothing)
#read the first image
cap = cv2.VideoCapture(FLAGS.input)
ret, frame_orig = cap.read()
cv2.setTrackbarMax('x', 'Track Bars', frame_orig.shape[0])
cv2.setTrackbarMax('y', 'Track Bars', frame_orig.shape[1])
cv2.setTrackbarPos('width', 'Track Bars', FLAGS.width)
while True:
x = cv2.getTrackbarPos('x', 'Track Bars')
y = cv2.getTrackbarPos('y', 'Track Bars')
width = cv2.getTrackbarPos('width', 'Track Bars')
frame_new = frame_orig.copy()
pt1 = (x, y)
pt2 = (x + width, y + width)
cv2.rectangle(frame_new, pt1, pt2, (0, 255, 0), 1)
cv2.imshow("Output", frame_new)
key = cv2.waitKey(1) & 0xFF
if key == ord('w'):
write_video = True
break
elif key == ord('q'):
write_video = False
break
logging.info(f"x: {x}")
logging.info(f"y: {y}")
logging.info(f"width: {width}")
cap.release()
if write_video:
outputvideo(int(x), int(y), int(width))
def on_change_global(self, int):
self.current_frame = int
cv2.setTrackbarPos("Global Slider", self.window_name, int)
if not self.local_slider_lower_window < int < self.local_slider_higher_window:
self.local_slider_lower_window = int - self.local_slider_window
self.local_slider_higher_window = int + self.local_slider_window
cv2.setTrackbarMin(
"Local Slider",
winname=self.window_name,
minval=self.local_slider_lower_window,
)
cv2.setTrackbarMax(
"Local Slider",
winname=self.window_name,
maxval=self.local_slider_higher_window,
)
cv2.setTrackbarPos("Local Slider", self.window_name, int)
def __change_frames__(self, *args):
label = cv2.getTrackbarPos("label", self.WINDOWS_CONTROLS)
stop_label = cv2.getTrackbarPos("stop_label", self.WINDOWS_CONTROLS)
direction = cv2.getTrackbarPos("direction", self.WINDOWS_CONTROLS)
round_number = cv2.getTrackbarPos("round_number", self.WINDOWS_CONTROLS)
error = cv2.getTrackbarPos("error", self.WINDOWS_CONTROLS)
self.patches = self.orig_patches
if error == 1: # False positive
self.patches = self.patches[np.logical_and(self._labels == 1, self._scores >= self._thresh)]
elif error == 2: # False negative
self.patches = self.patches[np.logical_and(self._labels == 2, self._scores < self._thresh)]
if label == 0:
self.patches = self.patches.unknown_anomaly
elif label == 1:
self.patches = self.patches.no_anomaly
elif label == 2:
self.patches = self.patches.anomaly
if stop_label == 0:
self.patches = self.patches.stop_ok
elif stop_label == 1:
self.patches = self.patches.stop_dont
elif stop_label == 2:
self.patches = self.patches.stop_do
if direction == 0:
self.patches = self.patches.direction_unknown
elif direction == 1:
self.patches = self.patches.direction_ccw
elif direction == 2:
self.patches = self.patches.direction_cw
if round_number != -1:
self.patches = self.patches.round_number(round_number)
cv2.setTrackbarPos("index", self.WINDOWS_CONTROLS, 0)
cv2.setTrackbarMax("index", self.WINDOWS_CONTROLS, max(0, self.patches.shape[0] - 1))
self.__maha__(only_refresh_image=True)
self.__draw__()
def on_mouse(event ,x,y,flag,param):
#print('(x,y)={},{}'.format(x, y))
if event == cv.EVENT_MOUSEMOVE:
#print('EVENT_MOUSEMOVE')
pass
elif event == cv.EVENT_LBUTTONDOWN:
print('EVENT_LBUTTONDOWN')
cv.setTrackbarMin('test', winname, 100)
elif event == cv.EVENT_RBUTTONDOWN:
print('EVENT_RBUTTONDOWN')
cv.setTrackbarMax('test', winname, 255)
elif event == cv.EVENT_MBUTTONDOWN:
print('EVENT_MBUTTONDOWN')
import random
pos = random.randint(100, 255)
cv.setTrackbarPos('test',winname, pos)
elif event == cv.EVENT_LBUTTONUP:
print('EVENT_LBUTTONUP')
elif event == cv.EVENT_RBUTTONUP:
print('EVENT_RBUTTONUP')
elif event == cv.EVENT_MBUTTONUP:
print('EVENT_MBUTTONUP')
elif event == cv.EVENT_LBUTTONDBLCLK:
print('EVENT_LBUTTONDBLCLK')
elif event == cv.EVENT_RBUTTONDBLCLK:
print('EVENT_RBUTTONDBLCLK')
elif event == cv.EVENT_MBUTTONDBLCLK:
print('EVENT_MBUTTONDBLCLK')
elif event == cv.EVENT_MOUSEWHEEL:
print('EVENT_MOUSEWHEEL')
if flag == cv.EVENT_FLAG_LBUTTON:
print('EVENT_FLAG_LBUTTON')
elif flag == cv.EVENT_FLAG_RBUTTON:
print('EVENT_FLAG_RBUTTON')
elif flag == cv.EVENT_FLAG_MBUTTON:
print('EVENT_FLAG_MBUTTON')
elif flag == cv.EVENT_FLAG_CTRLKEY:
print('EVENT_FLAG_CTRLKEY')
elif flag == cv.EVENT_FLAG_SHIFTKEY:
print('EVENT_FLAG_SHIFTKEY')
elif flag == cv.EVENT_FLAG_ALTKEY:
print('EVENT_FLAG_ALTKEY')
def onScope(self, val):
self.scope = val
self.x1 = 0
self.y1 = 0
self.x2 = self.camSize[0] // self.scope
self.y2 = self.camSize[1] // self.scope
cv2.setTrackbarMax(widgetNames.Roi.x1, widgetNames.sizeTracks, self.x2)
cv2.setTrackbarMax(widgetNames.Roi.y1, widgetNames.sizeTracks, self.y2)
cv2.setTrackbarMax(widgetNames.Roi.x2, widgetNames.sizeTracks, self.x2)
cv2.setTrackbarMax(widgetNames.Roi.y2, widgetNames.sizeTracks, self.y2)
cv2.setTrackbarPos(widgetNames.Roi.x1, widgetNames.sizeTracks, 0)
cv2.setTrackbarPos(widgetNames.Roi.y1, widgetNames.sizeTracks, 0)
cv2.setTrackbarPos(widgetNames.Roi.x2, widgetNames.sizeTracks, self.x2)
cv2.setTrackbarPos(widgetNames.Roi.y2, widgetNames.sizeTracks, self.y2)
def value(self, val: int): cv2.setTrackbarMax(self.name, self.winname, val)
for video_file_path in video_files_path:
if video_file_path in saved_video_lines:
continue
data_list = list()
saved = False
if not IMAGE_CLASSIFICATION:
vehicle_control_file_path = video_file_path.split('.')[0] + '.txt'
vehicle_control_file = open(vehicle_control_file_path, 'r')
lines = vehicle_control_file.readlines()
vehicle_control_file.close()
frame_counter = -1
video = cv2.VideoCapture(video_file_path)
video.set(cv2.CAP_PROP_POS_FRAMES, 1)
video.set(cv2.CAP_PROP_FPS, 10)
number_of_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
cv2.setTrackbarMax('PLAYBACK', 'image', number_of_frames)
cv2.setTrackbarPos('PLAYBACK', 'image', 1)
playing = True
starting_frame = 0
ending_frame = 0
option = 0
while True:
video.set(cv2.CAP_PROP_POS_FRAMES, frame_counter)
video.grab()
flag, frame = video.retrieve()
cv2.setTrackbarPos('PLAYBACK', 'image', frame_counter)
if not flag or frame is None:
frame_counter -= 1
if flag:
if len(regions) == 1:
second = tuple([
def main():
width = 640
height = 480
if not os.path.exists('/dev/video0'):
path = 'sudo modprobe bcm2835-v4l2 max_video_width=640 max_video_height=480'
os.system(path)
allowed = {
ord("w"): forward,
ord("s"): back,
ord("a"): turn_left,
ord("d"): turn_right,
ord("f"): stop
}
print("Allowed only: {}".format(allowed.keys()))
cv2.namedWindow("camera")
camera = cv2.VideoCapture(0)
camera.set(3, width)
camera.set(4, height)
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
video_output = cv2.VideoWriter('./session.avi', fourcc, 30.0, (640, 480))
def set_motor_config(config_name, value):
motor_configs[config_name] = value / 100
for config in motor_configs:
update_config = bind(set_motor_config, config)
cur_value = motor_configs[config] * 100
cv2.createTrackbar(config, "camera", cur_value, 100, update_config)
cv2.setTrackbarMin(config, "camera", 0)
cv2.setTrackbarMax(config, "camera", 100)
action_time = None
action_timeout = 250
direction = []
while camera.isOpened():
_, frame = camera.read()
video_output.write(frame)
cv2.imshow("camera", frame)
key = cv2.waitKey(1) & 0xFF
if key in allowed.keys():
action_time = datetime.datetime.now()
if key not in direction:
direction.append(key)
allowed[key]()
print(allowed[key])
elif key == ord("q"):
stop()
camera.release()
video_output.release()
cv2.destroyAllWindows()
exit(0)
if action_time is not None and (datetime.datetime.now() - action_time
).microseconds / 1000 > action_timeout:
stop()
print("stop")
direction.clear()
action_time = None
def update(
_
): # Note: all colors are in BGR format, as this is what OpenCV uses
global scale_x, scale_y, last_bin
# Check if trackbar ranges should be updated
bin = cv2.getTrackbarPos('bins', 'Histogram lines')
hist = f[keys[bin]]
if bin != last_bin:
last_bin = bin
cv2.setTrackbarMax('range start x', 'Histogram lines',
hist.shape[1] - 1)
cv2.setTrackbarMax('range stop x', 'Histogram lines',
hist.shape[1] - 1)
cv2.setTrackbarMax('range start y', 'Histogram lines',
hist.shape[0] - 1)
cv2.setTrackbarMax('range stop y', 'Histogram lines',
hist.shape[0] - 1)
cv2.setTrackbarMax('line', 'Histogram lines', hist.shape[0] - 1)
cv2.setTrackbarPos('range start x', 'Histogram lines', 0)
cv2.setTrackbarPos('range stop x', 'Histogram lines',
hist.shape[1] - 1)
cv2.setTrackbarPos('range start y', 'Histogram lines', 0)
cv2.setTrackbarPos('range stop y', 'Histogram lines',
hist.shape[0] - 1)
cv2.setTrackbarPos('line', 'Histogram lines', 0)
# Show the original image, along with the line
range_x_start = cv2.getTrackbarPos('range start x', 'Histogram lines')
range_x_stop = cv2.getTrackbarPos('range stop x', 'Histogram lines')
range_y_start = cv2.getTrackbarPos('range start y', 'Histogram lines')
range_y_stop = cv2.getTrackbarPos('range stop y', 'Histogram lines')
selected_line = cv2.getTrackbarPos('line', 'Histogram lines')
hist_sum = np.sum(hist, axis=1)
hist_sum[hist_sum == 0] = 1
hist = hist / hist_sum[:, np.newaxis]
#disp_hist = hist/hist_sum[:,np.newaxis]
disp_hist = hist
display = ((disp_hist.astype(np.float32) / disp_hist.max()) *
255.0).astype(np.uint8)
partial_width = cv2.getTrackbarPos('size x', 'Histogram lines') // 3
partial_height = cv2.getTrackbarPos('size y', 'Histogram lines') // 2
partial_size = (partial_width, partial_height)
scale_x = partial_width / display.shape[1]
scale_y = partial_height / display.shape[0]
#hist = hist[range_y_start:range_y_stop,range_x_start:range_x_stop]
box_x_start = int(range_x_start * scale_x)
box_y_start = int(range_y_start * scale_y)
box_x_stop = int(range_x_stop * scale_x)
box_y_stop = int(range_y_stop * scale_y)
resized = cv2.resize(display, partial_size)
colored = cv2.cvtColor(resized, cv2.COLOR_GRAY2BGR)
colored = cv2.rectangle(colored, (box_x_start, box_y_start),
(box_x_stop, box_y_stop), (0, 255, 0), 1)
colored[int(selected_line * scale_y), :] = (0, 0, 255)
# Show the plot of a single line
line = disp_hist[selected_line, :]
min_height = .01 * cv2.getTrackbarPos('min peak height',
'Histogram lines') * line.max()
meaned, peaks = process_line(
line, cv2.getTrackbarPos('smooth', 'Histogram lines'), min_height)
fig, ax = plt.subplots()
#ax.axvspan(range_x_start, range_x_stop, color='green', alpha=0.1)
ax.plot(line[range_x_start:range_x_stop])
ax.plot(meaned[range_x_start:range_x_stop])
#peaks_filt = [peak for peak in peaks if peak > range_x_start and peak < range_
peaks_filt = peaks[(peaks > range_x_start)
& (peaks < range_x_stop)] - range_x_start
ax.scatter(peaks_filt, meaned[peaks_filt], c='red')
line_plot = mplfig_to_npimage(fig)
line_plot = cv2.cvtColor(line_plot, cv2.COLOR_RGB2BGR)
plt.close()
lp_resized = cv2.resize(line_plot, partial_size)
# Show the peaks scattered on the original
px = []
py = []
for i in np.arange(range_y_stop - range_y_start):
line = hist[i + range_y_start, :]
min_height = .01 * cv2.getTrackbarPos(
'min peak height', 'Histogram lines') * line.max()
_, peaks = process_line(
line, cv2.getTrackbarPos('smooth', 'Histogram lines'),
min_height)
peaks = [
peak - range_x_start for peak in peaks
if peak > range_x_start and peak < range_x_stop
]
py += [i for _ in np.arange(len(peaks))]
px += list(peaks)
fig, ax = plt.subplots()
ax.imshow(hist[range_y_start:range_y_stop, range_x_start:range_x_stop],
cmap='jet')
# TODO lav opacity
#ax.scatter(px, py)
scatter_plot = mplfig_to_npimage(fig)
scatter_plot = cv2.cvtColor(scatter_plot, cv2.COLOR_RGB2BGR)
plt.close()
sp_resized = cv2.resize(scatter_plot, partial_size)
first_row = np.concatenate((colored, lp_resized, sp_resized), axis=1)
local_scale_y = partial_height / (range_y_stop - range_y_start)
mask = np.zeros(
(range_y_stop - range_y_start, range_x_stop - range_x_start),
dtype=np.uint8)
mask[py, px] = 255
close_kernel = np.ones(
(cv2.getTrackbarPos('close kernel y', 'Histogram lines'),
cv2.getTrackbarPos('close kernel x', 'Histogram lines')))
dilated = cv2.dilate(mask,
close_kernel,
iterations=cv2.getTrackbarPos(
'iter dilate', 'Histogram lines'))
#display_dilated = cv2.cvtColor(dilated, cv2.COLOR_GRAY2BGR)
#display_dilated = cv2.resize(display_dilated, partial_size)
#if selected_line > range_y_start and selected_line < range_y_stop:
# display_dilated[int((selected_line-range_y_start)*local_scale_y),:] = (0,0,255)
eroded = cv2.erode(dilated,
close_kernel,
iterations=cv2.getTrackbarPos(
'iter erode', 'Histogram lines'))
display_eroded = cv2.resize(eroded, partial_size)
display_eroded = cv2.cvtColor(display_eroded, cv2.COLOR_GRAY2BGR)
if selected_line > range_y_start and selected_line < range_y_stop:
display_eroded[int(
(selected_line - range_y_start) * local_scale_y), :] = (0, 0,
255)
# Find joints
#joint_kernel_size = cv2.getTrackbarPos('joint kernel size', 'Histogram lines')
#horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (joint_kernel_size,1))
#horizontal = cv2.morphologyEx(eroded, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
#vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1,joint_kernel_size))
#vertical = cv2.morphologyEx(eroded, cv2.MORPH_OPEN, vertical_kernel, iterations=2)
#joints = cv2.bitwise_and(horizontal, vertical)
#display_joints = cv2.resize(joints, partial_size)
#display_joints = cv2.cvtColor(display_joints, cv2.COLOR_GRAY2BGR)
#if selected_line > range_y_start and selected_line < range_y_stop:
# display_joints[int((selected_line-range_y_start)*local_scale_y),:] = (0,0,255)
# Find lines
contours, _ = cv2.findContours(eroded, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
result = np.zeros(
(range_y_stop - range_y_start, range_x_stop - range_x_start, 3),
np.uint8)
for i in np.arange(len(contours)):
if cv2.contourArea(contours[i]) > cv2.getTrackbarPos(
'min contour size', 'Histogram lines'):
result = cv2.drawContours(
result, contours, i,
(np.random.randint(0, 255), np.random.randint(
0, 255), np.random.randint(0, 255)), -1)
display_result = cv2.resize(result, partial_size)
if selected_line > range_y_start and selected_line < range_y_stop:
display_result[int(
(selected_line - range_y_start) * local_scale_y), :] = (0, 0,
255)
skeleton = skeletonize(result)
skeleton_gray = cv2.cvtColor(skeleton, cv2.COLOR_BGR2GRAY)
skeleton_gray = cv2.threshold(skeleton_gray, 1, 255,
cv2.THRESH_BINARY)[1]
skeleton_gray = cv2.dilate(skeleton_gray, (3, 3), 10)
joint_kernel_size = cv2.getTrackbarPos('joint kernel size',
'Histogram lines')
horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
(joint_kernel_size, 1))
horizontal = cv2.morphologyEx(skeleton_gray,
cv2.MORPH_OPEN,
horizontal_kernel,
iterations=2)
vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
(1, joint_kernel_size))
vertical = cv2.morphologyEx(skeleton_gray,
cv2.MORPH_OPEN,
vertical_kernel,
iterations=2)
joints = cv2.bitwise_and(horizontal, vertical)
joints = cv2.dilate(joints, (10, 10), iterations=5)
display_joints = cv2.resize(joints, partial_size)
display_joints = cv2.cvtColor(display_joints, cv2.COLOR_GRAY2BGR)
if selected_line > range_y_start and selected_line < range_y_stop:
display_joints[int(
(selected_line - range_y_start) * local_scale_y), :] = (0, 0,
255)
#second_row = np.concatenate((display_dilated, display_eroded, display_result), axis=1)
#second_row = np.concatenate((display_eroded, display_result, display_joints), axis=1)
second_row = np.concatenate(
(display_eroded, display_result, display_joints), axis=1)
cv2.imshow('Histogram lines', np.concatenate((first_row, second_row)))
import cv2
import numpy as np
win_name = "Arithmatic"
trackbar_name = "Brightness"
def onChange(x):
img2 = cv2.add(img, x)
cv2.imshow(win_name, img2)
img = cv2.imread('../img/girl.jpg', cv2.IMREAD_GRAYSCALE)
cv2.imshow(win_name, img)
cv2.createTrackbar(trackbar_name, win_name, 0, 255, onChange)
cv2.setTrackbarMax(trackbar_name, win_name, 255)
cv2.setTrackbarMin(trackbar_name, win_name, -255)
cv2.setTrackbarPos(trackbar_name, win_name, 0)
cv2.waitKey()
cv2.destroyAllWindows()
def AddSlider(sliderName,windowName,minSlider,maxSlider,valDefault, update):
cv.createTrackbar(sliderName, windowName, valDefault,maxSlider-minSlider+1, update)
cv.setTrackbarMin(sliderName, windowName, minSlider)
cv.setTrackbarMax(sliderName, windowName, maxSlider)
cv.setTrackbarPos(sliderName, windowName, valDefault)
