def first_slice_tbcb(self, x):
if x >= self.last_slice:
x = self.last_slice - 1
cv2.setTrackbarPos('first', self.window_name, x)
self.first_slice = x
cv2.setTrackbarMin('slices', self.window_name, x)
cv2.setTrackbarPos('slices', self.window_name, x)
def main():
# Initialize a capture object
cap = cv.VideoCapture(CAPTURE_DEVICE_ID)
cv.namedWindow(CONTROL_WINDOW_NAME)
control_image = np.zeros((1, int(cap.get(cv.CAP_PROP_FRAME_WIDTH))),
np.uint8)
cv.imshow(CONTROL_WINDOW_NAME, control_image)
cv.createTrackbar('Alpha', CONTROL_WINDOW_NAME, 0, 200, update_alpha)
cv.setTrackbarPos('Alpha', CONTROL_WINDOW_NAME, 100)
cv.createTrackbar('Beta', CONTROL_WINDOW_NAME, 0, 200, update_beta)
cv.setTrackbarPos('Beta', CONTROL_WINDOW_NAME, 100)
cv.createTrackbar('Height', CONTROL_WINDOW_NAME, 0, 400, update_height)
cv.setTrackbarPos('Height', CONTROL_WINDOW_NAME, 100)
cv.setTrackbarMin('Height', CONTROL_WINDOW_NAME, 1)
cv.createTrackbar('Width', CONTROL_WINDOW_NAME, 0, 400, update_width)
cv.setTrackbarPos('Width', CONTROL_WINDOW_NAME, 100)
cv.setTrackbarMin('Width', CONTROL_WINDOW_NAME, 1)
cv.createTrackbar('Binary Threshold', CONTROL_WINDOW_NAME, 0, 255,
update_bthresh)
# Capture a first frame
success, frame = cap.read()
# If for some reason success is False then the capture
# doesn't work
while success:
# If you wanna do something to the frame you could
# do it in the something function before the imshow call
frame = something(frame)
# Display the captured frame
cv.imshow(WINDOW_NAME, frame)
# Wait for one milisecond for a keypress
key = cv.waitKeyEx(1)
# waitKeyEx() is used instead of waitKey() as it returns
# also the special keys like the arrow keys
# If a value of 0 or less is passed as a parameter it will
# wait forever for a keypress and stop the loop
# Check if Escape or Q is pressed to end the pain
if key in (ESC_KEY, ord('q'), ord('Q')):
# Cleanup
cv.destroyAllWindows()
# And release the capture
cap.release()
# This is good practice as an unrealesed capture might render
# the camera in use after termination and thus making it...
# unusable
# and kill the loop
break
update_status(key)
# Get the next frame
success, frame = cap.read()
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 build_display(self, image_on_display):
def click_event(event, x, y, flags, params):
image = params
if event == cv2.EVENT_LBUTTONDOWN:
blue = image[y, x, 0]
green = image[y, x, 1]
red = image[y, x, 2]
self.image_holder.assign_median_color([blue, green, red])
strRGB = str(red) + "," + str(green) + "," + str(blue)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, strRGB, (x, y), font, 1, (255, 255, 255), 2)
cv2.imshow(self.window_name, image)
if event == cv2.EVENT_RBUTTONDOWN:
self.reset_display()
cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
cv2.createTrackbar(self.SIGMA, self.window_name, 0, 100,
self.trackbar_handler)
cv2.createTrackbar(self.DELTA, self.window_name, 10, 100,
self.trackbar_handler)
cv2.setTrackbarMin(self.DELTA, self.window_name, 10)
cv2.createTrackbar(self.ALPHA, self.window_name, 0, 1,
self.trackbar_handler)
cv2.setMouseCallback(self.window_name, click_event, image_on_display)
cv2.imshow(self.window_name, image_on_display)
def __init__(self, srcImg, modelPath, device="CPU"):
self.wnd_name = "Inpainting demo (press H for help)"
self.mask_color = (255, 0, 0)
self.radius = 10
self.old_point = None
self.inpainter = ImageInpainting(IECore(), modelPath, device)
self.img = cv2.resize(
srcImg, (self.inpainter.input_width, self.inpainter.input_height))
self.original_img = self.img.copy()
self.label = ""
self.mask = np.zeros(
(self.inpainter.input_height, self.inpainter.input_width, 1),
dtype=np.float32)
cv2.namedWindow(self.wnd_name, cv2.WINDOW_AUTOSIZE)
cv2.setMouseCallback(self.wnd_name, self.on_mouse)
cv2.createTrackbar("Brush size", self.wnd_name, self.radius, 30,
self.on_trackbar)
cv2.setTrackbarMin("Brush size", self.wnd_name, 1)
self.is_help_shown = False
self.is_original_shown = False
self.is_inpainted = False
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 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 __generateTrackbars(self):
cv2.createTrackbar('Distance', self.__previewWinName, 0, 255,
self.onChange)
cv2.createTrackbar('Angle', self.__previewWinName, 1, 89,
self.onChange)
cv2.setTrackbarMin('Angle', self.__previewWinName, 1)
cv2.createTrackbar('Center', self.__previewWinName, 0,
self.__imgSize[0], self.onChange)
def on_control_create(self, param):
'''
Create a control that represents a tracked param.
'''
param.trackbar = cv2.createTrackbar(param.name, self.window,
param.default, param.max,
param.set_value)
cv2.setTrackbarMin(param.name, self.window, param.min)
def changeCannyMin(x):
global thresh, cannyMin, cannyMax
cannyMin = x
cannyMax = x + 50
#thresh = cv2.Canny(gray, cannyMin, cannyMax)
cv2.setTrackbarMin('Umbral Maximo', 'ULA VISION 2016', cannyMin + 1)
#cv2.setTrackbarMax('Canny Thresh Max', 'ULA VISION 2016', cannyMax)
cv2.setTrackbarPos('Umbral Maximo', 'ULA VISION 2016', cannyMax)
#thresh = cv2.threshold(blurred, cannyMin, cannyMax, cv2.THRESH_BINARY)[1]
#cv2.imshow('ULA VISION 2016', thresh)
process_image()
def show(self):
"""Shows the window."""
assert self.show_window or (
not self.show_window and len(self.params) == 0)
if self.show_window:
cv2.namedWindow(self.name)
if self.show_controls:
for param in self.params:
cv2.createTrackbar(param.name, self.name,
param.default, param.maximum, self.__nop)
cv2.setTrackbarMin(param.name, self.name, param.minimum)
def tune_thresholds(vid_feed, thresholds):
"""DOCSTRING"""
# initialize window
win = 'Adjustment Control Panel'
cv2.namedWindow(win)
# initialize variables and trackbars
thresh_names = ['H_LO', 'H_HI',
'S_LO', 'S_HI',
'V_LO', 'V_HI']
blur_k_name = 'BLUR \'K\''
max_vals = [179, 179, 255, 255, 255, 255]
for thresh, val, max_val in zip(thresh_names,
thresholds,
max_vals):
cv2.createTrackbar(thresh, win, val, max_val, empty_callback)
cv2.createTrackbar(blur_k_name, win,
cf['blur_k']['initial'],
cf['blur_k']['max'],
empty_callback)
cv2.setTrackbarMin(blur_k_name, win, 1)
thresh_vals = None
keypress = -1
while keypress == -1:
__, frame = vid_feed.read()
# blur frame
blur_k = cv2.getTrackbarPos(blur_k_name, win)
frame_blur = cv2.blur(frame, (blur_k, blur_k))
frame_hsv = cv2.cvtColor(frame_blur, cv2.COLOR_BGR2HSV)
thresh_vals = np.asarray([cv2.getTrackbarPos(name, win)
for name in thresh_names])
frame_thresh = cv2.inRange(frame_hsv,
thresh_vals[::2],
thresh_vals[1::2])
# cv2.imshow(win_thresh, frame_thresh)
cv2.imshow(win, frame_thresh)
keypress = cv2.waitKey(5)
cv2.destroyWindow(win)
vid_feed.release()
return thresh_vals, keypress
def __init__(self):
self.scope = 2
self.camSize = (640 // self.scope, 480 // self.scope)
self.x1 = 0
self.x2 = self.camSize[0]
self.y1 = 0
self.y2 = self.camSize[1]
self.down = 100
self.high = 255
self.prop = 0
self.cube = 0
self.diff = 0
self.intg = 0
self.base = 40
self.frame = None
self.image = None
self.gray = None
self.binB = None
self.binW = None
cv2.namedWindow(widgetNames.frameImg)
cv2.namedWindow(widgetNames.rgbImg)
cv2.namedWindow(widgetNames.grayImg)
cv2.namedWindow(widgetNames.binImgB)
cv2.namedWindow(widgetNames.binImgW)
cv2.namedWindow(widgetNames.colorTracks)
cv2.namedWindow(widgetNames.sizeTracks)
cv2.namedWindow(widgetNames.robotControl)
cv2.createTrackbar(widgetNames.threshold.down, widgetNames.colorTracks, self.down, 255, self.onDown)
cv2.createTrackbar(widgetNames.threshold.high, widgetNames.colorTracks, self.high, 255, self.onHigh)
cv2.createTrackbar(widgetNames.Roi.x1, widgetNames.sizeTracks, self.x1, 640, self.onX1)
cv2.createTrackbar(widgetNames.Roi.x2, widgetNames.sizeTracks, self.x2, 640, self.onX2)
cv2.createTrackbar(widgetNames.Roi.y1, widgetNames.sizeTracks, self.y1, 480, self.onY1)
cv2.createTrackbar(widgetNames.Roi.y2, widgetNames.sizeTracks, self.y2, 480, self.onY2)
cv2.createTrackbar(widgetNames.coef.prop, widgetNames.robotControl, self.prop, 200, self.onProp)
cv2.createTrackbar(widgetNames.coef.cube, widgetNames.robotControl, self.cube, 200, self.onCube)
cv2.createTrackbar(widgetNames.coef.diff, widgetNames.robotControl, self.diff, 200, self.onDiff)
cv2.createTrackbar(widgetNames.coef.integral, widgetNames.robotControl, self.intg, 200, self.onIntg)
cv2.createTrackbar(widgetNames.coef.base, widgetNames.robotControl, self.base, 200, self.onBase)
cv2.createTrackbar(widgetNames.Roi.scope, widgetNames.sizeTracks, self.scope, 10, self.onScope)
cv2.setTrackbarMin(widgetNames.Roi.scope, widgetNames.sizeTracks, 1)
def display(self):
"""
Displays the track bar. It's called by
display method of parent window of the track bar.
:return:
"""
if self.displayed is False:
cv2.createTrackbar(self.name, self.parent_window.window_name,
self.start_value, self.max_value,
self.__routine)
cv2.setTrackbarMin(self.name, self.parent_window.window_name,
self.min_value)
self.displayed = True
def config(self):
print('Initializing...')
frame = self.video_reader.read()
cv2.namedWindow('video', cv2.WINDOW_AUTOSIZE)
frame_d = cv2.resize(frame, self.display_size_target)
labeled_frame_d = cv2.resize(frame, self.display_size_target)
cv2.imshow('video', np.hstack([frame_d, labeled_frame_d]))
cv2.createTrackbar('threshold', 'video', self.movement_threshold, 63,
nothing)
cv2.createTrackbar('kernelSize', 'video', self.kernel_size,
self.kernel_size * 3, nothing)
cv2.createTrackbar('frameStep', 'video', self.frame_step,
int(self.video_reader.frame_count / 20 - 1),
nothing)
cv2.setTrackbarMin('frameStep', 'video', 1)
reset_frame_step_countdown = -1
while True:
contours = self.get_contours(frame)
labeled_frame = frame.copy()
cv2.drawContours(labeled_frame, contours, -1, utils.COLOR['red'],
2, cv2.LINE_AA)
frame_d = cv2.resize(frame, self.display_size_target)
labeled_frame_d = cv2.resize(labeled_frame,
self.display_size_target)
cv2.imshow('video', np.hstack([frame_d, labeled_frame_d]))
self.movement_threshold = cv2.getTrackbarPos('threshold', 'video')
self.kernel_size = cv2.getTrackbarPos('kernelSize', 'video')
self.kernel_size = int(2 * (int((self.kernel_size - 1) / 2))) + 1
if self.frame_step != cv2.getTrackbarPos('frameStep', 'video'):
self.frame_step = cv2.getTrackbarPos('frameStep', 'video')
reset_frame_step_countdown = 20
if reset_frame_step_countdown > 0:
reset_frame_step_countdown -= 1
if reset_frame_step_countdown == 0:
self.video_reader.reset(frame_step=self.frame_step)
self.initialize_background_subtractor()
frame = self.video_reader.read()
reset_frame_step_countdown = -1
k = cv2.waitKey(30) & 0xff
if k in [13, 32]:
break
elif k == 27:
cv2.destroyAllWindows()
exit()
cv2.destroyAllWindows()
self.video_reader.reset()
print('Done')
def floodFill_tb(img):
# "el color que deseemos extraer no sea uniforme podemos establecer un rango de tolerancia, es decir un mínimo y máximo permito de cercanía"
# "Primero la variable connectivity nos permite definir el nivel de conectividad a tomar en cuenta al analizar a los pixeles vecinos, puede ser 4 o 8, al establecer el flag cv2.FLOODFILL_FIXED_RANGE se tomará en cuenta la distancia entre los vecinos"
def floodFill(tolerancia, point):
src = img.copy()
connectivity = 8 #8-adyacencia
flags = connectivity #considerar vecinos
flags |= cv.FLOODFILL_FIXED_RANGE
lowest_value = (tolerancia, ) * 3
gretest_value = (tolerancia, ) * 3
#floodFill(image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]]) -> retval, image, mask, rect
cv.floodFill(src, None, point, (0, 255, 255), lowest_value,
gretest_value, flags)
cv.imshow('relleno', src)
def mouse_clic(event, x, y, flags, param):
if event == cv.EVENT_LBUTTONUP:
global point
point = (x, y)
tol = cv.getTrackbarPos(trackbar_name, winname)
floodFill(tol, point)
def trackbar_value(value):
floodFill(value, point)
#definir ventana interactiva
winname = 'Flood fill'
trackbar_name = 'Tolerancia'
cv.namedWindow(winname)
#definir elementos interactivos sobre ventana
min_tolerancia = 1
point = (0, 0)
cv.setMouseCallback(winname, mouse_clic, img)
cv.createTrackbar(trackbar_name, winname, min_tolerancia, 100,
trackbar_value)
cv.setTrackbarMin(trackbar_name, winname, min_tolerancia)
while (1):
cv.imshow(winname, img)
# if cv.waitKey(20) & 0xFF == 27:
# break
key = cv.waitKey(1) & 0xFF
if key == ord("q"):
break
cv.destroyAllWindows()
def preview_colors(color, focus, bands, thresh, scale):
# object for image capture initialized for camera in port 1
cap = cv2.VideoCapture(0)
# the window is initialized with the name 'Settings'
cv2.namedWindow('Settings')
# trackbars are created and min values are set
cv2.createTrackbar('color', 'Settings', color, 180, nothing)
cv2.createTrackbar('bands', 'Settings', bands, 20, nothing)
cv2.createTrackbar('thresh', 'Settings', thresh, 20, nothing)
cv2.createTrackbar('bandwidth', 'Settings', focus[0], 180, nothing)
cv2.createTrackbar('min S', 'Settings', focus[1], 255, nothing)
cv2.createTrackbar('max S', 'Settings', focus[2], 255, nothing)
cv2.createTrackbar('min H', 'Settings', focus[3], 255, nothing)
cv2.createTrackbar('max H', 'Settings', focus[4], 255, nothing)
cv2.setTrackbarMin('bands', 'Settings', 1)
cv2.setTrackbarMin('thresh', 'Settings', 1)
# video stream is displayed
while True:
# a frame is taken from the camera feed and saved in 'frame'
__, frame = cap.read()
# trackbar positions are read and saved onto the appropriate paramters
color = cv2.getTrackbarPos('color', 'Settings')
bands = cv2.getTrackbarPos('bands', 'Settings')
thresh = cv2.getTrackbarPos('thresh', 'Settings')
focus[0] = cv2.getTrackbarPos('bandwidth', 'Settings')
focus[1] = cv2.getTrackbarPos('min S', 'Settings')
focus[2] = cv2.getTrackbarPos('max S', 'Settings')
focus[3] = cv2.getTrackbarPos('min H', 'Settings')
focus[4] = cv2.getTrackbarPos('max H', 'Settings')
# frame is filtered and displayed
filtered = color_vision(color, focus, bands, thresh, scale, image=frame)
gray = filtered[len(filtered)-1]*255
gray = cv2.resize(gray, None, fx=1/scale, fy=1/scale)
cv2.imshow('Preview', gray)
# waits for the escape key to stop the video stream and save the trackbar values onto the appropriate parameters
k = cv2.waitKey(5) & 0xFF
if k == 27:
break
cv2.destroyAllWindows()
# returns the filter parameters
return bands, thresh, color, focus
def __create_trackbar(self, param_dict):
# dimensions of track bar window
self.WIDTH = 300 # px
self.HEIGHT = 600 # px
# create black window
self.trackbar_window = np.zeros((self.WIDTH, self.HEIGHT, 3), np.uint8)
self.window_name = "trackbars"
cv2.namedWindow(self.window_name)
# create trackbars based on parameter dictionary with keys as trackbar name
for name, param in self.param_dict.items():
cv2.createTrackbar(name, self.window_name, param[0], param[2],
nothing)
cv2.setTrackbarMin(name, self.window_name, param[1])
def createWindow(title, x, y, trackbar_array=()):
# create window
cv.namedWindow(title, cv.WINDOW_NORMAL)
# create trackbars
for values in trackbar_array:
trackbar_name = values[0]
trackbar_min_val = values[1]
trackbar_max_val = values[2]
trackbar_current_val = values[3]
trackbar_function = values[4]
trackbar_name = trackbar_name + ' x %d' % trackbar_max_val
cv.createTrackbar(trackbar_name, title, trackbar_current_val,
trackbar_max_val, trackbar_function)
cv.setTrackbarMin(trackbar_name, title, trackbar_min_val)
cv.resizeWindow(title, 800, 500)
cv.moveWindow(title, x, y)
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 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 init():
# Create windows and sliders
cv2.namedWindow("Image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow('slider', cv2.WINDOW_AUTOSIZE)
cv2.moveWindow('slider', 640, 0)
cv2.resizeWindow('slider', 560, 400)
cv2.createTrackbar('B', 'slider', 0, 255, nothing)
cv2.createTrackbar('G', 'slider', 0, 255, nothing)
cv2.createTrackbar('R', 'slider', 0, 255, nothing)
cv2.createTrackbar('B1', 'slider', 0, 255, nothing)
cv2.createTrackbar('G1', 'slider', 0, 255, nothing)
cv2.createTrackbar('R1', 'slider', 0, 255, nothing)
cv2.createTrackbar('color', 'slider', 0, 5, nothing)
cv2.createTrackbar('image', 'slider', 1, 3, nothing)
cv2.setTrackbarMin('image', 'slider', 1)
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 create_new_pipeline():
global hypercube, num_layers, current_layer, paint_flag, diag_flags, compare_points
paint_flag = False
fn = easygui.fileopenbox(msg='Открыть гиперкуб numpy',
filetypes=[['.npy', 'Numpy Hypercube'],
['.tiff', 'GeoTIFF'], images_ext_list],
default='*.npy')
if fn:
_, ext_ = os.path.splitext(fn)
if (ext_ == '.npy'):
hypercube = numpy.load(fn)
elif (ext_ == '.tiff'):
# https://kipcrossing.github.io/2021-01-04-geotiff-python-package/
from geotiff import GeoTiff
geoTiff = GeoTiff(fn)
hypercube = geoTiff.read()[:].transpose((2, 0, 1))
elif (ext_ in images_ext_list):
#hypercube = cv2.imread(fn).transpose((2, 0, 1)) #EXIF fix might be here...
f = open(fn, "rb")
img = cv2.imdecode(numpy.frombuffer(f.read(), dtype=numpy.uint8),
cv2.IMREAD_COLOR)
hypercube = img.transpose((2, 0, 1))
num_layers = hypercube.shape[0]
cv2.namedWindow("Image", cv2.WINDOW_NORMAL)
cv2.resizeWindow("Image", hypercube.shape[2], hypercube.shape[1])
cv2.namedWindow("Settings", cv2.WINDOW_NORMAL)
cv2.resizeWindow("Settings", 300, 100)
cv2.setMouseCallback('Image', onmouse)
cv2.createTrackbar('layer', 'Settings', 0, num_layers - 1,
OnLayerChange)
cv2.createTrackbar('red_edge', 'Settings', num_layers // 2,
num_layers - 1, OnRedEdgeChange)
cv2.setTrackbarMin('red_edge', 'Settings', 1)
cv2.createTrackbar('num_points', 'Settings', 1, 9, OnNumPointsChange)
cv2.setTrackbarMin('num_points', 'Settings', 1)
current_layer = 0
diag_flags = [True for i in range(num_layers)
] #numpy.ones((num_layers,), dtype=int)
compare_points = []
OnLayerChange(0)
def _initialize_window(self):
"""Creates the window."""
cv.namedWindow(self.name)
for i, (chname, min_, max_) in enumerate(
zip(self.channel_names, self.channel_mins, self.channel_maxes)
):
cv.createTrackbar(
chname + MIN_SUFFIX,
self.name,
min_,
max_,
partial(self._update_lowerb, i),
)
cv.setTrackbarMin(chname + MIN_SUFFIX, self.name, min_)
cv.createTrackbar(
chname + MAX_SUFFIX,
self.name,
max_,
max_,
partial(self._update_upperb, i),
)
self._update()
type=int,
help="Number of tables.",
default=2)
args = parser.parse_args()
NUM_CELLS = args.num_cells
NUM_TABLES = args.num_tables
reset_needed = False
print_yellow_bold(f"[ARGUMENT] Number of Cells: {NUM_CELLS}")
print_yellow_bold(f"[ARGUMENT] Number of Tables: {NUM_TABLES}")
cv2.namedWindow(WINDOW_NAME)
cv2.moveWindow(WINDOW_NAME, 0, 0)
cv2.createTrackbar("AddNumber", WINDOW_NAME, 1, 300, dummy)
cv2.setTrackbarMin("AddNumber", WINDOW_NAME, 0)
image, hash_tables = CreateHashTables(win_size=WIN_SIZE,
num_tables=NUM_TABLES,
num_cells=NUM_CELLS,
margin=MARGIN)
number_history = []
while (True):
add_number = cv2.getTrackbarPos("AddNumber", WINDOW_NAME)
k = cv2.waitKey(1) & 0xFF
number_history = []
if k == ord('p') and not reset_needed:
print_yellow_bold(f"Trying to add {add_number} into hash tables.")
if not AddNumberToHashTables(hash_tables=hash_tables,
number=add_number,
from calculateCSpace import forwardKinematics, isIntersecting, obstacles
from shapely.geometry import *
import shapely
import shapely.geometry
import cv2
import numpy as np
def nothing(x):
pass
cv2.namedWindow('image')
cv2.createTrackbar('theta', 'image', -35, 175, nothing)
cv2.createTrackbar('phi', 'image', -180, 180, nothing)
cv2.setTrackbarMin('theta', 'image', -35)
cv2.setTrackbarMin('phi', 'image', -180)
elbowPos = np.asarray([0.0, 0.0])
def ro(tup):
return (int(tup[0]) + 256, 512 - (int(tup[1]) + 256))
while True:
theta = cv2.getTrackbarPos('theta', 'image')
phi = cv2.getTrackbarPos('phi', 'image')
clawPos, wristPos = forwardKinematics(theta, phi, False)
clawPos = np.asarray(clawPos)
def main():
cv2.namedWindow('frame')
cv2.createTrackbar('W', 'frame', 0, 100, nothing)
cv2.createTrackbar('Q', 'frame', 0, 100, nothing)
cv2.createTrackbar('R_A', 'frame', 1, 100, nothing)
cv2.createTrackbar('R_V', 'frame', 1, 100, nothing)
cv2.setTrackbarMin('R_A', 'frame', 1)
cv2.setTrackbarMin('R_V', 'frame', 1)
cv2.setTrackbarPos('W', 'frame', 50)
cv2.setTrackbarPos('Q', 'frame', 10)
cv2.setTrackbarPos('R_A', 'frame', 10)
cv2.setTrackbarPos('R_V', 'frame', 10)
ekf = filters.EKF(process_noise_variance=cv2.getTrackbarPos('Q', 'frame'),
observation_noise_covariance=np.diag(
np.array([
cv2.getTrackbarPos('R_A', 'frame'),
cv2.getTrackbarPos('R_A', 'frame'),
cv2.getTrackbarPos('R_V', 'frame'),
cv2.getTrackbarPos('R_V', 'frame')
])))
swekf = filters.StreamWeightEKF(
process_noise_variance=cv2.getTrackbarPos('Q', 'frame'),
observation_noise_covariance=[
cv2.getTrackbarPos('R_A', 'frame') * np.eye(2),
cv2.getTrackbarPos('R_V', 'frame') * np.eye(2)
])
x, y = filters.load_sequence_data("data.csv")
video = cv2.VideoCapture("video.m4v")
frame_idx = 0
x_ekf = 0
sigma_x_ekf = 10
x_swekf = 0
sigma_x_swekf = 10
while True:
has_frame, frame = video.read()
if has_frame:
y_ekf = np.hstack((y[0][frame_idx], y[1][frame_idx]))
y_swekf = [y[0][frame_idx], y[1][frame_idx]]
w = cv2.getTrackbarPos('W', 'frame') / 100
process_noise_variance = cv2.getTrackbarPos('Q', 'frame')
observation_noise_variance_audio = cv2.getTrackbarPos(
'R_A', 'frame') / 10
observation_noise_variance_video = cv2.getTrackbarPos(
'R_V', 'frame') / 10
ekf.process_noise_variance = process_noise_variance
ekf.observation_noise_covariance = np.diag(
np.array([
observation_noise_variance_audio,
observation_noise_variance_audio,
observation_noise_variance_video,
observation_noise_variance_video
]))
swekf.process_noise_variance = process_noise_variance
swekf.observation_noise_covariance = [
observation_noise_variance_audio * np.eye(2),
observation_noise_variance_video * np.eye(2)
]
x_ekf, sigma_x_ekf = ekf.step(x_ekf, sigma_x_ekf, y_ekf)
x_swekf, sigma_x_swekf = swekf.step(x_swekf, sigma_x_swekf,
y_swekf, w)
azimuth_audio = rvs2angle(y_swekf[0])
if not np.isnan(azimuth_audio):
pixel_pos_audio = int((1 - (azimuth_audio + 30.5) / 61) * 640)
cv2.line(frame, (pixel_pos_audio, 0), (pixel_pos_audio, 511),
(255, 0, 0), 1)
azimuth_video = rvs2angle(y_swekf[1])
if not np.isnan(azimuth_video):
pixel_pos_video = int((1 - (azimuth_video + 30.5) / 61) * 640)
cv2.line(frame, (pixel_pos_video, 0), (pixel_pos_video, 511),
(0, 255, 0), 1)
azimuth_grid = np.arange(-60, 61, 0.01)
x_pdf_ekf = 1 / (sigma_x_ekf * np.sqrt(2 * np.pi)) * np.exp(
-(azimuth_grid - x_ekf)**2 / (2 * sigma_x_ekf**2))
x_pdf_ekf = x_pdf_ekf / np.amax(x_pdf_ekf)
x_pdf_swekf = 1 / (sigma_x_swekf * np.sqrt(2 * np.pi)) * np.exp(
-(azimuth_grid - x_swekf)**2 / (2 * sigma_x_swekf**2))
x_pdf_swekf = x_pdf_swekf / np.amax(x_pdf_swekf)
pixel_grid = -320 + (1 - (azimuth_grid + 60) / 120) * 1280
pixel_pdf_ekf = 485 - (x_pdf_ekf * 100)
points_ekf = np.int32(
np.stack((pixel_grid, pixel_pdf_ekf), axis=-1))
cv2.polylines(frame, [points_ekf], True, (255, 0, 255))
pixel_pdf_swekf = 485 - (x_pdf_swekf * 100)
points_swekf = np.int32(
np.stack((pixel_grid, pixel_pdf_swekf), axis=-1))
cv2.polylines(frame, [points_swekf], True, (0, 255, 255))
cv2.imshow('frame', frame)
cv2.waitKey(33)
frame_idx += 1
if cv2.waitKey(33) & 0xFF == ord("q"):
break
else:
break
video.release()
cv2.destroyAllWindows()
def render_gui(frames):
"""
Renders an opencv gui where you can warp and move segmentation masks and generate a new image based on that mask
"""
try:
_set_trackbars(0, 0, 0, 0, 0, 0)
except cv2.error:
pass
cv2.namedWindow('Mask')
cv2.moveWindow("Mask", 0, 20)
cv2.createTrackbar('Select Mask', 'Mask', 0,
len(frames) - 1,
lambda x: _set_trackbars(x, 0, 0, 0, 0, 0))
cv2.createTrackbar('Dilate', 'Mask', 0, 20, no_action)
cv2.createTrackbar('Erode', 'Mask', 0, 20, no_action)
cv2.createTrackbar('Rotate', 'Mask', -180, 180, no_action)
cv2.createTrackbar('c', 'Mask', -100, 100, no_action)
cv2.createTrackbar('f', 'Mask', -100, 100, no_action)
cv2.setTrackbarMin('c', 'Mask', -100)
cv2.setTrackbarMin('f', 'Mask', -100)
cv2.setTrackbarMin('Rotate', 'Mask', -180)
warped_frames = frames.copy()
# reset settings
settings = settings_old = [[0 for _ in range(5)]
for _ in range(len(frames))]
index_old = -1
while 1:
# get mask
index = cv2.getTrackbarPos('Select Mask', 'Mask')
# load settings
if index is not index_old:
dilate, erode, deg, c, f = settings[index]
_set_trackbars(index, dilate, erode, deg, c, f)
# get settings for mask
dilate = cv2.getTrackbarPos('Dilate', 'Mask')
erode = cv2.getTrackbarPos('Erode', 'Mask')
deg = cv2.getTrackbarPos('Rotate', 'Mask')
c = cv2.getTrackbarPos('c', 'Mask')
f = cv2.getTrackbarPos('f', 'Mask')
# save settings
settings[index] = [dilate, erode, deg, c, f]
# apply settings
if settings == settings_old:
img = add_warp(frames[index].copy(),
dilate=dilate,
erode=erode,
deg=deg,
c=c,
f=f)
warped_frames[index] = img
result = render_frames(warped_frames)
# show result
mask = np.array(result.convert('RGB'))
mask = mask[:, :, ::-1]
cv2.imshow('Mask', mask)
index_old = index
settings_old = settings
# escape key
if (cv2.waitKey(1) & 0xFF) == 27:
break
cv2.destroyWindow('Mask')
return result
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)
global scaleFactor
scaleFactor = val
def onNeigh(val):
global minNeighbors
minNeighbors = val
def onSize(val):
global minSize
minSize = (val, val)
cv2.createTrackbar("scaleFactor", 'win', scaleFactor, 1000, onScale)
cv2.setTrackbarMin("scaleFactor", 'win', 101)
cv2.createTrackbar("minNeighbors", 'win', minNeighbors, 100, onNeigh)
cv2.createTrackbar("minSize", 'win', minSize[0], 100, onSize)
cap = cv2.VideoCapture(0)
faceCounter = 0
while True:
_, frame = cap.read()
image = cv2.resize(frame, (640 // 4, 480 // 4))
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = learning.cascade.detectMultiScale(gray,
scaleFactor=scaleFactor / 100,
minNeighbors=minNeighbors,
import cv2
gogopher = cv2.imread('../assets/gogopher.jpg', flags=cv2.IMREAD_COLOR)
puppy = cv2.imread('../assets/puppy.jpg', flags=cv2.IMREAD_COLOR)
cv2.namedWindow('TrackerBar', cv2.WINDOW_AUTOSIZE)
def on_tracker(val):
alpha = val / 100
dst = cv2.addWeighted(gogopher, alpha, puppy, 1 - alpha, 0)
cv2.imshow('TrackerBar', dst)
on_tracker(35)
# createTrackbar(tracker_name, window_name, display_value, max_value, handler)
cv2.createTrackbar('AlphaTracker', 'TrackerBar', 35, 100, on_tracker)
# The min value of tracker is default 0.
# but you can set the min by setTrackbarMin()
cv2.setTrackbarMin('AlphaTracker', 'TrackerBar', 20)
# set current value
# cv2.setTrackbarPos('AlphaTracker', 'TrackerBar', 35)
# set max value
# cv2.setTrackbarMax('AlphaTracker', 'TrackerBar', 100)
cv2.waitKey(0)
