def build_opts():
for o, t in shm.camera_calibration._fields:
print(o)
if t == ctypes.c_double:
opts.append(
options.DoubleOption(o,
getattr(shm.camera_calibration, o).get(),
DEFAULT_DOUBLE_MIN, DEFAULT_DOUBLE_MAX))
elif t == ctypes.c_int:
opts.append(
options.IntOption(o,
getattr(shm.camera_calibration, o).get(),
DEFAULT_INT_MIN, DEFAULT_INT_MAX))
return opts
import numpy as np
import shm
from vision.modules.base import ModuleBase
from vision.framework.color import bgr_to_lab, elementwise_color_dist, range_threshold
from vision.framework.draw import draw_line, draw_circle, draw_contours
from vision.framework.helpers import to_umat, to_odd
from vision.framework.feature import outer_contours, contour_centroid, contour_area, simple_canny, line_polar_to_cartesian, find_lines
from vision.framework.transform import erode, rect_kernel, simple_gaussian_blur
from vision import options
from vision.modules.will_common import find_best_match
options = [
options.BoolOption('debug', False),
options.IntOption('red_lab_a_min', 140, 0, 255),
options.IntOption('red_lab_a_max', 255, 0, 255),
options.IntOption('black_lab_l_min', 0, 0, 255),
options.IntOption('black_lab_l_max', 150, 0, 255),
options.IntOption('green_lab_a_min', 0, 0, 255),
options.IntOption('green_lab_a_max', 120, 0, 255),
options.IntOption('color_dist_min_green_funnel', 0, 0, 255),
options.IntOption('color_dist_max_green_funnel', 50, 0, 255),
options.IntOption('blur_kernel', 17, 0, 255),
options.IntOption('erode_kernel', 5, 0, 255),
options.IntOption('black_erode_iters', 5, 0, 100),
options.IntOption('hough_lines_rho', 5, 1, 1000),
options.IntOption('hough_lines_theta', 1, 1, 1000),
options.IntOption('hough_lines_thresh', 100, 0, 1000),
options.IntOption('contour_min_area', 1000, 0, 100000),
options.DoubleOption('percent_red_thresh', 0.05, 0, 1),
def get_shared_options(is_forward):
# (Downward, Forward)
return [
# Global
options.BoolOption('in_simulator', False),
options.BoolOption('preprocess_debug', False),
options.BoolOption('thresh_debug', True),
options.BoolOption('contour_debug', False),
options.BoolOption('bins_debug', True),
options.BoolOption('funnels_debug', False),
# Preprocess
options.IntOption('gaussian_kernel', (5, 5)[is_forward], 1, 40),
options.IntOption('gaussian_stdev', 20, 0, 40),
# Threshing
options.IntOption('erode_size', (3, 5)[is_forward], 1, 40),
options.IntOption('thresh_size', (15, 15)[is_forward], 1, 100),
options.IntOption("lab_b_min_red_bin", 140, 0, 255),
options.IntOption("lab_b_max_red_bin", 250, 0, 255),
options.IntOption("color_dist_min_red_funnel", (137, 0)[is_forward], 0,
255),
options.IntOption("color_dist_max_red_funnel", (250, 35)[is_forward],
0, 255),
options.IntOption("color_dist_min_yellow_funnel", (0, -1)[is_forward],
0, 255),
options.IntOption("color_dist_max_yellow_funnel", (25, -1)[is_forward],
0, 255),
# Contouring
options.IntOption('min_area', (50, 100)[is_forward], 1, 2000),
options.IntOption('min_y', (0, 200)[is_forward], 0, 2000),
options.DoubleOption('min_circularity', (0.8, 0.1)[is_forward], 0, 1),
options.DoubleOption('max_rectangularity', 0.9, 0, 1),
# Binning
options.DoubleOption('max_joining_dist', 120, 0, 500),
]
black_left = True
gate_shm_group = shm.bicolor_gate_vision
# SHM:
# - general, black, and red centers
# - confidence
module_options = [
options.BoolOption('debug', True),
#options.IntOption('erode_size', 1, 1, 40),
#options.IntOption('gaussian_kernel', 1, 1, 40),
#options.IntOption('gaussian_stdev', 2, 0, 40),
#options.IntOption('thresh_size', 7, 1, 100),
#options.IntOption('luv_u_canny_min', 0, 0, 255),
#options.IntOption('luv_u_canny_max', 255, 0, 255),
#options.IntOption('hls_h_canny_min', 0, 0, 255),
#options.IntOption('hls_h_canny_max', 255, 0, 255),
options.IntOption('ycrcb_cr_canny_min', 5, 0, 255),
options.IntOption('ycrcb_cr_canny_max', 13, 0, 255),
options.IntOption('min_area', 700, 1, 2000),
options.IntOption('center_dist', 100, 1, 2000),
#options.IntOption('luv_l_thresh_min', 1, 1, 254),
#options.IntOption('luv_l_thresh_max', 76, 1, 254),
options.IntOption('hough_votes', 250, 100, 1000000),
options.IntOption('rho', 7, 1, 100),
options.IntOption('bin_dist_threshold', 50, 0, 1000),
options.IntOption('min_length', 50, 1, 100000),
options.IntOption('max_gap', 50, 1, 100000),
options.IntOption('min_y', 0, 0, 1024),
]
WHITE = (255, 255, 255)
RED = (0, 0, 255)
BLUE = (255, 0, 0)
import cv2
import numpy as np
import shm
import auvlog.client
from vision.vision_common import draw_angled_arrow, \
get_angle_from_rotated_rect
from vision.modules.base import ModuleBase
from vision import options as gui_options
log = auvlog.client.log.vision.pipes
vision_options = [
gui_options.DoubleOption('block_size', .061, 0, .1),
gui_options.IntOption('c_thresh', -13, -100, 100),
gui_options.DoubleOption('erode_size', .018, 0, .1),
gui_options.DoubleOption('dilate_size', .038, 0, .1),
gui_options.DoubleOption('min_percent_frame', .02, 0, 1),
gui_options.DoubleOption('min_rectangularity', 1000),
gui_options.DoubleOption('heuristic_power', 5),
gui_options.BoolOption('debugging', True)
]
def get_zero_pipe_group():
pipe_group = shm.pipe_results.get()
pipe_group.angle = 0
pipe_group.center_x = 0
pipe_group.center_y = 0
pipe_group.heuristic_score = 0
#!/usr/bin/env python3
from vision import options
import numpy as np
from vision.modules.base import ModuleBase # , UndefinedModuleOption
from vision.framework.helpers import to_umat # , from_umat
from vision.framework.transform import resize, simple_gaussian_blur
import cv2
import shm
opts = [
options.DoubleOption('camera_scale', 0.35, 0, 1),
options.IntOption('lid_l_trg', 198, 0, 255),
options.IntOption('lid_a_trg', 119, 0, 255),
options.IntOption('lid_b_trg', 196, 0, 255),
options.IntOption('lid_d_thresh', 40, 0, 255), # 128
options.IntOption('canny1', 459, 0, 1000), # 25
options.IntOption('canny2', 496, 0, 1000), # 93
options.IntOption('houghness', 51, 0, 1000),
options.DoubleOption('min_cross_score', .15, 0, 1),
options.BoolOption('debug', False)
]
def make_poly(d1, d2):
#print(d1, d2)
return np.complex64([0, d1, (d1 + d2), d2])[:, np.newaxis]
class BinsCover(ModuleBase):
def process(self, mat):
camera_scale = self.options['camera_scale']
from vision.framework.helpers import to_umat # , from_umat
from vision.framework.draw import draw_circle
from vision.framework.color import bgr_to_lab, range_threshold
from vision.modules.gate import thresh_color_distance
from mission.missions.stake import MOVE_DIRECTION
from vision import options
opts = [
options.DoubleOption('rectangular_thresh', 0.8, 0, 1),
options.DoubleOption('source_x_scale_board', 0.1, 0, 1),
options.DoubleOption('source_y_scale_board', 0.1, 0, 1),
options.DoubleOption('downsize_camera', 0.5, 0, 1),
options.IntOption('min_match_count', 3, 0, 255),
options.DoubleOption('good_ratio', 0.8, 0, 1),
options.BoolOption('show_keypoints', False),
options.IntOption('board_separation', 450, 0, 4000),
options.IntOption('board_horizontal_offset', 70, -1000, 1000),
options.IntOption('lever_position_x',
-500 if MOVE_DIRECTION == 1 else 2700, -3000, 3000),
options.IntOption('lever_position_y', 2500, 0, 6000),
options.IntOption('heart_offset_x', -307, -3000, 3000),
options.IntOption('heart_offset_y', 0, -3000, 3000),
options.IntOption('belt_offset_x', 0, -3000, 3000),
options.IntOption('belt_offset_y', 0, -3000, 3000),
options.IntOption('left_circle_offset_x', -284, -3000, 3000),
options.IntOption('left_circle_offset_y', 565, -3000, 3000),
options.IntOption('right_circle_offset_x', -519, -3000, 3000),
options.IntOption('right_circle_offset_y', 565, -3000, 3000),
#!/usr/bin/env python3
from vision.modules.base import ModuleBase
from vision import options
import cv2
module_options = [
options.DoubleOption('text_size', 1.0, 1,0, 20.0),
options.IntOption('text_thickness', 1, 1, 10)
]
class Hello(ModuleBase):
def process(self, img):
hello_img = cv2.putText(
img, "Hello!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
self.options["text_size"], (0,0,0),
thickness=self.options["text_thickness"])
self.post("hello", hello_img)
if _name_ == '_main_':
Hello(None, module_options)
#!/usr/bin/env python3
from vision.modules.base import ModuleBase
from vision.modules import features_utils
from vision import options
import sys
import cv2
import numpy as np
module_options = [
options.IntOption('source_hess_thresh', 645, 10, 1000),
options.IntOption('video_hess_thresh', 645, 10, 1000),
options.DoubleOption('ratio_thresh', 0.7, 0.1, 1),
]
Detector = cv2.xfeatures2d.SURF_create
Detector = cv2.xfeatures2d.SIFT_create
class Features(ModuleBase):
def __init__(self, source_image_name, *args, **kwargs):
super().__init__(*args, **kwargs)
self._feature_finder = features_utils.FeatureFinder(Detector(), ('torpedo', source_image_name))
def process(self, img):
res = self._feature_finder.match_against(img)
if 'torpedo' not in res:
print('none found :(')
return
result = res['torpedo']
#!/usr/bin/env python3
import shm
from vision.modules.base import ModuleBase
from vision.modules import buoy_common
from vision import options
options = [
options.IntOption('hls_h_min', 63, 0, 255),
options.IntOption('hls_h_max', 207, 0, 255),
options.IntOption('lab_a_min', 123, 0, 255),
options.IntOption('lab_a_max', 167, 0, 255),
options.IntOption('lab_b_min', 87, 0, 255),
options.IntOption('lab_b_max', 142, 0, 255),
options.IntOption('min_area', 100, 0, 1000000),
options.IntOption('blur_size', 4, 1, 50),
options.IntOption('min_heuristic_score', 0, 0, 1000),
options.DoubleOption('min_circularity', 0.5, 0, 1),
options.BoolOption('verbose', False)
]
class RedBuoy(ModuleBase):
def process(self, mat):
buoy_common.process(self, mat, shm.red_buoy_results)
if __name__ == '__main__':
RedBuoy('forward', options)()
import sys
import math
import cv2
import numpy as np
import shm
from vision.modules.base import ModuleBase
from vision import options
#import slam.slam_util as slam
from will_common import find_best_match
options = [
options.BoolOption('debug', False),
options.IntOption('hsv_thresh_c', 35, 0, 100),
options.IntOption('canny_a', 50, 0, 255),
options.IntOption('canny_b', 110, 0, 255),
options.IntOption('contour_area_thresh', 10, 1, 200),
options.DoubleOption('perim_thresh', 1.5, 1, 10),
options.DoubleOption('circle_thresh', 3, 1, 10),
options.DoubleOption('ellipse_thresh', 1.2, 1, 10),
options.DoubleOption('max_pip_dist_ratio', 4, 0, 10),
options.DoubleOption('max_pip_radius_ratio', 1.2, 1, 10),
options.IntOption('min_y', 200, 0, 1024),
]
FORWARD_CAM_WIDTH = shm.camera.forward_width.get()
FORWARD_CAM_HEIGHT = shm.camera.forward_height.get()
PIP_THRESH = 5
#!/usr/bin/env python3
import shm
from vision.modules import buoy_common
from vision.modules.base import ModuleBase
from vision import options
options = [
options.IntOption('hls_h_min', 85, 0, 255),
options.IntOption('hls_h_max', 111, 0, 255),
options.IntOption('lab_a_min', 64, 0, 255),
options.IntOption('lab_a_max', 121, 0, 255),
options.IntOption('lab_b_min', 106, 0, 255),
options.IntOption('lab_b_max', 123, 0, 255),
options.IntOption('min_area', 100, 0, 1000000),
options.IntOption('blur_size', 4, 1, 50),
options.IntOption('min_heuristic_score', 0, 0, 1000),
options.DoubleOption('min_circularity', 0.1, 0, 1),
options.BoolOption('verbose', False)
]
class YellowBuoy(ModuleBase):
def process(self, mat):
buoy_common.process(self, mat, shm.yellow_buoy_results)
if __name__ == '__main__':
YellowBuoy('forward', options)()
import cv2
import numpy as np
import shm
import auvlog.client
from vision.vision_common import draw_angled_arrow, \
get_angle_from_rotated_rect
from vision.modules.base import ModuleBase
from vision import options as gui_options
log = auvlog.client.log.vision.pipes
vision_options = [
gui_options.IntOption('block_size', 1001, 0, 1500),
gui_options.IntOption('c_thresh', -4, -200, 100),
gui_options.IntOption('erode_size', 5, 0, 50),
gui_options.IntOption('dilate_size', 9, 0, 50),
gui_options.DoubleOption('min_percent_frame', 0.01, 0, 0.1),
gui_options.DoubleOption('max_percent_frame', 0.2, 0, 1),
# A circle with radius 1 inscribed in a square has
# 'rectangularity' pi/4 ~ 0.78.
gui_options.DoubleOption('aspect_ratio_threshold', 3, 0.5, 5),
gui_options.DoubleOption('min_rectangularity', 0.48),
gui_options.DoubleOption('heuristic_power', 5),
gui_options.IntOption('orange_lab_l_min', 152, 0, 255),
gui_options.IntOption('orange_lab_l_max', 255, 0, 255),
gui_options.IntOption('orange_hsv_v_min', 0, 0, 255),
gui_options.IntOption('orange_hsv_v_max', 255, 0, 255),
gui_options.IntOption('orange_rgb_r_min', 180, 0, 255),
from vision import options
opts = [
options.DoubleOption('rectangular_thresh', 0.7, 0, 1),
options.DoubleOption('source_x_scale_draugr', 1, 0, 1),
options.DoubleOption('source_y_scale_draugr', 1, 0, 1),
options.DoubleOption('source_x_scale_vetalas', 1, 0, 1),
options.DoubleOption('source_y_scale_vetalas', 1, 0, 1),
options.DoubleOption(
'source_x_scale_aswang', 0.69, 0,
1), #CHANGE BACK TO 1 IF COMPETITION BUOY IS NOT STRETCHED
options.DoubleOption('source_y_scale_aswang', 1, 0, 1),
options.DoubleOption('source_x_scale_jiangshi', 1, 0, 1),
options.DoubleOption('source_y_scale_jiangshi', 1, 0, 1),
options.DoubleOption('downsize_camera', 0.25, 0, 1),
options.IntOption('min_match_count', 10, 0, 255),
options.DoubleOption('good_ratio', 0.8, 0, 1),
options.BoolOption('show_keypoints', False)
]
PADDING = 100
class VampBuoy(ModuleBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#self.source = cv2.imread('buoy_images/draugr.png',0)
# self.orb = cv2.ORB_create(nfeatures=250, WTA_K=3)
self.detector = cv2.xfeatures2d.SIFT_create()
FLANN_INDEX_KDTREE = 0
#FLANN_INDEX_LSH = 6
#!/usr/bin/env python3
import cv2
import numpy as np
from vision import options
from vision.modules.base import ModuleBase
opts = [
options.IntOption('lab_l_min', 51, 0, 255),
options.IntOption('lab_l_max', 136, 0, 255),
options.IntOption('lab_a_min', 86, 0, 255),
options.IntOption('lab_a_max', 117, 0, 255),
options.IntOption('lab_b_min', 115, 0, 255),
options.IntOption('lab_b_max', 152, 0, 255),
options.IntOption('brightness', 127, 0, 255),
options.DoubleOption('min_area', 100, 0, 500),
options.DoubleOption('max_arclength', 4, 0, 500),
]
class Test(ModuleBase):
def process(self, mat):
o = lambda name: self.options[name]
self.post('original', mat)
lab = cv2.cvtColor(mat, cv2.COLOR_BGR2LAB)
l_a_b = cv2.split(lab)
threshed_chans = []
for i, chan in enumerate('lab'):
import shm
from vision.modules.base import ModuleBase
from vision.vision_common import green, red, white, yellow
from vision import options
from color_balance import balance
options = [
options.BoolOption('debug', False),
options.BoolOption('red_debug', False),
options.BoolOption('green_debug', False),
options.BoolOption('yellow_debug', True),
options.BoolOption('rescale_image', True),
options.BoolOption('use_color_correction', False),
options.IntOption('hls_l_min', 0, 0, 255),
options.IntOption('hls_l_max', 255, 0, 255),
options.IntOption('red_hls_h_min', 0, 0, 255),
options.IntOption('red_hls_h_max', 23, 0, 255),
options.IntOption('red_ycrcb_cb_min', 0, 0, 255),
options.IntOption('red_ycrcb_cb_max', 120, 0, 255),
options.IntOption('red_lab_a_min', 130, 0, 255),
options.IntOption('red_lab_a_max', 183, 0, 255),
options.IntOption('red_lab_b_min', 132, 0, 255),
options.IntOption('red_lab_b_max', 230, 0, 255),
options.IntOption('red_erode_kernel_size', 1, 1, 151),
options.IntOption('red_dilate_kernel_size', 1, 1, 151),
options.IntOption('green_lab_l_min', 0, 0, 255),
options.IntOption('green_lab_l_max', 255, 0, 255),
options.IntOption('green_hsv_v_min', 0, 0, 255),
options.IntOption('green_hsv_v_max', 255, 0, 255),
def __init__(self, module):
self.module = module
self.options = [
options.BoolOption('PPX_grayscale', False),
options.BoolOption('PPX_rgb_split', False),
options.BoolOption('PPX_lab_split', False),
options.BoolOption('PPX_hsv_split', False),
options.BoolOption('PPX_hls_split', False),
options.BoolOption('PPX_ycrcb_split', False),
options.BoolOption('PPX_luv_split', False),
options.BoolOption('PPX_color_correction', False),
options.IntOption('PPX_r_bias', 0, -255, 255),
options.IntOption('PPX_g_bias', 0, -255, 255),
options.IntOption('PPX_b_bias', 0, -255, 255),
options.DoubleOption('PPX_contrast', 1, 0, 255),
options.IntOption('PPX_brightness', 0, -255, 255),
options.BoolOption('PPX_gaussian_blur', False),
options.IntOption('PPX_gaussian_blur_kernel', 1, 1, 100),
options.IntOption('PPX_gaussian_noise', 0, 0, 255),
options.BoolOption('PPX_erode', False),
options.IntOption('PPX_erode_kernel', 1, 1, 50),
options.BoolOption('PPX_dilate', False),
options.IntOption('PPX_dilate_kernel', 1, 1, 50),
options.IntOption('PPX_rotate', 0, 0, 359),
options.BoolOption('PPX_resize', False),
options.IntOption(
'PPX_resize_width', 512, 1, 2048,
lambda x: x * self.options_dict['PPX_resize_height'].value * 3
<= self.module.max_buffer_size),
options.IntOption(
'PPX_resize_height', 512, 1, 2048,
lambda x: x * self.options_dict['PPX_resize_width'].value * 3
<= self.module.max_buffer_size),
options.DoubleOption('PPX_resize_ratio', 1, 0.01, 1),
options.IntOption('PPX_translate_x', 0, -2048, 2048),
options.IntOption('PPX_translate_y', 0, -2048, 2048),
]
self.options_dict = {option.name: option for option in self.options}
for option in self.options:
self.module.options_dict[option.name] = option
draw_angled_arrow,
get_angle_from_rotated_rect,
Hierarchy,
is_clipping,
)
from vision.modules.base import ModuleBase
from mission.constants.config import bins as constants
CONTOUR_HEURISTIC_LIMIT = 5
CONTOUR_SCALED_HEURISTIC_LIMIT = 2
options = [
options.BoolOption('clipping_guard', constants.clipping_guard),
options.BoolOption('debug', False),
options.IntOption('max_fps', 30, 0, 30),
options.IntOption('border_bgr_compon', constants.border_bgr_compon, 0, 2),
options.IntOption('block_size', 401, 0, 4000, lambda x: x % 2 == 1),
# options.IntOption('border_thresh', constants.border_thresh, 0, 255),
options.IntOption('morph_size', 25, 1, 30, lambda x: x % 2 == 1),
options.DoubleOption('min_size', 0.1, 0,
2), # Min length of min length side
options.DoubleOption('min_rectangularity', 0.7, 0, 1),
options.DoubleOption('min_inner_outer_ratio', 0.3, 0, 1),
options.DoubleOption('min_cover_diff', 25, 0, 255),
options.IntOption('blur', 27, 0, 100, lambda x: x % 2 == 1),
]
class Bins(ModuleBase):
def post(self, *args, **kwargs):
from vision.modules.base import ModuleBase # , UndefinedModuleOption
from vision.framework.transform import resize, simple_gaussian_blur
from vision.framework.helpers import to_umat # , from_umat
from vision.framework.draw import draw_circle
from vision.framework.color import bgr_to_lab, range_threshold
from vision import options
opts = [
options.DoubleOption('rectangular_thresh', 0.8, 0, 1),
options.DoubleOption('source_x_scale_bat', 0.1, 0, 1),
options.DoubleOption('source_y_scale_bat', 0.1, 0, 1),
options.DoubleOption('source_x_scale_wolf', 0.1, 0, 1),
options.DoubleOption('source_y_scale_wolf', 0.1, 0, 1),
options.DoubleOption('camera_scale', 0.35, 0, 1),
options.IntOption('min_match_count', 10, 0, 255),
options.DoubleOption('good_ratio', 0.8, 0, 1),
options.BoolOption('show_keypoints', True),
options.IntOption('min_gray', 83, 0, 255),
#options.IntOption('img_l_trg', 71, 0, 255),
#options.IntOption('img_a_trg', 94, 0, 255),
#options.IntOption('img_b_trg', 164, 0, 255),
#options.IntOption('img_d_thresh', 96, 0, 255), # 128
]
def make_poly(d1, d2):
#print(d1, d2)
return np.complex64([0, d1, (d1 + d2), d2])[:, np.newaxis]
import time
from collections import namedtuple
import math
import cv2
import shm
import numpy as np
from vision.modules import ModuleBase
from vision import options
capture_source = 'forward'
options = [
options.IntOption('lab_b_min', 41, (0, 255)),
options.IntOption('lab_b_max', 128, (0, 255)),
options.IntOption('yuv_v_min', 127, (0, 255)),
options.IntOption('yuv_v_max', 210, (0, 255)),
options.IntOption('hls_h_min', 73, (0, 255)),
options.IntOption('hls_h_max', 128, (0, 255)),
options.IntOption('min_area', 200),
options.IntOption('blur_size', 11, (1, 255), lambda x: x % 2 == 1),
options.DoubleOption('min_circularity', .35, (0, 150)),
options.DoubleOption('heuristicPower', 15),
options.IntOption('ideal_height', 510, (0, 1020)),
options.BoolOption('debugging', True)
]
class RedBuoy(ModuleBase.ModuleBase):
def __init__(self):
import cv2
import time
import math
import shm
import functools
import numpy as np
import auvlog.client
from vision import options
from vision.modules.base import ModuleBase
log = lambda m: auvlog.client.log.vision.sonar(m, copy_to_stdout = True)
options = [
options.IntOption('accumulation_count', 10, 1, 40),
options.IntOption('filter_p1', 10, 1, 100),
options.IntOption('filter_p2', 75, 1, 1000),
options.IntOption('thresh_c', 150, 1, 255),
options.IntOption('erode_kernel_size', 9, 1, 50),
options.DoubleOption('circularity_threshold', 7.0, 1.0, 20.0),
options.DoubleOption('radius_min_meters', 0.05, 0.0, 1.0),
options.DoubleOption('radius_max_meters', 0.20, 0.0, 1.0)
]
normalize = lambda x: x.astype(np.float32) / np.sum(x)
class Sonar(ModuleBase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#!/usr/bin/env python3
import math
import cv2
import shm
from mission.constants.config import wire as constants
from vision.modules.base import ModuleBase
from vision import options
options = [
options.IntOption('adaptive_thresh_block_size', constants.block_size, 1,
2500),
options.IntOption('adaptive_thresh_c', constants.thresh_c, 0, 20),
# options.IntOption('cmyk_y_min', 20, 0, 255),
# options.IntOption('cmyk_y_max', 255, 0, 255),
# options.IntOption('hsv_h_min', 18, 0, 255),
# options.IntOption('hsv_h_max', 59, 0, 255),
# options.IntOption('hsv_s_min', 0, 0, 255),
# options.IntOption('hsv_s_max', 255, 0, 255),
# options.IntOption('hsv_v_min', 0, 0, 255),
# options.IntOption('hsv_v_max', 255, 0, 255),
options.DoubleOption('min_area', constants.min_area, 0, 1000),
options.IntOption('kernel_size', constants.kernel_size, 1, 255),
options.DoubleOption('min_aspect_ratio', 6, 1, 40),
options.BoolOption('debugging', constants.debugging),
options.BoolOption('lab a', True),
options.BoolOption('lab b', False),
options.BoolOption('ycrcb cb', False),
options.BoolOption('yellow_debug', False),
from mission.constants.config import buoys as constants
from mission.constants.config import buoysVision as bv
from vision.modules.base import ModuleBase
from vision.vision_common import green, red, white, yellow
from vision import options
from vision.modules.color_balance import balance
options = [
options.BoolOption('debug', False),
options.BoolOption('red_debug', False),
options.BoolOption('green_debug', False),
options.BoolOption('yellow_debug', False),
options.BoolOption('use_color_correction', False),
options.IntOption('hls_l_min', bv.hls_l_min, 0, 255),
options.IntOption('hls_l_max', bv.hls_l_max, 0, 255),
options.IntOption('red_hls_h_min', bv.red_hls_h_min, 0, 255),
options.IntOption('red_hls_h_max', bv.red_hls_h_max, 0, 255),
options.IntOption('red_ycrcb_cb_min', bv.red_ycrcb_cb_min, 0, 255),
options.IntOption('red_ycrcb_cb_max', bv.red_ycrcb_cb_max, 0, 255),
options.IntOption('red_lab_a_min', bv.red_lab_a_min, 0, 255),
options.IntOption('red_lab_a_max', bv.red_lab_a_max, 0, 255),
options.IntOption('red_lab_b_min', bv.red_lab_b_min, 0, 255),
options.IntOption('red_lab_b_max', bv.red_lab_b_max, 0, 255),
options.IntOption('red_erode_kernel_size', bv.red_erode_kernel_size, 1,
151),
options.IntOption('red_dilate_kernel_size', bv.red_dilate_kernel_size, 1,
151),
options.IntOption('green_lab_l_min', bv.green_lab_l_min, 0, 255),
options.IntOption('green_lab_l_max', bv.green_lab_l_max, 0, 255),
# # gui_options.DoubleOption('min_line_dist', 100, 0, 1000),
# # A circle with radius 1 inscribed in a square has
# # 'rectangularity' pi/4 ~ 0.78.
# gui_options.DoubleOption('min_line_hough_length',45, 0, 500),
# gui_options.IntOption('color_dist_min', 0, 255),
# gui_options.IntOption('color_dist_max', 20, 0, 255),
# # Preprocess
# # gui_options.IntOption('gaussian_kernel', 5, 1, 40),
# # gui_options.IntOption('gaussian_stdev', 20, 0, 40),
# ],
# }
vision_options = [
gui_options.BoolOption('debugging', False),
gui_options.IntOption('canny1', 50, 0, 200),
gui_options.IntOption('canny2', 150, 0, 200),
gui_options.DoubleOption('min_angle_diff', np.pi / 8, 0, np.pi * 2),
gui_options.DoubleOption('min_line_hough_length', 45, 0, 500),
gui_options.IntOption('color_dist_min', 0, 0, 255),
gui_options.IntOption('color_dist_max', 20, 0, 255),
gui_options.IntOption('min_angle_range', 35, 0, 180),
gui_options.IntOption('max_angle_range', 55, 0, 180),
]
segment_info = namedtuple("segment_info",
["x1", "y1", "x2", "y2", "angle", "id", "updated"])
line_info = namedtuple("line_info",
["x1", "y1", "x2", "y2", "angle", "length", "id"])
INVALID_ERROR = 1e99
from collections import namedtuple
from functools import reduce
import cv2
import numpy as np
import shm
from vision.modules import buoy_common
from vision.modules.base import ModuleBase
from vision.vision_common import green, red, white, yellow
from vision import options
options = [
options.IntOption('c_thresh', -25, -100, 100),
options.IntOption('red_c_thresh', 30, -100, 100),
options.IntOption('green_c_thresh', 40, -100, 100),
options.IntOption('cr_c_thresh', 25, -100, 100),
options.IntOption('h_c_thresh', -5, -100, 100),
options.IntOption('filter_p1', 5, 1, 100),
options.IntOption('filter_p2', 75, 1, 1000),
options.IntOption('filter_p3', 75, 1, 1000),
options.IntOption('block_size', 551, 1, 1500),
options.IntOption('red_block_size', 551, 1, 1500),
options.IntOption('green_block_size', 551, 1, 1500),
options.IntOption('cr_block_size', 551, 1, 1500),
options.IntOption('h_block_size', 311, 1, 1500),
options.IntOption('blur_size', 1, 1, 150, lambda x: x % 2 == 1),
options.IntOption('kernel_size', 31, 1, 151),
options.IntOption('min_heuristic_score', 1, 0, 1000),
from collections import namedtuple
from conf.vehicle import VEHICLE, is_mainsub
from vision import options
from vision.modules.base import ModuleBase
from vision.framework.feature import outer_contours, contour_area, contour_centroid, min_enclosing_circle, min_enclosing_rect
from vision.framework.transform import resize, simple_gaussian_blur, morph_remove_noise, morph_close_holes, dilate, erode, rect_kernel
from vision.framework.helpers import to_umat, from_umat, to_odd
from vision.framework.color import bgr_to_lab, gray_to_bgr, range_threshold
from vision.framework.draw import draw_contours, draw_circle, draw_text
CUAUV_LOCALE = os.environ['CUAUV_LOCALE']
OPTS_ODYSSEUS = [
options.IntOption('lab_l_ref', 255, 0, 255),
options.IntOption('lab_a_ref', 163, 0, 255),
options.IntOption('lab_b_ref', 180, 0, 255),
options.IntOption('color_dist_thresh', 45, 0, 255),
options.IntOption('blur_kernel', 3, 0, 255),
options.IntOption('blur_std', 10, 0, 500),
options.DoubleOption('resize_width_scale', 0.5, 0, 1),
options.DoubleOption('resize_height_scale', 0.5, 0, 1),
options.IntOption('dilate_kernel', 1, 0, 255),
options.IntOption('erode_kernel', 1, 0, 255),
options.IntOption('min_contour_area', 30, 0, 500),
options.DoubleOption('min_contour_rect', 0.4, 0, 1),
options.DoubleOption('min_contour_ratio', 4.5, 0, 10),
options.DoubleOption('max_angle_from_vertical', 15, 0, 90),
options.DoubleOption('min_length', 15, 0, 500),
options.IntOption('auto_distance_percentile', 25, 0, 100),
#!/usr/bin/env python3
from vision.modules.base import ModuleBase
from vision import options
from vision.stdlib import *
import shm
import math
import time
import cv2 as cv2
import numpy as np
from collections import namedtuple
from cash_in_shared import *
module_options = [
options.IntOption('gaussian_kernel', 2, 1, 40),
options.IntOption('gaussian_stdev', 10, 0, 40),
options.IntOption('min_area', 100, 1, 2000),
options.DoubleOption('min_circularity', 0.4, 0, 1),
]
class RandomPinger(ModuleBase):
last_run = 0
def process(self, img):
curr_time = time.time()
print(curr_time - self.last_run)
if curr_time - self.last_run < .2:
print("skipping")
# self.last_run = curr_time
return
