def __init__(self, big, location, constraint, flyers, bombs, boomboxes, turkeyshakes, *groups):
     if big == True:
         effects.SpriteSheet.__init__(self, util.load_image( "playerBigMove_sheet.png" ), (60,90) )
         self.max_speed = 5
     else:
         effects.SpriteSheet.__init__(self, util.load_image( "playerMove_sheet.png" ), (30,45) )
         self.max_speed = 4
     self.constraint = constraint
     self.movement = { 'up':0, 'down':0, 'left':0, 'right':0 }
     self.facing = 'right'
     self.flyers = flyers
     self.bombs = bombs
     self.boomboxes = boomboxes
     self.turkeyshakes = turkeyshakes
     self.contacting = ''
     self.time = 0
     self.anim_frame = 0
     self.state = 0
     self.flipped = False
     self.booltop = True
     self.wait = 0
     self.bomb_place = False
     self.placing = 0
     self.end = False
     
     self.rect.center = location
     if big:
         self.rect.height -= 45
     else:
         self.rect.height -= 22.5

 def refresh_image(self):     
     super(WaterTank, self).refresh_image()
     if self.sprite is None: return
     if 'Gray Water' in self.filter.target:
         self.sprite.add_layer('GrayDrop',util.load_image("images/graywdrop_40x40.png"))  
     else:
         self.sprite.add_layer('WaterDrop',util.load_image("images/waterdrop_40x40.png"))        

 def __init__(self, big, location, direction, *groups):
     self.type = 'turkeyshake'
     pygame.sprite.Sprite.__init__( self, *groups )
     self.movement = { 'up':0, 'down':0, 'left':0, 'right':0 }
     if big == True:
         self.image = util.load_image( "smoothie_TurkeyBig.png" )
     else:
         self.image = util.load_image( "smoothie_Turkey.png" )
     self.rect = self.image.get_rect()
     self.time = 30
     self.exploded = False
     self.big = big
     if pygame.mixer.get_init():
         self.sound = pygame.mixer.Sound(pkg_resources.resource_stream("applesauce", "sounds/Slurping Smoothie.ogg"))
         self.sound.set_volume(0.8)
         self.sound.play()
     else:
         self.sound = None
     
     if direction.endswith( 'up' ):
         self.movement['up'] = 1
     elif direction.endswith( 'down' ):
         self.movement['down'] = 1
     if direction.startswith( 'left' ):
         self.movement['left'] = 1
     elif direction.startswith( 'right' ):
         self.movement['right'] = 1
         
     if self.movement['up'] ^ self.movement['down'] == 1 and self.movement['left'] ^ self.movement['right'] == 1:
         self.speed = math.sqrt( 50 )
     else:
         self.speed = 10
     self.rect.center = location

 def refresh_image(self):     
     super(DockingRing, self).refresh_image()
     if self.open:
         self.sprite.add_layer('DockingRing',util.load_image("images/open_hatch.png"))
     else:
         self.sprite.add_layer('DockingRing',util.load_image("images/closed_hatch.png"))
     self.sprite.layer['Equipment'].visible=False    

