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)