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)