def __init__(self, module):
self.module = module
self.options = [
options.BoolOption('PPX_grayscale', False),
options.BoolOption('PPX_lab', 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
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),
]
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
#!/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)
options.IntOption('green_erode_kernel_size', 5, 1, 151),
options.IntOption('green_dilate_kernel_size', 5, 1, 151),
options.IntOption('yellow_hls_h_min', 17, 0, 255),
options.IntOption('yellow_hls_h_max', 49, 0, 255),
options.IntOption('yellow_ycrcb_cb_min', 0, 0, 255),
options.IntOption('yellow_ycrcb_cb_max', 120, 0, 255),
options.IntOption('yellow_lab_a_min', 0, 0, 255),
options.IntOption('yellow_lab_a_max', 122, 0, 255),
options.IntOption('yellow_lab_b_min', 148, 0, 255),
options.IntOption('yellow_lab_b_max', 255, 0, 255),
options.IntOption('yellow_erode_kernel_size', 1, 1, 151),
options.IntOption('yellow_dilate_kernel_size', 1, 1, 151),
options.IntOption('blur_kernel', 1, 1, 151),
options.IntOption('max_error', 5000, 100, 100000),
options.IntOption('max_buoy_error', 1500, 100, 100000),
options.DoubleOption('min_circularity', 0.65, 0.1, 0.95),
options.DoubleOption('min_percent_frame', 0.0002, 0, 0.01)
]
# L, A, B
#RED_REF = (150, 180, 180)
#GREEN_REF = (95, 115, 150)
#YELLOW_REF = (200, 100, 180)
RED_REF = (100, 170, 170)
GREEN_REF = (100, 80, 170)
YELLOW_REF = (140, 114, 180)
DOWNSCALE_RATIO = 0.33
CONTOUR_CIRCULARITY_HEURISTIC_LIMIT = 50
CONTOUR_SCALED_HEURISTIC_LIMIT = 20
CONTOUR_CLASSIFICATION_LIMIT = 5
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'):
min = o('lab_{}_min'.format(chan))
# # '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 conf.vehicle import VEHICLE
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),
options.IntOption('yellow_hls_h_min', 58, 0, 255),
options.IntOption('yellow_hls_h_max', 100, 0, 255),
options.IntOption('yellow_ycrcb_cb_min', 111, 0, 255),
options.IntOption('yellow_ycrcb_cb_max', 145, 0, 255),
options.IntOption('yellow_lab_a_min', 0, 0, 255),
options.IntOption('yellow_lab_a_max', 101, 0, 255),
options.IntOption('yellow_lab_b_min', 95, 0, 255),
options.IntOption('yellow_lab_b_max', 152, 0, 255)
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):
super(RedBuoy, self).__init__(options, True)
self.vsp_data = None
self.times = []
def process(self, mat):
self.times.insert(0, time.time())
while time.time() - self.times[-1] > 5:
import traceback
import sys
import time
import numpy as np
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
]
#!/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']
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
class Dice(ModuleBase):
def post_umat(self, tag, img):
self.post(tag, cv2.UMat.get(img))
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),
gui_options.IntOption('orange_rgb_r_max', 255, 0, 255),
gui_options.IntOption('orange_ycrcb_y_min', 125, 0, 255),
gui_options.IntOption('orange_ycrcb_y_max', 255, 0, 255),
gui_options.IntOption('dark_lab_l_min', 54, 0, 255),
#!/usr/bin/env python3
import shm
import cv2
import time
import numpy as np
from vision.modules.base import ModuleBase
from vision.framework.transform import resize, simple_gaussian_blur
from vision.framework.helpers import to_umat, from_umat
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)
]
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):
if self.options['debug']:
super().post(*args, **kwargs)
def draw_contours(self, mat, *contours):
cv2.drawContours(mat, contours, -1, (0, 127, 255), thickness=3)
import numpy as np
from vision.modules.base import ModuleBase # , UndefinedModuleOption
from vision.framework.transform import resize, simple_gaussian_blur
from vision.framework.feature import outer_contours, contour_centroid, contour_area, simple_canny
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),
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)
self.prev = []
def process(self, mat):
c0, c1, c2 = cv2.split(mat)
#!/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']
options.IntOption('yellow_hls_h_min', bv.yellow_hls_h_min, 0, 255),
options.IntOption('yellow_hls_h_max', bv.yellow_hls_h_max, 0, 255),
options.IntOption('yellow_ycrcb_cb_min', bv.yellow_ycrcb_cb_min, 0, 255),
options.IntOption('yellow_ycrcb_cb_max', bv.yellow_ycrcb_cb_max, 0, 255),
options.IntOption('yellow_lab_a_min', bv.yellow_lab_a_min, 0, 255),
options.IntOption('yellow_lab_a_max', bv.yellow_lab_a_max, 0, 255),
options.IntOption('yellow_lab_b_min', bv.yellow_lab_b_min, 0, 255),
options.IntOption('yellow_lab_b_max', bv.yellow_lab_b_max, 0, 255),
options.IntOption('yellow_erode_kernel_size', bv.yellow_erode_kernel_size,
1, 151),
options.IntOption('yellow_dilate_kernel_size',
bv.yellow_dilate_kernel_size, 1, 151),
options.IntOption('blur_kernel', bv.blur_kernel, 1, 151),
options.IntOption('max_error', bv.max_error, 100, 100000),
options.IntOption('max_buoy_error', bv.max_buoy_error, 100, 100000),
options.DoubleOption('min_circularity', bv.min_circularity, 0.1, 0.95),
options.DoubleOption('min_percent_frame', bv.min_percent_frame, 0, 0.01),
options.IntOption('ex', bv.ex, 0, 1600),
options.IntOption('ey', bv.ey, 0, 1200),
options.IntOption('max_y_diff', bv.max_y_diff, 0, 500),
options.IntOption('min_x_diff', bv.min_x_diff, 0, 500)
]
CONTOUR_CIRCULARITY_HEURISTIC_LIMIT = 50
CONTOUR_SCALED_HEURISTIC_LIMIT = 20
CONTOUR_CLASSIFICATION_LIMIT = 6
ContourAreaData = namedtuple('ContourAreaData', ['contour', 'area'])
ContourScoreData = namedtuple(
'ContourScoreData',
['contour', 'area', 'circularity', 'score', 'center', 'radius'])
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
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
self.last_run = curr_time
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),
options.IntOption('nonblack_thresh', 900, 0, 10000),
options.IntOption('water_a_thresh', 20, 0, 255),
options.IntOption('water_b_thresh', 25, 0, 255),
options.BoolOption('debug', True),
]
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),
]
POST_UMAT = True
ROTATION_PREDICTION_ANGLE = 20
DOWNWARD_CAM_WIDTH = shm.camera.downward_width.get()
DOWNWARD_CAM_HEIGHT = shm.camera.downward_height.get()
# 30 for green, 75 for red
TARGET_ANGLE = 30
def within_camera(x, y):
return 0 <= x < DOWNWARD_CAM_WIDTH and 0 <= y < DOWNWARD_CAM_HEIGHT