def init():
    Health.heart = util.load_image("sydan")
    Health.heart_empty = util.load_image("sydan-tyhja")
    Health.heart_broken = util.load_image("sydan-rikki")
    heart_broken = pygame.Surface((Health.heart_broken.get_rect().width, Health.heart_broken.get_rect().height))
    heart_broken.fill((255,0,255))
    heart_broken.set_colorkey((255,0,255))
    heart_broken.blit(Health.heart_broken, heart_broken.get_rect())
    Health.heart_broken = heart_broken

 def get_tile(self, name, colorkey=None, tile_pos=None):
     key = (name, tile_pos)
     if not self.tiles.has_key( key ):
         image = util.load_image(TILES_DIR, name)
         image = util.load_image(TILES_DIR, name).convert()
         if tile_pos is not None:
             tmp = Surface( (TILE_SIZE, TILE_SIZE) )
             rect = Rect(tile_pos[0]*TILE_SIZE, tile_pos[1]*TILE_SIZE,TILE_SIZE,TILE_SIZE)
             tmp.blit(image, (0,0), rect)
             image = tmp.convert()
         self.tiles[key] = image
     return self.tiles[key]

 def explode(self):
     if self.exploded == False:
         self.time = 200
         self.exploded = True
         if self.big == True:
             self.image = util.load_image( "hit_smoothie_TurkeyBig.png" )
         else:
             self.image = util.load_image( "hit_smoothie_Turkey.png" )
         tmp = self.image.get_rect()
         tmp.center = self.rect.center
         self.rect = tmp
         for value in self.movement.keys():
             self.movement[value] = 0

    def __init__(self,pos,offset = 16):
        #load imgs
        self._default = util.load_image("data/bw_key0.png")
        self._red = util.load_image("data/red_key0.png")
        self._green = util.load_image("data/green_key0.png")
        self._blue = util.load_image("data/blue_key0.png")

        self.red = self._default
        self.green = self._default
        self.blue = self._default

        self.offset = offset
        self.draw_pos = pos

 def __init__(self, name, group=None):
     self.name = name
     info_path = util.respath('environments', name, 'info.json')
     with pyglet.resource.file(info_path, 'r') as info_file:
         info = json.load(info_file)
         self.background_tile_rows = info['tile_rows']
         self.background_tile_cols = info['tile_columns']
     self.background_batch = pyglet.graphics.Batch()
     self.background_sprites = []
     self.overlay_batch = pyglet.graphics.Batch()
     self.overlay_sprites = []
     
     self.width = 0
     self.height = 0
     background_sprites_dict = {}
     tile_w = 0
     tile_h = 0
     for x in range(self.background_tile_cols):
         this_y = 0
         for y in range(self.background_tile_rows):
             img = util.load_image(util.respath('environments', 
                                                      name, 
                                                      '%d_%d.png' % (x, y)))
             tile_w, tile_h = img.width, img.height
             new_sprite = pyglet.sprite.Sprite(img, x=x*tile_w, y=y*tile_h,
                                               batch=self.background_batch,
                                               group=group)
             self.background_sprites.append(new_sprite)
             background_sprites_dict[(x, y)] = new_sprite
     for x in range(self.background_tile_cols):
         self.width += background_sprites_dict[(x, 0)].width
     for y in range(self.background_tile_rows):
         self.height += background_sprites_dict[(0, y)].height
     gamestate.camera_max = (self.width-gamestate.norm_w//2, self.height-gamestate.norm_h//2)
     
     for x in range(self.background_tile_cols):
         for y in range(self.background_tile_rows):
             overlay_tile_path = util.respath('environments', name, 'overlay_%d_%d.png' % (x, y))
             try:
                 img = util.load_image(overlay_tile_path)
                 new_sprite = pyglet.sprite.Sprite(img, x=x*tile_w, y=y*tile_h,
                                                   batch=self.overlay_batch)
                 self.overlay_sprites.append(new_sprite)
             except pyglet.resource.ResourceNotFoundException:
                 pass    # Ignore if no overlay
     
     self.draw = self.background_batch.draw
     self.draw_overlay = self.overlay_batch.draw
     self.behind = util.load_image('environments/spacebackground.png')

    def __init__(self, pos, image, space, anim_name="", num_frames=1, sequence=[0, 1], frequency=8):
        self.is_movable = True
        GameObject.__init__(
            self, pos, util.to_sprite(util.load_image("data/info_sign0.png")), space, OBJECT_TYPE_INFO, pm.inf
        )
        self.body, self.shape = create_box(space, (pos.x, pos.y), frequency, 12.0)
        self.shape.collision_type = OBJECT_TYPE_INFO
        self.info_bubble = util.load_image(image)
        space.add_static(self.shape)
        self._show_info = False
        self.cool_down = 0.0

        if not anim_name == "":
            self.animation = animation.new_animation(anim_name, "png", num_frames, frequency, sequence)
        self.animation.play()

    def __init__(self, *args, **kwargs):
        ''' Not perfect but the bike uses hardcoded constants
            Warning! Lots of opaque physics and math
        '''
        super(Bike, self).__init__(*args, **kwargs)

        # Not ideal to use white as the color key
        # Not ideal to hardcode the bike image asset
        self.original, self.rect = util.load_image('bike.png', (255,255,255))
        self.image = self.original

        self.speed = 0
        self.max_speed = 5

        # Is this bike moving?
        self.driving = 0

        # Each bike has its own target
        self.target = Target()

        # start at the origin
        self.x, self.y = self.rect.centerx, self.rect.centery
        self.angle = 0.0

        self.dt = 0.0

        # Some physics constants. These and the image ought to be parameters
        # F_c = mv*v/r --> v_max = sqrt(F_traction/m) * sqrt(r)
        self.ft = 5.0
        self.mass = 200.0
        self.brake = 0.1
        self.accel = 0.05
        self.draw_cb = []

    def __init__(self, ship_rect, ship_angle, left = False):
        pygame.sprite.Sprite.__init__(self)

        if not Cannonball.image:
            Cannonball.image = util.load_image("kuti")
        if not Cannonball.sound:
            Cannonball.sound = util.load_sound("pam")
        screen = pygame.display.get_surface()
        self.area = screen.get_rect()

        self.image = Cannonball.image


        self.hitmask = pygame.surfarray.array_alpha(self.image)

        Cannonball.sound.play()

        #self.dy = -5
        #self.dx = 10
        # Shoot at an angle of 25 relative to the ship
        if not left:
            self.rect = pygame.Rect(ship_rect.right, ship_rect.centery, self.image.get_width(), self.image.get_height())
            self.vect = [math.cos((-ship_angle - 25.0) / 180.0 * math.pi) * 11.0,
                         math.sin((-ship_angle - 25.0) / 180.0 * math.pi) * 11.0]
        else:
            self.rect = pygame.Rect(ship_rect.left, ship_rect.centery, self.image.get_width(), self.image.get_height())
            self.vect = [math.cos((-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0,
                         math.sin((-ship_angle + 180.0 + 25.0) / 180.0 * math.pi) * 11.0]

    def init(self,image_map,tile_x=0,tile_y=0,color_key=None):
        """MapEntity(Surface, tile_x, tile_y, direction)
       
           Surface should be obtained from util.load_image

           tile_x & tile_y specify what image map to use if you join
           multiple images into one map (Characters, Entities, etc)
           legal values are positive integers representing zero based index

           direction is what direction the entity should face,
           can also be set later with MapEntity.face(direction)
           legal values are map.NORTH, map.EAST, map.SOUTH, & map.WEST"""

        image = util.load_image(CHARACTERS_DIR, image_map, True, color_key)
        Sprite.__init__(self)
        self.image_args = (image_map, True, color_key)
        self.pos = (0,0)
        self.map = None
        self.image = image
        self.image_base_x = tile_x * 3 * TILE_SIZE
        self.image_base_y = tile_y * 4 * TILE_SIZE
        self.frame = 0
        self.image_tile = Rect( self.image_base_x, self.image_base_y,
                                TILE_SIZE, TILE_SIZE )
        self.rect = Rect(0,0,TILE_SIZE,TILE_SIZE)
        self.face(NORTH)
        self.next_frame()
        self.velocity = (0,0)
        self.speed = 4
        self.moving = False # For tile based motion
        self.always_animate = False
        self.animation_count = 1
        self.animation_speed = 6
        self.entered_tile = False
        self.can_trigger_actions = 0

def get_HOG_features(data_path, pickle_name):
    size = len(data_path)
    rowPatchCnt = 4
    colPatchCnt = 4
    var_features = np.zeros((size, colPatchCnt*rowPatchCnt*3))
    print var_features.shape

    image = color.rgb2gray(data.astronaut())
    #print image

    fd, hog_image = hog(image, orientation = 8, pixels_per_cell=(16, 16), cells_per_block = (1,1), visualise=True)

    print fd

    im = util.load_image(data_path[0])
    #print im
    #for i in range(size):
        #if i % 500 == 0: print "{}/{}".format(i, size)
        #im = util.load_image(data_path[i])
        #patchH = im.shape[0] / rowPatchCnt
        #patchW = im.shape[1] / colPatchCnt
        #pass
        #im = np.array(im)

    pass

    def __init__(self, usealpha):
        pygame.sprite.Sprite.__init__(self)

        self.image = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
        self.rect = self.image.get_rect()

        if not Water.raster_image:
            Water.raster_image = pygame.transform.scale(util.load_image("rasteri"), (SCREEN_WIDTH, SCREEN_HEIGHT))

        self.water_levels = []
        for i in xrange(self.rect.width):
            self.water_levels.append(0.0)
        self.t = 0

        self.usealpha = usealpha

        self.target_amplitude = self.amplitude = SCREEN_HEIGHT / 8.0
        self.target_wavelength = self.wavelength = 0.02 * SCREEN_WIDTH / 2.0 / math.pi
        self.target_speed = self.speed = 0.06 / math.pi / 2.0 * FPS
        self.target_baseheight = self.baseheight = SCREEN_HEIGHT / 24.0 * 8.0

        if self.usealpha:
            self.image.set_alpha(110)

        self.update()

    def __init__(self, screen, menu, selection = 0):
        self.screen = screen

        if not Menu.sky:
            Menu.sky = util.load_image("taivas")

        self.water = Water.global_water
        self.water_sprite = pygame.sprite.Group()
        self.water_sprite.add(self.water)

        if not Menu.logo:
            Menu.logo = util.load_image("logo")

        self.menu = menu
        self.selection = selection
        self.t = 0

    def __init__(self, image_filename, levelmap):
        self.levelmap = levelmap

        self.__img = util.load_image(image_filename, False, None)
        order = range(8)
        delay = 4  # each phase of the animation lasts 6 frames
        offset = Vector(0,16)  # the "position-point" of the hero is on
                # his left elbow...
        self.size = 16

        self.__walk_down = Animation(order)
        for down_rect in [ (4+i*24, 0, 16, 31) for i in range(8) ]:
            self.__walk_down.add_frame(self.__img, down_rect, delay, offset)

        self.__walk_up = Animation(order)
        for up_rect in [ (4+i*24, 32, 16, 31) for i in range(8) ]:
            self.__walk_up.add_frame(self.__img, up_rect, delay, offset)

        self.__walk_left = Animation(order)
        for left_rect in [ (4+i*24, 64, 16, 31) for i in range(8) ]:
            self.__walk_left.add_frame(self.__img, left_rect, delay, offset)

        self.__walk_right = Animation(order)
        for right_rect in [ (4+i*24, 96, 16, 31) for i in range(8) ]:
            self.__walk_right.add_frame(self.__img, right_rect, delay, offset)

        # initial values
        self.state = self.DOWN_WALK
        # Coordinates are relative to the map - not to the screen!
        self.pos = Vector(0,0)
        self.speed = 2

 def __create__(self, file, name, size):
     # Open the generation Image:
     temp_file = util.load_image(file, util.config.settings['Screen_Size'])
     # Create new Folder
     self.name = name
     this_path = util.local_path('source/Maps', self.name)
     if os.path.exists( this_path ): return -1
     os.makedirs( this_path )
     os.makedirs( this_path + '/items')
     # Save Background
     temp_file.save( this_path + '/background.gif' )
     temp_file.close()
     # Write Config
     temp_file = open( this_path + '/config', 'w')
     ## Write Dimensions
     temp_file.write("%d, %d\n\n" % (size[0], size[1]))
     ## Write wall positions
     for i in range(size[1]):
         temp_file.write((' 0,' * size[0])[1:-1] + '\n')
     temp_file.write('\n')
     ## Write Object Start positions
     for i in range(size[1]):
         temp_file.write((' 0,' * size[0])[1:-1] + '\n')
     temp_file.write('\n')
     ## Write Object Defenitions: None
     ## Close config file and load from created files. 
     temp_file.close()
     self.__load__()

 def refresh_image(self, imgfile, x_off = 0):     
     if self.sprite: self.sprite.delete()
     import graphics_pyglet
     self.sprite = graphics_pyglet.LayeredSprite(name=self.name,start_order = -30)
     img = util.load_image(imgfile )
     self.sprite.add_layer(self.name,img)    
     self.sprite._offset = [gv.config['ZOOM'] * 2 * x_off, 0]

def main():
    # TODO: Erase dummy net
    net = None
    """
    TODO: Comment in
    deploy_fpath = 'deploy.prototxt'
    model_fpath = 'model.protobinary'

    caffe.set_mode_gpu()
    net = caffe.Net(deploy_fpath, model_fpath, caffe.TEST)
    """

    bpath = '../yandere-crawler/illust/'

    code_db = []

    # TODO: For train.txt
    with open('./test.txt') as f:
        for line in f:
            preview_fpath, _ = line.rstrip().split(' ')
            preview_fpath = bpath + preview_fpath

            print preview_fpath

            # Make BGR 227x227 image
            data = util.load_image(preview_fpath)

            # Make code
            code = util.make_code(net, data)

            code_db.append((code, preview_fpath))

    with open('./code_db.pickle', 'wb') as f:
        pickle.dump(code_db, f)