def __init__(self, screen, sprite_sheet, sheet_offsets, pos=(0, 0), resize=None, detail=None, frame_delay=None, flip=False): super().__init__() self.screen = screen if not resize: resize = (self.screen.get_height() // 10, self.screen.get_height() // 10) self.image_manager = ImageManager(sprite_sheet, sheet=True, pos_offsets=sheet_offsets, resize=resize, animation_delay=frame_delay) if flip: self.image_manager.flip() self.image, self.rect = self.image_manager.get_image() if detail: self.detail_piece = ImageManager( detail, sheet=True, pos_offsets=sheet_offsets, resize=resize).all_images()[ 0] # grab first image in detail sheet if flip: self.image_manager.flip() self.image.blit(self.detail_piece, (0, 0)) # combine detail else: self.detail_piece = None self.rect.centerx, self.rect.centery = pos
def __init__(self): self.images = np.array([ImageManager(), ImageManager()]) self.bridge = CvBridge() # Intrinsic camera calibration matrices self.camera_K = None self.camera_D = None # Image sizes self.image_h = 1 self.image_w = 1 # Current command sent to duckiebot self.joy_command = Twist2DStamped() # Initiate the feature detector self.cv2_detector = None self.last_ros_time = time.time() self.last_theta = 0 # Initialize parameters self.parameters = VisualOdometryParameters() self.mask_params = [0.5, 0.7, 0.4] self.stingray_mask = [] self.mask_img=None self.histogram_img=None
def __init__(self, screen, x, y, direction, maze, p_type=P_TYPE_1): self.screen = screen self.maze = maze self.direction = direction self.p_type = p_type if p_type == Portal.P_TYPE_1: self.image_manager = ImageManager('blue-portal-bg.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (64, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (64, 32, 32, 32), (0, 64, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=250) image, _ = self.image_manager.get_image() else: self.image_manager = ImageManager('orange-portal-bg.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (64, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (64, 32, 32, 32), (0, 64, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=250) image, _ = self.image_manager.get_image() super().__init__(x, y, maze.block_size, maze.block_size, image)
def __init__(self, screen, maze): super().__init__() self.screen = screen self.radius = maze.block_size // 5 self.maze = maze self.sound_manager = SoundManager(sound_files=['pacman-pellet-eat.wav', 'pacman-fruit-eat.wav', 'pacman-killed.wav', 'pacman-portal.wav'], keys=['eat', 'fruit', 'dead', 'portal'], channel=PacMan.PAC_AUDIO_CHANNEL) self.horizontal_images = ImageManager('pacman-horiz.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (0, 64, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), reversible=True) self.vertical_images = ImageManager('pacman-vert.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (0, 64, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), reversible=True) self.death_images = ImageManager('pacman-death.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (0, 64, 32, 32), (32, 64, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=150, repeat=False) self.flip_status = {'use_horiz': True, 'h_flip': False, 'v_flip': False} self.spawn_info = self.maze.player_spawn[1] self.tile = self.maze.player_spawn[0] self.direction = None self.moving = False self.speed = maze.block_size // 7 self.image, self.rect = self.horizontal_images.get_image() self.rect.centerx, self.rect.centery = self.spawn_info # screen coordinates for spawn self.dead = False self.portal_controller = PortalController(screen, self, maze) # controller object for portal # Keyboard related events/actions/releases self.event_map = {pygame.KEYDOWN: self.perform_action, pygame.KEYUP: self.reset_direction} self.action_map = {pygame.K_UP: self.set_move_up, pygame.K_LEFT: self.set_move_left, pygame.K_DOWN: self.set_move_down, pygame.K_RIGHT: self.set_move_right, pygame.K_q: self.blue_portal, pygame.K_w: self.orange_portal}
def __init__(self) -> None: self.image_manager = ImageManager() self.updater = Updater(token=environ.get('HS_TELEGRAM_BOT_TOKEN'), request_kwargs={ "connect_timeout": 60., "read_timeout": 60. }, use_context=True)
def setUp(self): aws_connector = AwsConnector(None) self.s3_resource = aws_connector.get_s3_resource() self.s3_resource.create_bucket( Bucket=self.BUCKET, CreateBucketConfiguration={'LocationConstraint': 'eu-west-2'}, ) self.image_manager = ImageManager(self.s3_resource, self.BUCKET)
def __init__(self, parent, pixel_width, pixel_height, pixel_seq=None, FPS=50, left=None, right=None, top=None, bottom=None, width=None, height=None): super().__init__(parent, left=left, right=right, top=top, bottom=bottom, width=width, height=height) self.pixel_height = pixel_height self.pixel_width = pixel_width self.mgr = ImageManager(img_height = pixel_height, img_width = pixel_width, max_texture_size=1024) self.set_wait_img() if pixel_seq is not None: self.set_pixels(pixel_seq) self.img_index = 0 self.switch_time = 1/FPS self.countdown = self.switch_time
def setUpClass(self): self.database_connector = database_connector.DatabaseConnector() self.item_manager = database_manager.ItemManager( self.database_connector) self.tag_manager = database_manager.TagManager(self.database_connector) aws_connector = AwsConnector(None) self.s3_resource = aws_connector.get_s3_resource() self.image_manager = ImageManager(self.s3_resource, self.BUCKET) self.product_manager = product_manager.ProductManager( self.item_manager, self.tag_manager, self.image_manager)
def get_labels(): decoded_image = base64.b64decode(request.data) image_manager = ImageManager() client = vision.Client() vision_service = VisionService(client, image_manager) labels = vision_service.find_features(decoded_image) style = StylesComparator(request.data) labels = style.filter_labels(labels) twin_response = style.find_twin(labels) style.save_new_image_and_labels(labels) return generate_response(labels, style, twin_response)
def __init__(self, screen, initial_count=3, ct_pos=(0, 0), images_size=(32, 32)): self.screen = screen self.max_lives = initial_count self.lives = initial_count sheet_images = ImageManager('pacman-horiz.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32), (0, 64, 32, 32)], resize=images_size).all_images() life_image = sheet_images[-1] # get last image from the sprite sheet self.life_display = ImageRow(screen, life_image, initial_count, 'Lives', ct_pos)
def test1(data): decoded_image = data if not MOCK_LABELS: image_manager = ImageManager() client = vision.Client() vision_service = VisionService(client, image_manager) labels = vision_service.find_features(decoded_image) else: labels = ['clothing', 'puma', 'star wars'] print labels style = StylesComparator(data) res = style.create_output_for_user(style.image_stream, labels) return res["styles"]
def predict(self, image_path): manager = ImageManager() manager.get_image_info([image_path], self.prediction_path) feature_columns = [tf.feature_column.numeric_column(k) for k in self.feature_name] classifier = tf.estimator.DNNClassifier( feature_columns=feature_columns, hidden_units=[10, 10], n_classes=10, model_dir='/tmp/image_model' ) predictions = classifier.predict(input_fn=(lambda: self.input_fn_predict())) for prediction in predictions: id = prediction['class_ids'] if prediction['probabilities'][id] >= 0.6: object_predict = self.find_object_by_id(id) return object_predict else: return None
def main(): pygame.init() size = width, height = 800, 800 d_surf = pygame.display.set_mode(size) clock = pygame.time.Clock() car_id = 'CAR_ID' wheel_id = 'WHEEL_ID' lot_id = 'LOT_ID' car_start_pos = (400, 600) car_length = 90 car_width = 50 car_angle = 0 wheel_angle = 0 image_manager = ImageManager() image_manager.put(car_id, 'images/car.png', (64, 112)) image_manager.put(wheel_id, 'images/tyre.png', (8, 24)) image_manager.put(lot_id, 'images/lot.png', (800, 800)) car = Car(car_id, wheel_id, car_start_pos, car_length, car_width, car_angle, wheel_angle) car_controller = CarController(car) car_drawer = CarDrawer(image_manager) while True: delta_ms = clock.tick(30) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type in (pygame.KEYUP, pygame.KEYDOWN): car_controller.handle_event(event) car_controller.update() car.update() d_surf.blit(image_manager.get(lot_id), (0, 0)) car_drawer.draw(d_surf, car) pygame.display.update()
def sense_and_act(self): """ Shouldn't actually affect the motors, but should request that a picture should be taken. :return: a """ Motors().stop() image = self.find_sensob(CameraSensob).update() im = ImageManager(image=image) im.dump_image('/') triple2 = [0] * 3 for x in range(im.xmax): for y in range(im.ymax): t = im.get_pixel(x, y) for i in range(len(triple2)): triple2[i] += t[i] t3 = [] for i in triple2: t3.append(i / (im.xmax * im.ymax)) over_50 = False for i in t3: if i > 50: over_50 = True if over_50: self.priority = 1 self.match_degree = 1 self.motor_recommendations = ["r"] else: self.priority = 1 self.match_degree = 1 self.bbcon.notifications.append("q") print("We found our item!") # self.find_sensob(UltrasonicSensob).value = 11.0 self.bbcon.notifications.remove("p")
import numpy import GA from PIL import Image from image_manager import ImageManager image = ImageManager() def cycle(size_of_population, total_population, mating_parents, colors, img_new, gen): fitness = GA.fitness_function(image.get_array(), total_population, image.use_inverse_img) parents = GA.select(total_population, fitness, mating_parents) offspring_crossover = GA.crossover_function( parents, (size_of_population[0] - parents.shape[0], image.weights, colors), image.get_array(), img_new, image.use_inverse_img) offspring_mutation = GA.mutation(offspring_crossover) total_population[0:parents.shape[0], :, :] = parents total_population[parents.shape[0]:, :, :] = offspring_mutation image.create(image.step_destination + str(gen), 0, total_population) def main(gens, number_of_solutions, mating_parents, colors): img_new = Image.new('RGB', (image.width, image.height), 'WHITE')
def search_and_scrape(self, search_terms_for_directories, target_number=800): for directory, search_terms in search_terms_for_directories.items(): directory = os.path.join(self.image_manager.base_directory, directory) if not os.path.exists(directory): os.makedirs(directory) for search_term in search_terms: self.search_for_items(search_term) n_images_scraped = 0 while n_images_scraped<target_number: images = self.find_images() if len(images) <= n_images_scraped: break self.scrape_images(images[n_images_scraped:], directory, search_term, start_index=n_images_scraped) n_images_scraped = len(images) if __name__=='main': base_directory = '~/tree-logic/tree_photos' manager = ImageManager(base_directory) search_terms_for_directories = { 'betula_papyrifera': ['betula papyrifera'] # ,'acer_macrophylum': ['bigleaf maple forest', 'acer macrophylum tree', 'bigleaf maple branches'] # ,'platanus_acerifolia': ['london plane tree', 'london plane flowers'] # ,'pseudotsuga_menziesii': ['pseudotsuga menziesii tree', 'douglas fir needles'] } search_and_scrape(search_terms_for_directories)
import cv2 import numpy as np import matplotlib # need to specify matplot lib to use "tkAgg before pyplot is imported" matplotlib.use("TkAgg") import matplotlib.pyplot as plt from image_manager import ImageManager from color_converter import ColorConverter from gui import GUI # Color is strange because OpenCV us BGR for color and matplotlib uses RGB # Need to convert to RGB before plot with matplotlib manager = ImageManager() # img = manager.upload("john.png") # RGB_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) gui = GUI(manager) # print(img[0]) # print(RGB_image[0]) # def make_grayscale(img): # return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # probably want to generate the figsize based off of pic dimensions # plt.figure(figsize=(5, 6)), plt.imshow(RGB_image) #grey image(must specify a gray color map in imshow) # manager.make_grayscale() # manager.convert('to_grayscale') # reds = manager.get_reds()
def instance(): return ImageManager(tempfile.mkdtemp(prefix='hobo-sapiens__image-hash'))
def test_storage(instance: ImageManager): instance.image_hashes['asd'] = '123' assert instance.image_hashes['asd'] == '123' assert ImageManager( instance.image_hashes.directory).image_hashes['asd'] == '123'
from contract.config import config from contract.download_images import download_images as contract_download_images from contract.download_images import metadata as download_images_metadata from contract.listen_images import listen_images as contract_listen_images from contract.listen_images import metadata as listen_images_metadata from contract.get_contract import get_contract from contract.download_image_data import download_image_data from contract.download_image_data import metadata as download_images_data_metadata from contract.download_image_data import errors as download_images_data_errors from image_manager import ImageManager app = Flask(__name__) image_checker = NNModelChecker() image_manager = ImageManager(image_checker) @app.before_request def log_request_info(): app.logger.debug('Headers: %s', request.headers) app.logger.debug('Body: %s', request.get_data()) def load_image(data): nparr = np.fromstring(data, np.uint8) # decode image img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) img = Image.fromarray(img) return img
def __init__(self, x, y, width, height): images = ['apple.png', 'cherry.png', 'peach.png', 'strawberry.png'] fruit_image, _ = ImageManager(img=choice(images), resize=(width // 2, height // 2)).get_image() super(Fruit, self).__init__(x, y, width, height, fruit_image)
def main(): image_manager = ImageManager() image_manager.store('images/background.png', 'BACKGROUND') image_manager.store('images/unit_neutral.png', 'NEUTRAL') image_manager.store('images/unit_guard.png', 'GUARD') image_manager.store('images/unit_attack.png', 'ATTACK') image_manager.store('images/unit_attack_prepare.png', 'ATTACK_PREPARE') image_manager.store('images/unit_thrust_prepare.png', 'THRUST_PREPARE') image_manager.store('images/unit_thrust.png', 'THRUST') image_manager.store('images/unit_deflected.png', 'DEFLECTED') image_manager.store('images/unit_damaged.png', 'DAMAGED') unit_drawer_1 = UnitDrawer({ unit.STATE_NEUTRAL: image_manager.image('NEUTRAL').size((384, 288)).get(), unit.STATE_GUARD: image_manager.image('GUARD').size((384, 288)).get(), unit.STATE_ATTACK: image_manager.image('ATTACK').size((384, 288)).get(), unit.STATE_ATTACK_PREPARE: image_manager.image('ATTACK_PREPARE').size((384, 288)).get(), unit.STATE_THRUST_PREPARE: image_manager.image('THRUST_PREPARE').size((384, 288)).get(), unit.STATE_THRUST: image_manager.image('THRUST').size((384, 288)).get(), unit.STATE_DEFLECT: image_manager.image('GUARD').size((384, 288)).get(), unit.STATE_DEFLECTED: image_manager.image('DEFLECTED').size((384, 288)).get(), unit.STATE_DAMAGED: image_manager.image('DAMAGED').size((384, 288)).get() }) unit_drawer_2 = UnitDrawer({ unit.STATE_NEUTRAL: image_manager.image('NEUTRAL').size((384, 288)).flipped().get(), unit.STATE_GUARD: image_manager.image('GUARD').size((384, 288)).flipped().get(), unit.STATE_ATTACK: image_manager.image('ATTACK').size((384, 288)).flipped().get(), unit.STATE_ATTACK_PREPARE: image_manager.image('ATTACK_PREPARE').size((384, 288)).flipped().get(), unit.STATE_THRUST_PREPARE: image_manager.image('THRUST_PREPARE').size((384, 288)).flipped().get(), unit.STATE_THRUST: image_manager.image('THRUST').size((384, 288)).flipped().get(), unit.STATE_DEFLECT: image_manager.image('GUARD').size((384, 288)).flipped().get(), unit.STATE_DEFLECTED: image_manager.image('DEFLECTED').size((384, 288)).flipped().get(), unit.STATE_DAMAGED: image_manager.image('DAMAGED').size((384, 288)).flipped().get() }) unit_1 = Unit((-20, 124), (384, 288)) unit_2 = Unit((140, 124), (384, 288)) arena = Arena(unit_1, unit_2, ai_func) arena_drawer = ArenaDrawer( unit_drawer_1, unit_drawer_2, image_manager.image('BACKGROUND').size((500, 500)).get()) arena_control = ArenaControl(arena) duel_manager = DuelManager(unit_1, unit_2) pygame.init() pygame.display.set_caption('Duel') size = width, height = 500, 500 d_surf = pygame.display.set_mode(size) clock = pygame.time.Clock() while True: delta_ms = clock.tick(30) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() else: arena_control.handle_event(event) duel_manager.update() arena.update() clock.tick(30) arena_drawer.draw(d_surf, arena) pygame.display.update()
from config import DatabaseConf, ImageConf from response import Response import login_config CONFIG = login_config.get_config() database_connector = DatabaseConnector(database=CONFIG.DB, host=CONFIG.HOST, user=CONFIG.USER, password=CONFIG.PASSWORD) database_connector.create_database(CONFIG.DB) database_connector.create_tables() connection = database_connector.get_connection() item_manager = ItemManager(database_connector) tag_manager = TagManager(database_connector) s3_resource = AwsConnector(CONFIG.BOTO3_PROFILE).get_s3_resource() image_manager = ImageManager(s3_resource, CONFIG.BUCKET) product_manager = ProductManager(item_manager, tag_manager, image_manager) application = Flask(__name__) application.secret_key = CONFIG.SECRET_KEY login_manager = LoginManager() login_manager.init_app(application) js = Bundle('js/helper.js', 'js/add-products.js', 'js/lettering.js', 'js/front-page.js', 'js/search.js', 'js/ajax.js', 'js/setup.js',
def __init__(self, root: Tk): self.__root = root self.__image_manager = ImageManager() root.rowconfigure(0, weight=1) root.columnconfigure(0, weight=1) main_window = ttk.Frame(root) main_window.rowconfigure(0, weight=1) main_window.columnconfigure(0, weight=2) main_window.columnconfigure(1, weight=2) main_window.grid(row=0, column=0, sticky=(N, S, W, E)) # Create scrollable images self.__face_detected = False self.__left_image_window = ScrollableImage( main_window, image=self.__image_manager.image) self.__left_image_window.grid(row=0, column=0, sticky=(N, S, W, E)) self.__right_image_window = ScrollableImage( main_window, image=self.__image_manager.manipulated_image) self.__right_image_window.grid(row=0, column=1, sticky=(N, S, W, E)) # Create menu bar root.option_add('*tearOff', FALSE) menu_bar = Menu(root) file_menu = Menu(menu_bar) file_menu.add_command(label='Open', command=self.open_file) file_menu.add_command(label="Save", command=self.save_image_as, accelerator='Ctrl-s') menu_bar.add_cascade(menu=file_menu, label='File') edit_menu = Menu(menu_bar) edit_menu.add_command(label='Undo', command=self.undo, accelerator='Ctrl-z') edit_menu.add_command(label='Rotate 90° ↷', command=self.gui_update_wrapper( self.__image_manager.rotate_by_90, True)) edit_menu.add_command(label='Rotate 180° ↷', command=self.gui_update_wrapper( self.__image_manager.rotate_by_180, True)) edit_menu.add_command(label='Rotate -90° ↶', command=self.gui_update_wrapper( self.__image_manager.rotate_by_270, True)) edit_menu.add_command(label="Grayscale", command=self.gui_update_wrapper( self.__image_manager.to_grayscale, True), accelerator='Ctrl-g') menu_bar.add_cascade(menu=edit_menu, label='Edit') blurs_menu = Menu(menu_bar) blurs_menu.add_command(label='Median Blur', command=lambda: self.show_parameters_panel( self.__median_blur_menu)) blurs_menu.add_command(label="Gaussian Blur", command=lambda: self.show_parameters_panel( self.__gaussian_blur_menu)) blurs_menu.add_command(label='Averaging', command=lambda: self.show_parameters_panel( self.__averaging_blur_menu)) blurs_menu.add_command(label='Bilateral Filter', command=lambda: self.show_parameters_panel( self.__bilateral_filter_menu)) menu_bar.add_cascade(menu=blurs_menu, label='Blurs') threshold_menu = Menu(menu_bar) threshold_menu.add_command(label='Global Threshold', command=lambda: self.show_parameters_panel( self.__global_threshold_menu)) threshold_menu.add_command(label='Adaptive Mean Threshold', command=lambda: self.show_parameters_panel( self.__adaptive_mean_threshold_menu)) threshold_menu.add_command(label='Adaptive Gaussian Threshold', command=lambda: self.show_parameters_panel( self.__adaptive_gauss_threshold_menu)) menu_bar.add_cascade(menu=threshold_menu, label='Threshold') gradient_menu = Menu(menu_bar) gradient_menu.add_command( label='Sobel X', command=lambda: self.show_parameters_panel(self.__sobel_x_menu)) gradient_menu.add_command( label='Sobel Y', command=lambda: self.show_parameters_panel(self.__sobel_y_menu)) gradient_menu.add_command( label='Laplacian', command=lambda: self.show_parameters_panel(self.__laplacian_menu)) menu_bar.add_cascade(menu=gradient_menu, label='Gradient') advanced_menu = Menu(menu_bar) advanced_menu.add_command( label='Canny', command=lambda: self.show_parameters_panel(self.__canny_menu)) advanced_menu.add_command(label='Histogram', command=self.show_histogram) face_detection_menu = Menu(advanced_menu) face_detection_menu.add_command( label='Haar Cascade Face Detection', command=lambda: self.show_parameters_panel(self.__haar_menu)) face_detection_menu.add_command( label='Facial Landmarks Detection', command=lambda: self.show_parameters_panel(self. __shape_predictor_menu)) advanced_menu.add_cascade(menu=face_detection_menu, label='Face Detection') menu_bar.add_cascade(menu=advanced_menu, label='Advanced') root['menu'] = menu_bar # Create status bar with scale self.__scale_var = StringVar() self.__scale_val = 100 self.__scale_var.set("100%") bottom_panel = ttk.Frame(main_window) bottom_panel.columnconfigure(0, weight=1) bottom_panel.grid(row=1, column=0, sticky=(W, E), columnspan=3) self.__status_bar = ttk.Label( bottom_panel, text="Tip: you can select parameters menu using Ctrl-q and previous" " commands queue using Ctrl-p", anchor="w") self.__status_bar.grid(row=0, column=0, sticky=(E, W)) scale_label = ttk.Label(bottom_panel, textvariable=self.__scale_var) scale_label.grid(row=0, column=1) scale = ttk.Scale(bottom_panel, from_=1, to=200, orient=HORIZONTAL, command=self.scale_image) scale.set(100) scale.grid(row=0, column=2) # Create right panel (notebook) main_window.columnconfigure(2, minsize=180) self.__right_panel = ttk.Notebook(main_window) self.__right_panel.grid(row=0, column=2, sticky=(N, S, W, E)) self.__right_panel.columnconfigure(0, weight=1) self.__right_panel.rowconfigure(0, weight=1) # Create parameters menu (notebook) self.__active_menu = None self.__parameters_menu = ttk.Frame(self.__right_panel) self.__right_panel.add(self.__parameters_menu, text='Parameters') parameters_separator = ttk.Separator(self.__parameters_menu, orient='horizontal') parameters_separator.grid(row=0, column=0, sticky=(W, E)) self.__parameters_menu.columnconfigure(0, weight=1) self.__canny_menu = CannyMenu(self.__parameters_menu) self.__canny_menu.callback = self.gui_update_wrapper( self.__image_manager.canny) self.__median_blur_menu = MedianBlur(self.__parameters_menu) self.__median_blur_menu.callback = self.gui_update_wrapper( self.__image_manager.median_blur) self.__gaussian_blur_menu = GeneralBlurMenu(self.__parameters_menu, 'Gaussian blur') self.__gaussian_blur_menu.callback = self.gui_update_wrapper( self.__image_manager.gaussian_blur) self.__averaging_blur_menu = GeneralBlurMenu(self.__parameters_menu, 'Averaging') self.__averaging_blur_menu.callback = self.gui_update_wrapper( self.__image_manager.averaging_blur) self.__bilateral_filter_menu = BilateralFilterMenu( self.__parameters_menu) self.__bilateral_filter_menu.callback = self.gui_update_wrapper( self.__image_manager.bilateral_filter) self.__global_threshold_menu = GlobalThresholdMenu( self.__parameters_menu) self.__global_threshold_menu.callback = self.gui_update_wrapper( self.__image_manager.global_threshold) self.__adaptive_mean_threshold_menu = AdaptiveThresholdMenu( self.__parameters_menu, 'Adaptive Mean Threshold') self.__adaptive_mean_threshold_menu.callback = self.gui_update_wrapper( self.__image_manager.mean_threshold) self.__adaptive_gauss_threshold_menu = AdaptiveThresholdMenu( self.__parameters_menu, 'Adaptive Gauss Threshold') self.__adaptive_gauss_threshold_menu.callback = self.gui_update_wrapper( self.__image_manager.gaussian_threshold) self.__sobel_x_menu = GradientMenu(self.__parameters_menu, 'Sobel X') self.__sobel_x_menu.callback = self.gui_update_wrapper( self.__image_manager.sobel_x) self.__sobel_y_menu = GradientMenu(self.__parameters_menu, 'Sobel Y') self.__sobel_y_menu.callback = self.gui_update_wrapper( self.__image_manager.sobel_y) self.__laplacian_menu = GradientMenu(self.__parameters_menu, 'Laplacian') self.__laplacian_menu.callback = self.gui_update_wrapper( self.__image_manager.laplacian) self.__haar_menu = HaarCascadeMenu(self.__parameters_menu) self.__haar_menu.callback = self.gui_detect_wrapper( self.__image_manager.haar_face_detection) self.__shape_predictor_menu = ShapePredictorMenu( self.__parameters_menu) self.__shape_predictor_menu.callback = self.gui_detect_wrapper( self.__image_manager.dlib_face_shape_prediction) # Create queue menu (notebook) queue_panel = ttk.Frame(self.__right_panel) self.__right_panel.add(queue_panel, text='Commands') queue_label = ttk.Label(queue_panel, text='Previous Commands', anchor='center') queue_label.grid(row=0, column=0, sticky=(W, E)) queue_separator = ttk.Separator(queue_panel, orient='horizontal') queue_separator.grid(row=1, column=0, sticky=(W, E)) queue_panel.columnconfigure(0, weight=1) queue_panel.rowconfigure(2, weight=1) self.__queue = ScrollableList(queue_panel) self.__queue.callback_function = self.show_prev_image self.__queue.list = self.__image_manager.prev_commands self.__queue.grid(row=2, column=0, sticky=(N, S, W, E)) # binds root.bind('<Control-z>', self.undo) root.bind('<Control-p>', self.show_parameters_menu) root.bind('<Control-q>', lambda event: self.show_parameters_menu(event, 1)) root.bind( '<Control-g>', self.event_wrapper( self.gui_update_wrapper(self.__image_manager.to_grayscale, True))) root.bind('<Control-s>', self.event_wrapper(self.save_image_as))
def __init__(self, screen, maze, target, spawn_info, sound_manager, ghost_file='ghost-red.png'): super().__init__() self.screen = screen self.maze = maze self.internal_map = maze.map_lines self.target = target self.sound_manager = sound_manager self.norm_images = ImageManager(ghost_file, sheet=True, pos_offsets=[(0, 0, 32, 32), (0, 32, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=250) self.blue_images = ImageManager('ghost-ppellet.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (0, 32, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=150) self.blue_warnings = ImageManager('ghost-ppellet-warn.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (0, 32, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), animation_delay=150) self.eyes = ImageManager('ghost-eyes.png', sheet=True, pos_offsets=[(0, 0, 32, 32), (32, 0, 32, 32), (0, 32, 32, 32), (32, 32, 32, 32)], resize=(self.maze.block_size, self.maze.block_size), keys=['r', 'u', 'd', 'l']) self.score_font = sysfont.SysFont(None, 22) self.score_image = None self.image, self.rect = self.norm_images.get_image() self.curr_eye, _ = self.eyes.get_image( key='r') # default eye to looking right self.image.blit(self.curr_eye, (0, 0)) # combine eyes and body self.return_tile = spawn_info[0] # spawn tile self.return_path = None # path back to spawn tile self.return_delay = 1000 # 1 second delay from being eaten to returning self.eaten_time = None # timestamp for being eaten self.start_pos = spawn_info[1] self.reset_position() self.tile = spawn_info[0] self.direction = None self.last_position = None self.speed = maze.block_size / 10 self.state = { 'enabled': False, 'blue': False, 'return': False, 'speed_boost': False } self.blue_interval = 5000 # 5 second time limit for blue status self.blue_start = None # timestamp for blue status start self.blink = False self.last_blink = time.get_ticks() self.blink_interval = 250
image_manager.get_image_info(image_list, 'Data/training_info.csv', index=True) def is_valid(image): read_test = cv2.imread(image) if read_test is None: return False return True if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--directory', type=str, default='Images', help=""" Path to the images folder. """) parser.add_argument('--path', type=str, default='Data/label_map.txt', help=""" Path to the label_map file. """) FLAGS = parser.parse_args() image_manager = ImageManager() main(image_manager)