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()