def load_font(self, path, size, search=None):
if path.startswith("/") and os.path.exists(path):
return TTF_OpenFont(path.encode("utf-8"),
math.ceil(size * self.scale))
search_dirs = [search] if search else []
search_dirs.extend(self.search)
for directory in search_dirs:
full_path = os.path.join(directory, path)
if os.path.exists(full_path):
return TTF_OpenFont(full_path.encode("utf-8"),
math.ceil(size * self.scale))
def __init__(self,
renderer,
font=None,
text="",
fontSize=16,
textColor=pixels.SDL_Color(255, 255, 255),
backgroundColor=pixels.SDL_Color(0, 0, 0)):
if isinstance(renderer, sdl2ext.RenderContext):
self.renderer = renderer.renderer
elif isinstance(renderer, render.SDL_Renderer):
self.renderer = renderer
else:
raise TypeError("unsupported renderer type")
if font is None:
font = os.path.join(os.environ["windir"], "Fonts", "Arial.ttf")
elif not os.path.isfile(font):
if os.path.isfile(
os.path.join(os.environ["windir"], "Fonts",
font + ".ttf")):
font = os.path.join(os.environ["windir"], "Fonts",
font + ".ttf")
else:
raise IOError("Cannot find %s" % font)
self.font = TTF_OpenFont(font, fontSize)
if self.font is None:
raise TTF_GetError()
self._text = text
self.fontSize = fontSize
self.textColor = textColor
self.backgroundColor = backgroundColor
texture = self._createTexture()
super(TextSprite, self).__init__(texture)
def __init__(self,
label,
fontpath,
font_size=None,
color=None,
bg_color=None,
line_height=None,
font_label=None):
self._font_size = None
self._line_height = 0.5
self.__font_size_units = P.default_font_unit
self.__line_height_units = '*' # multiple of font size
self.__fontpath = fontpath.encode('utf-8')
self.label = label
self.scale_factor = self._get_scale_factor()
self.font_size = font_size if font_size else P.default_font_size
self.font_label = font_label if font_label else P.default_font_name
self.color = rgb_to_rgba(color) if color else P.default_color
self.bg_color = rgb_to_rgba(bg_color) if bg_color else (0, 0, 0, 0)
if line_height:
self.line_height = line_height
# Load in font
self.__font = TTF_OpenFont(self.__fontpath, self._font_size)
def __init__(self,
renderer,
font=None,
text="",
font_size=16,
text_color=SDL_Color(255, 255, 255),
background_color=SDL_Color(0, 0, 0)):
self.renderer = renderer
if font is None:
font = FONTS.get_path("04B_20__.TTF")
else:
font = FONTS.get_path(font)
self.font = TTF_OpenFont(font.encode("UTF-8"), font_size)
if self.font is None:
raise TTF_GetError()
self._text = text
self.font_size = font_size
self.text_color = text_color
self.background_color = background_color
texture = self._create_texture()
super(TextSprite, self).__init__(texture)
def _get_scale_factor(self):
'''Determines the scale factor between the font in pt units and the max character height
from baseline (ignoring accents and punctuation) in pixels. Used for rendering a font at
a known size in pixels.
'''
max_ascent = 0
minX, maxX, minY, maxY, advance = c_int(0), c_int(0), c_int(0), c_int(
0), c_int(0)
caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
chars = caps + caps.lower() + "0123456789"
testfont = TTF_OpenFont(self.__fontpath, 40)
for char in chars:
TTF_GlyphMetrics(testfont, ord(char), byref(minX), byref(maxX),
byref(minY), byref(maxY), byref(advance))
if maxY.value > max_ascent:
max_ascent = maxY.value
TTF_CloseFont(testfont)
return 40 / float(max_ascent)
def font_size(self, size):
if isinstance(size, str):
unit = ''.join([i for i in size if not (i.isdigit() or i == '.')])
if len(unit):
if unit not in ['pt', 'px', 'deg']:
raise ValueError(
"Font size unit must be either 'pt', 'px', or 'deg'")
self.__font_size_units = unit
size = float(''.join(
[i for i in size if (i.isdigit() or i == '.')]))
else:
size = float(size)
if self.__font_size_units == 'px':
self._font_size = int(size * self.scale_factor)
elif self.__font_size_units == 'deg':
self._font_size = int(deg_to_px(size) * self.scale_factor)
else:
self._font_size = int(size)
TTF_CloseFont(self.__font)
self.__font = TTF_OpenFont(self.__fontpath, self._font_size)
def __init__(self, renderer):
super(FPS, self).__init__()
self.renderer = renderer
self.font = TTF_OpenFont(RESOURCES.get_path("tuffy.ttf"), 16)
def main(video_filename):
sdl2.ext.init()
SDL_Init(SDL_INIT_VIDEO)
SDL_Init(SDL_INIT_JOYSTICK)
TTF_Init()
window_size_width = 800
window_size_height = 400
image_width = 320
image_height = 240
border_width = 50
axis_animation_range = 300
window = SDL_CreateWindow(b"Joystick Servo Platform",
100,
100,
window_size_width,
window_size_height,
SDL_WINDOW_SHOWN)
renderer = SDL_CreateRenderer(
window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC)
window_sensors = sdl2.ext.Window("Sensor Images", size=(image_width * 2, image_height))
RESOURCES = sdl2.ext.Resources(__file__, "resources")
# load background
path = RESOURCES.get_path('circle.png').encode('utf8')
texture_operation = loadTexture(path, renderer)
# load help image
path = RESOURCES.get_path('help.png').encode('utf8')
texture_help = loadTexture(path, renderer)
# load axis image
path = RESOURCES.get_path('axis.png').encode('utf8')
texture_axis = loadTexture(path, renderer)
texture_axis_w, texture_axis_h = ctypes.c_int(), ctypes.c_int()
SDL_QueryTexture(texture_axis, None, None, texture_axis_w, texture_axis_h)
texture_axis_w, texture_axis_h = texture_axis_w.value, texture_axis_h.value
# load font
fontfile = RESOURCES.get_path('arialbd.ttf').encode('utf8')
fontsize = 14
ttffont = TTF_OpenFont(fontfile, fontsize)
# instructions to be shown on the gui
instructions = [
'=============== Menu =================',
'Choose serial port for left platform, then for right platform, using number',
'Press "s" to swap serial connections',
'Press "c" to close all serial connections',
'Press "t" to test connections',
'Press "h" to show or hide the picture of the usage of joystick'
]
instructions_sensor = [
'---------------- ',
'Choose sensor for the left, then for the right, using (a,b)',
'Press "v" to show images from touch sensor',
'Press "x" to exchange images from sensor',
'Prsss "M" to write image to file',
'Press "N" to stop write image to file',
'Press "q" to quit'
]
h_offset = 15
selected_ports = OrderedDict({'Left': None, 'Right': None})
selected_sensors = OrderedDict({'Left Sensor': None, 'Right Sensor': None})
avaliable_ports = get_serial_port()
joystick = JoystickController()
start_position = (10, 10)
def list_infos(pre_info, info_list, dev_list, selected_items, start_position, h_offset, use_alpha=False):
for index, item in enumerate(pre_info):
txt_texture = renderText(item, ttffont, SDL_BLACK, renderer)
renderTexture(txt_texture, renderer, start_position[0], start_position[1] + index * h_offset)
if len(dev_list) > 0:
port_str = info_list[0]
else:
port_str = info_list[1]
txt_texture = renderText(port_str, ttffont, SDL_BLACK, renderer)
renderTexture(txt_texture, renderer, start_position[0],
start_position[1] + h_offset * len(pre_info))
for index, port in enumerate(dev_list):
if use_alpha:
index_char = chr(index + 97)
else:
index_char = str(index)
port_str = ' ' * 9 + '[' + index_char + ']' + str(port)
txt_texture = renderText(port_str, ttffont, SDL_BLACK, renderer)
renderTexture(txt_texture, renderer, start_position[0],
start_position[1] + h_offset * (len(pre_info) + 1 + index))
for index, (platform_index, port) in enumerate(selected_items.items()):
if port is None:
port_str = 'None'
color = SDL_RED
else:
port_str = str(port)
color = SDL_GREEN
txt_texture = renderText(platform_index + ':' + port_str, ttffont,
color, renderer)
renderTexture(
txt_texture, renderer, start_position[0], start_position[1] + h_offset *
(len(pre_info) + 1 + len(dev_list) + index))
list_infos(instructions,
['Avaliable serial ports:', 'No serial port avaliable'] ,
get_serial_port(),
selected_ports,
start_position,
h_offset)
# just get the usb touch sensor list only once to save time and didn't use the win32api
avaliable_touch_sensors = get_touch_sensor_list()
print(avaliable_touch_sensors)
start_position_sensor = start_position[0], start_position[1] + 180
list_infos(instructions_sensor,
['Avaliable sensors:', 'No sensors avaliable'] ,
avaliable_touch_sensors,
selected_sensors,
start_position_sensor,
h_offset)
event = sdl2.SDL_Event()
show_help_picture = False
running = True
# joystick_message = None
show_sensors_images = False
sensor_left_cap, sensor_right_cap = None, None
sensor_left_writer, sensor_right_writer = None, None
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == SDL_KEYDOWN:
keyboard_state = SDL_GetKeyboardState(None)
if keyboard_state[SDL_SCANCODE_S]:
selected_ports['Left'], selected_ports[
'Right'] = selected_ports['Right'], selected_ports[
'Left']
joystick.swap_connections()
elif keyboard_state[SDL_SCANCODE_H]:
show_help_picture = not show_help_picture
elif keyboard_state[SDL_SCANCODE_C]:
selected_ports['Left'], selected_ports[
'Right'] = None, None
joystick.close_connections()
elif keyboard_state[SDL_SCANCODE_T]:
joystick.shock_spindle()
elif keyboard_state[SDL_SCANCODE_A]:
if len(avaliable_touch_sensors) < 1:
break
sensor = avaliable_touch_sensors[0]
if sensor_left_cap is None:
sensor_left_cap = cv2.VideoCapture(sensor, cv2.CAP_DSHOW)
index = 'Left Sensor'
else:
sensor_right_cap = cv2.VideoCapture(sensor, cv2.CAP_DSHOW)
index = 'Right Sensor'
selected_sensors[index] = sensor
elif keyboard_state[SDL_SCANCODE_B]:
if len(avaliable_touch_sensors) < 2:
break
sensor = avaliable_touch_sensors[1]
if sensor_left_cap is None:
sensor_left_cap = cv2.VideoCapture(sensor, cv2.CAP_DSHOW)
index = 'Left Sensor'
else:
sensor_right_cap = cv2.VideoCapture(sensor, cv2.CAP_DSHOW)
index = 'Right Sensor'
selected_sensors[index] = sensor
elif keyboard_state[SDL_SCANCODE_V]:
if sensor_right_cap is not None or sensor_left_cap is not None:
show_sensors_images = True
window_sensors.show()
if sensor_right_cap is not None:
sensor_right_cap.set(3, 320)
sensor_right_cap.set(4, 240)
if sensor_left_cap is not None:
sensor_left_cap.set(3, 320)
sensor_left_cap.set(4, 240)
# print('press V')
elif keyboard_state[SDL_SCANCODE_M]:
writer_num = 0
if sensor_right_cap is not None:
fps = sensor_right_cap.get(cv2.CAP_PROP_FPS)
width = sensor_right_cap.get(cv2.CAP_PROP_FRAME_WIDTH)
height = sensor_right_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
sensor_right_writer = cv2.VideoWriter(video_filename + '_right.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'),
30,
(int(width), int(height)))
print('Writing right sensor''s image.')
if sensor_left_cap is not None:
fps = sensor_left_cap.get(cv2.CAP_PROP_FPS)
width = sensor_left_cap.get(cv2.CAP_PROP_FRAME_WIDTH)
height = sensor_left_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
print('fps,w,h:',fps, width, height)
sensor_left_writer = cv2.VideoWriter(video_filename + '_left.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'),
30,
(int(width), int(height)))
print('Writing left sensor''s image.')
elif keyboard_state[SDL_SCANCODE_N]:
sensor_writer_exist = False
if sensor_right_writer is not None:
sensor_right_writer.release()
sensor_right_writer = None
sensor_writer_exist = True
if sensor_left_writer is not None:
sensor_left_writer.release()
sensor_left_writer = None
sensor_writer_exist = True
if sensor_writer_exist:
print('All video writers are closed')
elif keyboard_state[SDL_SCANCODE_X]:
sensor_left_cap, sensor_right_cap = sensor_right_cap, sensor_left_cap
elif keyboard_state[SDL_SCANCODE_Q]:
running = False
break
# num key
elif event.key.keysym.scancode in SDL_SCANCODE_NUM_LIST:
# pdb.set_trace()
num = SDL_SCANCODE_NUM_LIST.index(
event.key.keysym.scancode)
if num < len(avaliable_ports) and avaliable_ports[num] not in selected_ports.values() and\
None in selected_ports.values():
for index, value in selected_ports.items():
if value is None:
if index == 'Left':
joystick.con_left = GrblCmd(
avaliable_ports[num])
else:
joystick.con_right = GrblCmd(
avaliable_ports[num])
selected_ports[index] = avaliable_ports[num]
break
elif event.type == sdl2.SDL_QUIT:
running = False
else:
joystick_message = joystick.update(event)
# print(event.type, event.key)
SDL_RenderClear(renderer)
# draw background
if show_help_picture:
renderTexture(texture_help, renderer, 0, 0)
else:
renderTexture(texture_operation, renderer, 0, 0)
# draw axis poles
x_L_axis = int(border_width + axis_animation_range / 2 +
joystick.axis['L_H'] * axis_animation_range / 2 -
texture_axis_w / 2)
y_L_axis = int(border_width + axis_animation_range / 2 +
joystick.axis['L_V'] * axis_animation_range / 2 -
texture_axis_h / 2)
renderTexture(texture_axis, renderer, x_L_axis, y_L_axis)
x_R_axis = int(window_size_width -
(border_width + axis_animation_range / 2) +
joystick.axis['R_H'] * axis_animation_range / 2 -
texture_axis_w / 2)
y_R_axis = int(border_width + axis_animation_range / 2 +
joystick.axis['R_V'] * axis_animation_range / 2 -
texture_axis_h / 2)
renderTexture(texture_axis, renderer, x_R_axis, y_R_axis)
# draw help info and the serial port info
list_infos(instructions,
['Avaliable serial ports:', 'No serial port avaliable'] ,
get_serial_port(),
selected_ports,
start_position,
h_offset)
list_infos(instructions_sensor,
['Avaliable sensors:', 'No sensors avaliable'] ,
avaliable_touch_sensors,
selected_sensors,
start_position_sensor,
h_offset, use_alpha=True)
# joystick connection status
if joystick.device is not None:
color = SDL_BLUE
joystick_state_text = 'Joystick'
else:
color = SDL_GRAY
joystick_state_text = 'Joystick'
txt_texture = renderText(joystick_state_text, ttffont, color, renderer)
# shown on right corner
renderTexture(txt_texture, renderer,
window_size_width - 10 * len(joystick_state_text), 10)
SDL_RenderPresent(renderer)
# get pictures
if show_sensors_images:
total_image = np.zeros((image_width * 2, image_height, 3), dtype=np.uint8)
if sensor_left_cap is not None:
ret, left_image = sensor_left_cap.read()
if ret:
if sensor_left_writer is not None:
sensor_left_writer.write(left_image)
total_image[:image_width,:,:] = np.rot90(left_image)
if sensor_right_cap is not None:
# pdb.set_trace()
ret, right_image = sensor_right_cap.read()
if ret:
if sensor_right_writer is not None:
sensor_right_writer.write(right_image)
total_image[image_width:,:,:] = np.rot90(right_image)
load_CV_images_to_window(total_image, window_sensors.window)
window_sensors.refresh()
TTF_CloseFont(ttffont)
SDL_DestroyTexture(texture_operation)
SDL_DestroyRenderer(renderer)
SDL_DestroyWindow(window)
SDL_Quit()