def __init__(self, x, y, image, enemygroup, mapsprite, tileImage): pygame.sprite.Sprite.__init__(self) self.foward = Animation(image,0,4, -2) self.right = Animation(image,8,12, -2) self.up = Animation(image, 16, 20, -2) self.left = Animation(image, 24, 28, -2) self.downright = Animation(image, 28, 32, -2) self.downleft = Animation(image, 40, 44, -2) self.upright = Animation(image, 48, 52, -2) self.upleft = Animation(image, 56, 60, -2) self.grabImage = Animation(image, 60, 64, 1) self.heldPunchImage = Animation(image, 44, 48, 1) # self.selectImage = Animation(image, 37, 41, -2, 1) self.tileImage = tileImage self.x = x self.y = y self.list = image self.image = self.foward.image() # default direction facing (right) self.rect = self.image.get_rect() self.rect.topleft = (self.x,self.y) # update tile rect location self.modeStack = [] self.modeStack.append('0') self.enemysprite = enemygroup self.z = 0 self.mapsprite = mapsprite self.selectedTile = Tile(0,0, image,0, mode=1) self.tilesprite = pygame.sprite.Group() self.tilesprite.add(self.selectedTile) self.dirdisX = 0 self.dirdisY = 0
def start(self): (startX, startY) = self.getPosition() (nextX, nextY) = self.getNextPosition() anim = Animation(self.speed, [("x", startX, nextX), ("y", startY, nextY)], IN_OUT_QUAD) self.addAnimation(anim) anim.onCompletion(self.nextSquare) anim.start()
def __init__(self, x, y, angle, velocity, damage): super(RedL1BulletActor, self).__init__(x, y, 5, 5) self.damage = damage nextX = x + cos(radians(angle)) * 800 # TODO: HACKY nextY = y + sin(radians(angle)) * 800 anim = Animation(velocity, [("x", x, nextX), ("y", y, nextY)], LINEAR) anim.onFrame(self.collisionCheck) self.addAnimation(anim) anim.start()
class Pooter(Enemy): """Simple enemy fly class""" hurtDistance = 0.6 health = 12 def __init__(self, xy, sounds, textures): self.x, self.y = xy self.sounds = sounds self.frames = [textures.subsurface(i*64, 0, 64, 64) for i in range(2)] # self.deathFrames = [textures.subsurface(i*128 - ((i//4)*128*4), 128 * (i//4 + 1), 128, 128) for i in range(12)] self.anim = Animation(self.frames, 0.04) self.health = 2 def die(self): if not self.dead: # self.anim = Animation(self.deathFrames, 0.24) self.dead = True self.sounds[-1].play() # Play death sound def render(self, surface, time, character, nodes, paths, bounds, obsticals): speed = 1.5/GRATIO ix, iy = (character.x-GRIDX)/GRATIO, (character.y-GRIDY)/GRATIO dx, dy = (ix-self.x), (iy-self.y) # X and Y ratios dist = sqrt(dx**2+dy**2) rx = dx/dist ry = dy/dist hurtDistance = 0.8 if not self.dead: # Add to x and y self.x += speed*rx self.y += speed*ry self.checkHurt(character, time) frame = self.anim.render(time) else: frame = self.anim.render(time) if self.anim.looped: return False surface.blit(frame, (GRIDX+GRATIO*self.x-self.anim.width//2, GRIDY+GRATIO*self.y-self.anim.height//2)) return True # Should remain in enemies list
def loadAnimations(self): """Loads all animations for game given the images are already loaded""" flash=Animation() flash.addFrame(self.getImage("crono"),500) flash.addFrame(self.getImage("cronoflip"),500) self.animations["ahhh"]=flash leftRun = Animation() leftRun.addFrame(self.getImage("left1"), 200) leftRun.addFrame(self.getImage("left2"), 200) leftRun.addFrame(self.getImage("left3"), 200) self.animations["left"] = leftRun
class Fly(Enemy): """Simple enemy fly class""" isFlying = True pathed = False health = 4 weight = 1 hurtDistance = 0.8 def __init__(self, xy, sounds, textures): self.x, self.y = xy self.sounds = sounds # Frames and death frames self.frames = [textures.subsurface(i*64, 0, 64, 64) for i in range(2)] self.deathFrames = [textures.subsurface(i*128 - ((i//4)*128*4), 128 * (i//4 + 1), 128, 128) for i in range(12)] self.anim = Animation(self.frames, 0.04) # Speed ratio self.speed = 1.5/GRATIO def die(self): if not self.dead: self.anim = Animation(self.deathFrames, 0.24) self.dead = True self.sounds[-1].play() # Play death sound def render(self, surface, time, character, nodes, paths, bounds, obsticals): self.cx, self.cy = ix, iy = (character.x-GRIDX)/GRATIO, (character.y-GRIDY)/GRATIO dx, dy = (self.cx-self.x), (self.cy-self.y) if not self.dead: if not self.pathed: self.pathFind((ix, iy), nodes, paths) self.pathed = True self.move() # Check for damage self.checkHurt(character, time) frame = self.anim.render(time) else: frame = self.anim.render(time) if self.anim.looped: return False surface.blit(frame, (GRIDX+GRATIO*self.x-self.anim.width//2, GRIDY+GRATIO*self.y-self.anim.height//2)) return True
class BaseTile(GameActor): """ Basically just a surface and the property material_group, which defines the behaviour of the Tile. There are following types: -solid: Just a normal, solid, unbreakable block. -deco: No physics, only decoration (background mostly) -soft_break Breakable with the soft punch, jump and fall-attack -hard_break: Breakable with the hard punch, jump and fall-attack -shot_break: Breakable throwing an enemy (after charging up) -fire_break: Breakable when Wario is on fire (literally) -ladder: A material on which Wario can climb in all directions -water_still: Still water -water_left: Water that flows to the left -water_right: Water that flows to the right -water_up: Water that flows up -water_down: Water that flows down -water_impervious: Water that is impervious (Wario can't dive in it, only swim on top of it) -platform_fallthrough: A platform through which can be jumped if coming from the bottom up Is also pervious in certain states of Wario, like the zombie-wario. Note: The transparency color is always (225, 0, 255), also called "magic-pink" """ def __init__(self, position, engine, material_group, tiles_list): super(BaseTile, self).__init__(position, engine) # Set material_group (only for physics, see class description) self.material_group = material_group # Create the animation-instance containing all surfaces self.animation = Animation(tiles_list, 10) self.animation.update() # Create owm rect self.rect = pygame.Rect((0, 0), tiles_list[0].get_size()) def set_property(self, property_name, property_value): if property_name == "material_group": self.material_group = property_value elif property_name == "alpha": for sprite in self.animation.sprites: sprite.set_alpha(0) def get_material_group(self): return self.material_group def _update(self): self.engine.graphics.blit(self.animation.get_surface(), self.rect)
def __init__(self, x, y, color = (255, 255, 255), objectList = [], spriteList = []): self.objectList = objectList self.spriteList = spriteList self.rect = pygame.Rect(x, y, 15, 15) self.screen = pygame.display.get_surface() self.butterflyAnim = Animation("butterfly", 8) self.butterflyAnim.updateColor(color) self.butterflyAnim.setFrameRange(1, 8); self.butterflyAnim.setCurrentFrame(randint(1, 8)) self.sprite = pygame.sprite.RenderPlain(self.butterflyAnim) self.butterflyAnim.playAnim() self.area = self.screen.get_rect() self.color = color self.floorLevel = self.screen.get_height() - self.rect.h self.movingLeft = False self.movingRight = False self.movingUp = False self.movingDown = False self.degree = randint(0, 360) self.speed = 4 self.detlaUpdate = 0 self.collide = False self.movePos = [0,0.01]
def getAnimation(self, action): global animations try: return animations[action] except: animations = Animation.loadAnimations("human") return animations[action]
class Coin(Item): """Pickup coin class""" def __init__(self, variant, xy, sounds, textures): self.variant = variant self.x = xy[0] self.y = xy[1] self.sounds = sounds self.textures = textures[variant] self.worth = [1, 5, 10][variant] self.bounds = Rect(GRIDX+GRATIO*self.x,GRIDY+GRATIO*self.y, 52, 52) self.collideable = False self.pickedUp = False # Split up textures self.frames = [self.textures.subsurface(i*128, 0, 128, 128) for i in range(6)] self.frames = [self.frames[0].copy() for i in range(16)] + self.frames self.anim = Animation(self.frames, 1) def pickup(self): self.pickedUp = True self.sounds[1].play() def render(self, surface, time, objects, ox=0, oy=0): if not self.pickedUp: surface.blit(self.anim.render(time), (GRIDX+GRATIO*self.x+GRATIO//2-self.anim.width//2+ox,GRIDY+GRATIO*self.y+GRATIO//2-self.anim.height//2+oy)) return not self.pickedUp
def __init__(self, xy, sounds, textures): self.x, self.y = xy self.sounds = sounds # Split textures self.frames = [textures["enemies"]["boil"].subsurface(i*64-(i//4)*(64*4), (i//4)*64, 64, 64) for i in range(10)][::-1] # Record sound and textures for tears self.tearTextures = textures["tears"] self.tearSounds = sounds["tear"] # How long it takes to grow + current size self.size = 0 self.advanceTime = 0.5 # When the animation was started self.start = cTime() # Animation for grow self.animation = Animation(self.frames, 10, shouldLoop=False) # How long the boil has been full self.sinceFull = -1 # How many tears the boil has active self.tears = []
def __init__(self, direction, posX, posY, objectList = [], rabbitList = []): self.objectList = objectList self.rabbitList = rabbitList self.carrotAnim = Animation("carrot", 24) self.carrotAnim.setFrameRange(1, 12); self.rect = pygame.Rect(posX, posY, 25, 25) self.carrotAnim.setRect(self.rect) self.carrotAnim.playAnim() self.sprite = pygame.sprite.RenderPlain(self.carrotAnim) self.screen = pygame.display.get_surface() self.area = self.screen.get_rect() self.area.h += 500 self.area.y -= 550 self.area.w -= 200 self.smoked = False self.countDown = 60 self.moveX = posX self.direction = direction if self.direction == "left": self.carrotAnim.flipAnim()
def __init__(self, position, engine, material_group, tiles_list): super(BaseTile, self).__init__(position, engine) # Set material_group (only for physics, see class description) self.material_group = material_group # Create the animation-instance containing all surfaces self.animation = Animation(tiles_list, 10) self.animation.update() # Create owm rect self.rect = pygame.Rect((0, 0), tiles_list[0].get_size())
def __init__(self, hp): super(RedEasyEnemyActor, self).__init__(hp) self.baseColor = [1.0, 0.0, 0.0] anim = Animation(5000, [("rotation", 0, 360)], LINEAR) anim.loop = True self.addAnimation(anim) anim.start() anim = Animation(250, [("scale", .8, 1.2)], IN_OUT_QUAD) anim.loop = True anim.pingPong = True self.addAnimation(anim) anim.start()
def __init__(self, x, y, player, image): self.x = x self.y = y pygame.sprite.Sprite.__init__(self) # self.imglist = Animation(image,0,5) # self.heldImage = Animation(image,35, 39, -2) self.imagelist = image self.image = image[3] self.dx, self.dy = 0, 0 self.movex, self.movey = 0, 0 self.rect = self.image.get_rect() self.rect.topleft = (self.x, self.y) self.player = player self.modeStack = [] self.modeStack.append("0") self.heldImage = Animation(image, 48, 52, -1) self.punchedImage = Animation(image, 40, 44, 1)
def __init__(self, xy, sounds, textures): self.x, self.y = xy self.sounds = sounds self.frames = [textures.subsurface(i*64, 0, 64, 64) for i in range(2)] # self.deathFrames = [textures.subsurface(i*128 - ((i//4)*128*4), 128 * (i//4 + 1), 128, 128) for i in range(12)] self.anim = Animation(self.frames, 0.04) self.health = 2
def __init__(self, variant, xy, sound, textures): self.variant = variant self.x = xy[0] self.y = xy[1] self.sound = sound self.textures = textures[variant] self.frames = [self.textures.subsurface(192*i - (i//4)*768,192*(i//4), 192, 192) for i in range(12)] self.anim = Animation(self.frames, .45) sound.play() # Play explosion sound
def smoke(self): self.smoked = True self.rect.x -= 25 self.rect.y -= 25 self.rect.w = 75 self.rect.h = 75 self.carrotAnim = Animation("carrot_smoke", 25) self.carrotAnim.setFrameRange(1, 25); self.carrotAnim.setRect(self.rect) self.sprite = pygame.sprite.RenderPlain(self.carrotAnim) self.carrotAnim.playAnim(False)
def __init__(self, xy, sounds, textures): self.x, self.y = xy self.sounds = sounds # Frames and death frames self.frames = [textures.subsurface(i*64, 0, 64, 64) for i in range(2)] self.deathFrames = [textures.subsurface(i*128 - ((i//4)*128*4), 128 * (i//4 + 1), 128, 128) for i in range(12)] self.anim = Animation(self.frames, 0.04) # Speed ratio self.speed = 1.5/GRATIO
def __init__(self, variant, xy, sounds, textures): self.variant = variant self.x = xy[0] self.y = xy[1] self.sounds = sounds self.textures = textures # Random base self.randVar = randint(0,2) self.collideable = False self.destroyed = False self.bounds = Rect(GRIDX+GRATIO*self.x-16-4, GRIDY+GRATIO*self.y-16-5, 64+4, 64) self.health = 4 # Get frames for flame self.fireFrames = [self.textures[0].subsurface(Rect(96*i, 0, 96, 104)) for i in range(6)] xMod = 0 yMod = 0 if self.randVar == 1: xMod = 64*2 elif self.randVar == 2: yMod = 64*2 # Wood animation frames self.woodFrames = [self.textures[1].subsurface(Rect((64*i - (i//2)*128)+xMod, (i//2)*64+yMod, 64, 64)) for i in range(4)] self.fire = Animation(self.fireFrames, .4) self.wood = Animation(self.woodFrames, .4) # Define dead wood and fire frames self.deadWood = self.woodFrames[1] self.deadFire = Surface((0,0))
def __init__(self, variant, xy, sounds, textures): self.variant = variant self.x = xy[0] self.y = xy[1] self.sounds = sounds self.textures = textures[variant] self.worth = [1, 5, 10][variant] self.bounds = Rect(GRIDX+GRATIO*self.x,GRIDY+GRATIO*self.y, 52, 52) self.collideable = False self.pickedUp = False # Split up textures self.frames = [self.textures.subsurface(i*128, 0, 128, 128) for i in range(6)] self.frames = [self.frames[0].copy() for i in range(16)] + self.frames self.anim = Animation(self.frames, 1)
def __init__(self, xyv, xy, ixy, speed, damage, shotRange, friendly, textures, sounds): self.xVel, self.yVel = xyv # X, Y velocity # Stats self.speed = int(speed*2)+4 self.damage = damage+3 self.friendly = friendly self.range = (shotRange*20)+200 self.distance = 0 # sounds self.sounds = sounds self.x = xy[0] self.y = xy[1] # Inherited x and y velocity self.iXVel = ixy[0] self.iYVel = ixy[1] self.poped = False self.frames = [textures[1].subsurface(Rect((i*128 - ((i)//4)*128*4), ((i//4)*128), 128, 128)) for i in range(12)] self.popping = Animation(self.frames, 0.24) self.ox = self.x self.oy = self.y offX = 0 offY = 0 if damage > 7: offX = -7 offY = 1 if not friendly: offY += 2 # Play random shoot sound sounds[randint(0,1)].play() # Texture setup self.texture = textures[0].subsurface(Rect((self.damage+offX)*64, offY*64, 64, 64)) self.width = self.texture.get_width() self.height = self.texture.get_height()
def __init__(self, x, y, image, id, mode=None): self.x = x self.y = y pygame.sprite.Sprite.__init__(self) self.id = id if mode == 1: self.animation = Animation(image, 32, 39, -2) self.image = self.animation.image() self.rect = self.image self.mode = 1 print mode else: self.image = image self.rect = self.image.get_rect() self.mode = 0 self.dx, self.dy = 0, 0 self.rect = self.image.get_rect() self.rect.topleft = (self.x,self.y)
def __init__(self): super(GLTD, self).__init__() self.totalEnemies = 1 self.window = Window() self.window.addActor(GridActor(0, 0, 600, 600)) self.window.board = BoardActor(0, 0, 600, 600) self.window.addActor(self.window.board) self.window.addActor(masterParticleClock) # TODO: unmessify. IMPORTANT #anim = Animation(20, [], LINEAR) #self.px = 10.0 #self.py = 10 #anim.onCompletion(self.createNewParticles) #anim.loop = True #self.window.addAnimation(anim) #anim.start() anim = Animation(1864, [], LINEAR) anim.onCompletion(self.createNewEnemy) anim.loop = True self.window.addAnimation(anim) anim.start() #tower = RedL1TowerActor(4,7) #self.window.addTower(tower) #tower.start() # #tower = RedL1TowerActor(10,5) #tower.range = 150 #tower.reloadSpeed = 300 #tower.damage = 1000 #tower.shake = 2 #self.window.addTower(tower) #tower.start() towerChooser = TowerChooser(600, 300, 200, 300) self.window.addActor(towerChooser) tower = RedL1TowerActor(0, 0) tower.active = False tower.x = tower.y = 40.0 towerChooser.addActor(tower) glutMainLoop()
class Explosion: """Bomb explosion class""" def __init__(self, variant, xy, sound, textures): self.variant = variant self.x = xy[0] self.y = xy[1] self.sound = sound self.textures = textures[variant] self.frames = [self.textures.subsurface(192*i - (i//4)*768,192*(i//4), 192, 192) for i in range(12)] self.anim = Animation(self.frames, .45) sound.play() # Play explosion sound def render(self, surface, time, ox=0, oy=0): # Get frame and blit to screen frame = self.anim.render(time) if self.anim.looped: return False surface.blit(frame, ((GRIDX + GRATIO*self.x) - self.anim.width//2 + ox, (GRIDY + GRATIO*self.y) - self.anim.height//2 - 50 + oy)) return True
def __init__(self, textures, sounds): self.texture = textures["bosses"]["duke"].subsurface(0, 128, 160, 128) self.sounds = sounds self.textures = textures self.frames = [ textures["bosses"]["duke"].subsurface(160, 128, 160, 128), textures["bosses"]["duke"].subsurface(160, 0, 160, 128), textures["bosses"]["duke"].subsurface(0, 0, 160, 128) ] self.tearTextures = textures["tears"] self.tearSounds = sounds["tear"] self.animation = Animation(self.frames, 0.5) self.textures = textures self.lastShot = -1 self.flies = [] self.animating = False
def setup(self, x=None, y=None): #sprite list: self.player_list = arcade.SpriteList() self.wall_list = arcade.SpriteList() self.background_list = arcade.SpriteList() #player setup: self.player = Animation.PlayerCharacter() #setup map: map_name = f"maps/{self.map}.tmx" platforms_layer_name = 'walls' my_map = arcade.tilemap.read_tmx(map_name) # Only create the dialogue event list on the first load, reference list on successive map changes if self.first_load_of_game: # Set up Event Class # (Don't recreate Event class on new map load) self.event = Event.Event() self.event.dialogue_events_overworld = arcade.tilemap.process_layer( arcade.tilemap.read_tmx("maps/overworld.tmx"), "Dialogue_Events", TILE_SCALING) self.event.dialogue_events_dollarstore = arcade.tilemap.process_layer( arcade.tilemap.read_tmx("maps/DollarStore.tmx"), "Dialogue_Events", TILE_SCALING) self.event.dialogue_events_malmart = arcade.tilemap.process_layer( arcade.tilemap.read_tmx("maps/MalMart.tmx"), "Dialogue_Events", TILE_SCALING) self.event.dialogue_events_school = arcade.tilemap.process_layer( arcade.tilemap.read_tmx("maps/TheSchool.tmx"), "Dialogue_Events", TILE_SCALING) self.first_load_of_game = False # Only set-up encounters constructor/set-up on initial game load: self.encounter = Encounter.Encounter() self.encounter.setup(self.view_bottom, self.view_left) # Always display finished events self.finished_event = arcade.tilemap.process_layer( arcade.tilemap.read_tmx(map_name), "Finished_Event", TILE_SCALING) if self.map == "overworld": self.building_list = arcade.SpriteList() self.rand_range = 600 if x and y: self.player.center_x = x self.player.center_y = y else: self.player.center_x = 512 self.player.center_y = 5000 # Use the event list for the overworld self.dialogue_events_list = self.event.dialogue_events_overworld self.building_list = arcade.tilemap.process_layer( my_map, "buildings", TILE_SCALING) arcade.set_background_color(arcade.csscolor.BURLYWOOD) else: # Use event list for Dollar Store if self.map == "DollarStore": self.dialogue_events_list = self.event.dialogue_events_dollarstore # Use event list for MalMart elif self.map == "MalMart": self.dialogue_events_list = self.event.dialogue_events_malmart # Use event list for School elif self.map == "TheSchool": self.dialogue_events_list = self.event.dialogue_events_school self.rand_range = 300 self.door_list = arcade.SpriteList() self.player.center_x = 256 self.player.center_y = 2960 self.door_list = arcade.tilemap.process_layer( my_map, "doors", TILE_SCALING) arcade.set_background_color(arcade.csscolor.WHITE) self.player_list.append(self.player) # Set up overlay class self.overlay = Overlay.Overlay() self.overlay.load_media() #Set up Inventory Class self.inventory = Inventory.Inventory() #set up walls self.wall_list = arcade.tilemap.process_layer( map_object=my_map, layer_name=platforms_layer_name, scaling=TILE_SCALING) #set up background objects: self.background_list = arcade.tilemap.process_layer( my_map, "Background", TILE_SCALING) #setup background: if my_map.background_color: arcade.set_background_color(my_map.background_color) self.physics_engine = arcade.PhysicsEngineSimple( self.player, self.wall_list) self.view_bottom = 0 self.view_left = 0
def process_data(anim, phase, gait, injuries, type='flat'): """ Do FK """ global_xforms = Animation.transforms_global(anim) global_positions = global_xforms[:, :, :3, 3] / global_xforms[:, :, 3:, 3] global_rotations = Quaternions.from_transforms(global_xforms) """ Extract Forward Direction """ #original pfnn bvh hierarchy sdr_l, sdr_r, hip_l, hip_r = 18, 25, 2, 7 #for mixamo bvh hierarchy #sdr_l, sdr_r, hip_l, hip_r = 10, 29, 52, 48 across = ((global_positions[:, sdr_l] - global_positions[:, sdr_r]) + (global_positions[:, hip_l] - global_positions[:, hip_r])) across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] """ Smooth Forward Direction """ direction_filterwidth = 20 forward = filters.gaussian_filter1d(np.cross(across, np.array([[0, 1, 0]])), direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] root_rotation = Quaternions.between( forward, np.array([[0, 0, 1]]).repeat(len(forward), axis=0))[:, np.newaxis] """ Local Space """ local_positions = global_positions.copy() local_positions[:, :, 0] = local_positions[:, :, 0] - local_positions[:, 0:1, 0] local_positions[:, :, 2] = local_positions[:, :, 2] - local_positions[:, 0:1, 2] local_positions = root_rotation[:-1] * local_positions[:-1] local_velocities = root_rotation[:-1] * (global_positions[1:] - global_positions[:-1]) local_rotations = abs((root_rotation[:-1] * global_rotations[:-1])).log() root_velocity = root_rotation[:-1] * (global_positions[1:, 0:1] - global_positions[:-1, 0:1]) root_rvelocity = Pivots.from_quaternions(root_rotation[1:] * -root_rotation[:-1]).ps """ Foot Contacts """ #original pfnn bvh hierarchy fid_l, fid_r = np.array([4, 5]), np.array([9, 10]) #mixamo bvh #fid_l, fid_r = np.array([53,54]), np.array([49,50]) velfactor = np.array([0.02, 0.02]) feet_l_x = (global_positions[1:, fid_l, 0] - global_positions[:-1, fid_l, 0])**2 feet_l_y = (global_positions[1:, fid_l, 1] - global_positions[:-1, fid_l, 1])**2 feet_l_z = (global_positions[1:, fid_l, 2] - global_positions[:-1, fid_l, 2])**2 feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor)).astype(np.float) feet_r_x = (global_positions[1:, fid_r, 0] - global_positions[:-1, fid_r, 0])**2 feet_r_y = (global_positions[1:, fid_r, 1] - global_positions[:-1, fid_r, 1])**2 feet_r_z = (global_positions[1:, fid_r, 2] - global_positions[:-1, fid_r, 2])**2 feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor)).astype(np.float) """ Phase """ dphase = phase[1:] - phase[:-1] dphase[dphase < 0] = (1.0 - phase[:-1] + phase[1:])[dphase < 0] """ Adjust Crouching Gait Value """ if type == 'flat': crouch_low, crouch_high = 80, 130 head = 16 gait[:-1, 3] = 1 - np.clip( (global_positions[:-1, head, 1] - 80) / (130 - 80), 0, 1) gait[-1, 3] = gait[-2, 3] """ Start Windows """ Pc, Xc, Yc = [], [], [] for i in range(window, len(anim) - window - 1, 1): rootposs = root_rotation[i:i + 1, 0] * ( global_positions[i - window:i + window:10, 0] - global_positions[i:i + 1, 0]) rootdirs = root_rotation[i:i + 1, 0] * forward[i - window:i + window:10] rootgait = gait[i - window:i + window:10] Pc.append(phase[i]) Xc.append( np.hstack([ rootposs[:, 0].ravel(), rootposs[:, 2].ravel(), # Trajectory Pos rootdirs[:, 0].ravel(), rootdirs[:, 2].ravel(), # Trajectory Dir rootgait[:, 0].ravel(), rootgait[:, 1].ravel(), # Trajectory Gait rootgait[:, 2].ravel(), rootgait[:, 3].ravel(), rootgait[:, 4].ravel(), rootgait[:, 5].ravel(), local_positions[i - 1].ravel(), # Joint Pos local_velocities[i - 1].ravel(), # Joint Vel injuries[i - 1].ravel() #Joints Link's status ])) rootposs_next = root_rotation[i + 1:i + 2, 0] * ( global_positions[i + 1:i + window + 1:10, 0] - global_positions[i + 1:i + 2, 0]) rootdirs_next = root_rotation[i + 1:i + 2, 0] * forward[i + 1:i + window + 1:10] Yc.append( np.hstack([ root_velocity[i, 0, 0].ravel(), # Root Vel X root_velocity[i, 0, 2].ravel(), # Root Vel Y root_rvelocity[i].ravel(), # Root Rot Vel dphase[i], # Change in Phase np.concatenate([feet_l[i], feet_r[i]], axis=-1), # Contacts rootposs_next[:, 0].ravel(), rootposs_next[:, 2].ravel(), # Next Trajectory Pos rootdirs_next[:, 0].ravel(), rootdirs_next[:, 2].ravel(), # Next Trajectory Dir local_positions[i].ravel(), # Joint Pos local_velocities[i].ravel(), # Joint Vel local_rotations[i].ravel() # Joint Rot ])) return np.array(Pc), np.array(Xc), np.array(Yc)
def fix_foot_contact(input_file, foot_file, output_file, ref_height): anim, name, ftime = BVH.load(input_file) fid = get_ee_id_by_names(name) contact = get_foot_contact(foot_file, ref_height) glb = Animation.positions_global(anim) # [T, J, 3] T = glb.shape[0] for i, fidx in enumerate(fid): # fidx: index of the foot joint fixed = contact[:, i] # [T] s = 0 while s < T: while s < T and fixed[s] == 0: s += 1 if s >= T: break t = s avg = glb[t, fidx].copy() while t + 1 < T and fixed[t + 1] == 1: t += 1 avg += glb[t, fidx].copy() avg /= (t - s + 1) for j in range(s, t + 1): glb[j, fidx] = avg.copy() s = t + 1 for s in range(T): if fixed[s] == 1: continue l, r = None, None consl, consr = False, False for k in range(L): if s - k - 1 < 0: break if fixed[s - k - 1]: l = s - k - 1 consl = True break for k in range(L): if s + k + 1 >= T: break if fixed[s + k + 1]: r = s + k + 1 consr = True break if not consl and not consr: continue if consl and consr: litp = lerp(alpha(1.0 * (s - l + 1) / (L + 1)), glb[s, fidx], glb[l, fidx]) ritp = lerp(alpha(1.0 * (r - s + 1) / (L + 1)), glb[s, fidx], glb[r, fidx]) itp = lerp(alpha(1.0 * (s - l + 1) / (r - l + 1)), ritp, litp) glb[s, fidx] = itp.copy() continue if consl: litp = lerp(alpha(1.0 * (s - l + 1) / (L + 1)), glb[s, fidx], glb[l, fidx]) glb[s, fidx] = litp.copy() continue if consr: ritp = lerp(alpha(1.0 * (r - s + 1) / (L + 1)), glb[s, fidx], glb[r, fidx]) glb[s, fidx] = ritp.copy() # glb is ready anim = anim.copy() rot = torch.tensor(anim.rotations.qs, dtype=torch.float) pos = torch.tensor(anim.positions[:, 0, :], dtype=torch.float) offset = torch.tensor(anim.offsets, dtype=torch.float) glb = torch.tensor(glb, dtype=torch.float) ik_solver = InverseKinematics(rot, pos, offset, anim.parents, glb) print('Fixing foot contact using IK...') for i in tqdm(range(50)): ik_solver.step() rotations = ik_solver.rotations.detach() norm = torch.norm(rotations, dim=-1, keepdim=True) rotations /= norm anim.rotations = Quaternions(rotations.numpy()) anim.positions[:, 0, :] = ik_solver.position.detach().numpy() BVH.save(output_file, anim, name, ftime)
def main(gpu, prefix, mem_frac): is_test = True data_path = "./datasets/test/" min_steps = 120 max_steps = 120 (testlocal, testglobal, testoutseq, testskel, from_names, to_names, tgtjoints, tgtanims, inpjoints, inpanims, gtanims) = load_testdata(min_steps, max_steps) local_mean = np.load(data_path[:-5] + "mixamo_local_motion_mean.npy") local_std = np.load(data_path[:-5] + "mixamo_local_motion_std.npy") global_mean = np.load(data_path[:-5] + "mixamo_global_motion_mean.npy") global_std = np.load(data_path[:-5] + "mixamo_global_motion_std.npy") local_std[local_std == 0] = 1 for i in xrange(len(testlocal)): testlocal[i] = (testlocal[i] - local_mean) / local_std testglobal[i] = (testglobal[i] - global_mean) / global_std testskel[i] = (testskel[i] - local_mean) / local_std num_layer = int(prefix.split("num_layer=")[1].split("_")[0]) gru_units = int(prefix.split("gru_units=")[1].split("_")[0]) keep_prob = 1.0 n_joints = testskel[0].shape[-2] layers_units = [] for i in range(num_layer): layers_units.append(gru_units) if is_test: results_dir = "./results/outputs/test/" + prefix else: results_dir = "./results/outputs/train/" + prefix models_dir = "./models/" + prefix parents = np.array([ -1, 0, 1, 2, 3, 4, 0, 6, 7, 8, 0, 10, 11, 12, 3, 14, 15, 16, 3, 18, 19, 20 ]) with tf.device("/gpu:%d" % gpu): gru = EncoderDecoderGRU(1, None, None, None, None, n_joints, layers_units, max_steps, local_mean, local_std, global_mean, global_std, parents, keep_prob, None, None, None, is_train=False) local_mean = local_mean.reshape((1, 1, -1)) local_std = local_std.reshape((1, 1, -1)) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=mem_frac) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, gpu_options=gpu_options)) as sess: sess.run(tf.global_variables_initializer()) if "paper_models" in models_dir: if "Adv" in prefix: best_model = "EncoderDecoderGRU.model-46000" elif "Cycle" in prefix: best_model = "EncoderDecoderGRU.model-47000" else: best_model = "EncoderDecoderGRU.model-43000" else: best_model = None # will pick last model loaded, model_name = gru.load(sess, models_dir, best_model) if loaded: print("[*] Load SUCCESS") else: print("[!] Load failed...") return for i in xrange(len(testlocal)): print "Testing: " + str(i) + "/" + str(len(testlocal)) mask_batch = np.zeros((1, max_steps), dtype="float32") localA_batch = testlocal[i][:max_steps].reshape([1, max_steps, -1]) globalA_batch = testglobal[i][:max_steps].reshape( [1, max_steps, -1]) seqA_batch = np.concatenate((localA_batch, globalA_batch), axis=-1) skelB_batch = testskel[i][:max_steps].reshape([1, max_steps, -1]) step = max_steps mask_batch[0, :step] = 1.0 res_path = results_dir + "/{0:05d}".format(i) if not os.path.exists(results_dir): os.makedirs(results_dir) outputB, quatsB = gru.predict(sess, seqA_batch, skelB_batch, mask_batch) outputB[:, :step, : -4] = outputB[:, :step, :-4] * local_std + local_mean outputB[:, :step, -4:] = outputB[:, :step, -4:] * global_std + global_mean seqA_batch[:, :step, : -4] = seqA_batch[:, :step, :-4] * local_std + local_mean seqA_batch[:, :step, -4:] = seqA_batch[:, :step, -4:] * global_std + global_mean gt = testoutseq[i][None, :max_steps].copy() tjoints = np.reshape(skelB_batch * local_std + local_mean, [max_steps, -1, 3]) bl_tjoints = tjoints.copy() tgtanim, tgtnames, tgtftime = tgtanims[i] gtanim, gtnames, gtftime = gtanims[i] inpanim, inpnames, inpftime = inpanims[i] tmp_gt = Animation.positions_global(gtanim) start_rots = get_orient_start(tmp_gt, tgtjoints[i][14], tgtjoints[i][18], tgtjoints[i][6], tgtjoints[i][10]) """Exclude angles in exclude_list as they will rotate non-existent children During training.""" exclude_list = [5, 17, 21, 9, 13] canim_joints = [] cquat_joints = [] for l in xrange(len(tgtjoints[i])): if l not in exclude_list: canim_joints.append(tgtjoints[i][l]) cquat_joints.append(l) outputB_bvh = outputB[0].copy() """Follow the same motion direction as the input and zero speeds that are zero in the input.""" outputB_bvh[:, -4:] = outputB_bvh[:, -4:] * ( np.sign(seqA_batch[0, :, -4:]) * np.sign(outputB[0, :, -4:])) outputB_bvh[:, -3][np.abs(seqA_batch[0, :, -3]) <= 1e-2] = 0. outputB_bvh[:, :3] = gtanim.positions[:1, 0, :].copy() wjs, rots = put_in_world_bvh(outputB_bvh.copy(), start_rots) tjoints[:, 0, :] = wjs[0, :, 0].copy() cpy_bvh = seqA_batch[0].copy() cpy_bvh[:, :3] = gtanim.positions[:1, 0, :].copy() bl_wjs, _ = put_in_world_bvh(cpy_bvh.copy(), start_rots) bl_tjoints[:, 0, :] = bl_wjs[0, :, 0].copy() cquat = quatsB[0][:, cquat_joints].copy() if "Big_Vegas" in from_names[i]: from_bvh = from_names[i].replace("Big_Vegas", "Vegas") else: from_bvh = from_names[i] if "Warrok_W_Kurniawan" in to_names[i]: to_bvh = to_names[i].replace("Warrok_W_Kurniawan", "Warrok") else: to_bvh = to_names[i] bvh_path = "./results/blender_files/" + to_bvh.split("_")[-1] if not os.path.exists(bvh_path): os.makedirs(bvh_path) bvh_path += "/{0:05d}".format(i) BVH.save( bvh_path + "_from=" + from_bvh + "_to=" + to_bvh + "_gt.bvh", gtanim, gtnames, gtftime) tgtanim.positions[:, tgtjoints[i]] = bl_tjoints.copy() tgtanim.offsets[tgtjoints[i][1:]] = bl_tjoints[0, 1:] BVH.save( bvh_path + "_from=" + from_bvh + "_to=" + to_bvh + "_cpy.bvh", tgtanim, tgtnames, tgtftime) tgtanim.positions[:, tgtjoints[i]] = tjoints tgtanim.offsets[tgtjoints[i][1:]] = tjoints[0, 1:] """World rotation of character (global rotation)""" cquat[:, 0:1, :] = (rots * Quaternions(cquat[:, 0:1, :])).qs tgtanim.rotations.qs[:, canim_joints] = cquat BVH.save(bvh_path + "_from=" + from_bvh + "_to=" + to_bvh + ".bvh", tgtanim, tgtnames, tgtftime) BVH.save( bvh_path + "_from=" + from_bvh + "_to=" + to_bvh + "_inp.bvh", inpanim, inpnames, inpftime) np.savez(res_path + "_from=" + from_names[i] + "_to=" + to_names[i] + ".npz", outputA_=outputB[:, :step], outputB_=outputB[:, :step], quatsB=quatsB[:, :step], input_=seqA_batch[:, :step], gt=gt) print "Done."
def apply_results(towr_results, anim_bvh, start_idx, end_idx, character, run_ik=True): ''' Applies trajectory optim results back to our original skeleton. ''' # read in og animation anim, names, _ = BVH.load(anim_bvh) anim.rotations = anim.rotations[start_idx:end_idx] anim.positions = anim.positions[start_idx:end_idx] toe_inds = get_character_toe_inds(character) ankle_inds = get_character_ankle_inds(character) # add heel to IK with towr results if (not character in heeled_characters) and (towr_results.feet_pos.shape[1] == 4): anim, _ = add_heel_to_anim(anim, toe_inds, ankle_inds) init_pos = Animation.positions_global(anim) upper_body_joints = get_character_upper_body(character) map_segment_to_joints = get_character_seg_to_joint_map(character) map_segment_to_mass_perc = get_character_seg_to_mass_perc_map(character) left_toe_idx, right_toe_idx = get_character_toe_inds(character) # calc COM over time and offsets of upper body joints (including root) # since we only need offsets, don't have to zero out position anim_COM = np.zeros((anim.shape[0], 3)) upper_offsets = np.zeros((anim.shape[0], len(upper_body_joints), 3)) for i in range(anim.shape[0]): cur_COM = np.zeros(3) for key in map_segment_to_joints.keys(): seg_pos = np.mean(init_pos[i, map_segment_to_joints[key], :], axis=0) mass_frac = map_segment_to_mass_perc[key] * 0.01 cur_COM += mass_frac * seg_pos anim_COM[i] = cur_COM for j in range(len(upper_body_joints)): upper_offsets[i, j] = init_pos[i, upper_body_joints[j]] - cur_COM anim_og = deepcopy(anim) com_og = anim_COM.copy() # desired global position of upper joints is based on optimized COM position seq_len = end_idx - start_idx desired_pos = upper_offsets + np.expand_dims(towr_results.base_pos[:seq_len], axis=1)*100.0 # keep everything the same except replace # root information with optimized output anim.rotations[:,0,:] = Quaternions.from_euler(towr_results.base_rot, order='xyz', world=True)[:seq_len] anim.positions[:,0,:] = desired_pos[:,0,:] if run_ik: # add IK targets for upper body joints targetmap = {} for i in range(len(upper_body_joints)): targetmap[upper_body_joints[i]] = desired_pos[:,i,:] # setup IK with foot joints targetetd at feet position optimized outputs left_foot_target = towr_results.feet_pos[:seq_len,0,:] * 100.0 # out of meters right_foot_target = towr_results.feet_pos[:seq_len,1,:] * 100.0 # out of meters targetmap[left_toe_idx] = left_foot_target targetmap[right_toe_idx] = right_foot_target # and heels left_heel_idx = anim.positions.shape[1] - 2 right_heel_idx = anim.positions.shape[1] - 1 if character in heeled_characters: print('Using COMBINED character') # already has a heel joint left_heel_idx, right_heel_idx = get_character_heel_inds(character) if towr_results.feet_pos.shape[1] == 4: print('Found heel data, including it in IK') left_heel_target = towr_results.feet_pos[:seq_len,2,:] * 100.0 right_heel_target = towr_results.feet_pos[:seq_len,3,:] * 100.0 targetmap[left_heel_idx] = left_heel_target targetmap[right_heel_idx] = right_heel_target # run IK ik = JacobianInverseKinematicsCK(anim, targetmap, translate=True, iterations=30, smoothness=0.001, damping=7.0, silent=False) ik() return anim, names, anim_og, com_og
def __call__(self, descendants=None, gamma=1.0): self.descendants = descendants """ Calculate Masses """ if self.weights is None: self.weights = np.ones(self.animation.shape[1]) if self.weights_translate is None: self.weights_translate = np.ones(self.animation.shape[1]) """ Calculate Descendants """ if self.descendants is None: self.descendants = AnimationStructure.descendants_mask(self.animation.parents) self.tdescendants = np.eye(self.animation.shape[1]) + self.descendants self.first_descendants = self.descendants[:,np.array(list(self.targets.keys()))].repeat(3, axis=0).astype(int) self.first_tdescendants = self.tdescendants[:,np.array(list(self.targets.keys()))].repeat(3, axis=0).astype(int) """ Calculate End Effectors """ self.endeff = np.array(list(self.targets.values())) self.endeff = np.swapaxes(self.endeff, 0, 1) if not self.references is None: self.second_descendants = self.descendants.repeat(3, axis=0).astype(int) self.second_tdescendants = self.tdescendants.repeat(3, axis=0).astype(int) self.second_targets = dict([(i, self.references[:,i]) for i in xrange(self.references.shape[1])]) nf = len(self.animation) nj = self.animation.shape[1] if not self.silent: gp = Animation.positions_global(self.animation) gp = gp[:,np.array(list(self.targets.keys()))] error = np.mean(np.sqrt(np.sum((self.endeff - gp)**2.0, axis=2))) print('[JacobianInverseKinematics] Start | Error: %f' % error) for i in range(self.iterations): """ Get Global Rotations & Positions """ gt = Animation.transforms_global(self.animation) gp = gt[:,:,:,3] gp = gp[:,:,:3] / gp[:,:,3,np.newaxis] gr = Quaternions.from_transforms(gt) x = self.animation.rotations.euler().reshape(nf, -1) w = self.weights.repeat(3) if self.translate: x = np.hstack([x, self.animation.positions.reshape(nf, -1)]) w = np.hstack([w, self.weights_translate.repeat(3)]) """ Generate Jacobian """ if self.recalculate or i == 0: j = self.jacobian(x, gp, gr, self.targets, self.first_descendants, self.first_tdescendants) """ Update Variables """ l = self.damping * (1.0 / (w + 0.001)) d = (l*l) * np.eye(x.shape[1]) e = gamma * (self.endeff.reshape(nf,-1) - gp[:,np.array(list(self.targets.keys()))].reshape(nf, -1)) x += np.array(list(map(lambda jf, ef: linalg.lu_solve(linalg.lu_factor(jf.T.dot(jf) + d), jf.T.dot(ef)), j, e))) """ Generate Secondary Jacobian """ if self.references is not None: ns = np.array(list(map(lambda jf: np.eye(x.shape[1]) - linalg.solve(jf.T.dot(jf) + d, jf.T.dot(jf)), j))) if self.recalculate or i == 0: j2 = self.jacobian(x, gp, gr, self.second_targets, self.second_descendants, self.second_tdescendants) e2 = self.secondary * (self.references.reshape(nf, -1) - gp.reshape(nf, -1)) x += np.array(list(map(lambda nsf, j2f, e2f: nsf.dot(linalg.lu_solve(linalg.lu_factor(j2f.T.dot(j2f) + d), j2f.T.dot(e2f))), ns, j2, e2))) """ Set Back Rotations / Translations """ self.animation.rotations = Quaternions.from_euler( x[:,:nj*3].reshape((nf, nj, 3)), order='xyz', world=True) if self.translate: self.animation.positions = x[:,nj*3:].reshape((nf,nj, 3)) """ Generate Error """ if not self.silent: gp = Animation.positions_global(self.animation) gp = gp[:,np.array(list(self.targets.keys()))] error = np.mean(np.sum((self.endeff - gp)**2.0, axis=2)**0.5) print('[JacobianInverseKinematics] Iteration %i | Error: %f' % (i+1, error))
18: 25, 19: 26, 20: 27, 22: 30, 24: 12, 25: 17, 26: 18, 27: 19, 29: 22 } targetmap = {} #targetmap[1] = anim.positions[:,0,:] for k in mapping: #anim.rotations[:,k] = stanim.rotations[:,mapping[k]] targetmap[k] = normalizedPose[:, mapping[k], :] #ik = JacobianInverseKinematics(anim, targetmap, iterations=10, damping=10.0, silent=True) ik = JacobianInverseKinematics(anim, targetmap, iterations=20, damping=10.0, silent=True) ik() """Debug""" targets = Animation.positions_global(anim) targets_vis = conv_visGl_form(targets) * 5 showSkeleton([targets_vis, original_vis]) #Debug #BVH.save('./h36m/'+'S'+str(subjectIdx) + '-' + os.path.split(cdf_file)[1].replace('.cdf', '.bvh'), anim, names)
rect1.x=50 rect1.y=200 but1=pygame.Surface((50,50)) but1.fill((0,255,0)) rect2=but.get_rect() rect2.x=100 rect2.y=200 but2=pygame.Surface((50,50)) but2.fill((0,0,255)) rect3=but.get_rect() rect3.x=150 rect3.y=200 animations=[] animations.append(Animation('picture/looking.png',12)) animations.append(Animation('picture/attack.png',12)) animations.append(Animation('picture/run.png',8)) animations.append(Animation('picture/talking.png',8)) player1=Player(animations,50,50) GAME=True sc.blit(player1.image,player1.rect) sc.blit(but,rect1) sc.blit(but1,rect2) sc.blit(but2,rect3) pygame.display.update() while GAME: for i in pygame.event.get(): if i.type==pygame.QUIT: GAME=False
def retarget_skeleton(self, normalizedPose): """ Retargets the Panoptic Skeleton onto CMU skeleton :param normalizedPose: Panoptic skeleton (57, F) :return: retargeted animation """ # reshape normalizedPose = np.transpose(normalizedPose) # (frames,57) normalizedPose = normalizedPose.reshape(normalizedPose.shape[0], 19, 3) # (frames,19,3) # Flip Y axis normalizedPose[:, :, 1] = -normalizedPose[:, :, 1] # calculate panoptic height panopticThigh = normalizedPose[:, 6, :] - normalizedPose[:, 7, :] panopticThigh = panopticThigh**2 panopticHeight = np.mean(np.sqrt(np.sum(panopticThigh, axis=1))) # load the rest skeleton rest, names, _ = BVH.load('meta/rest.bvh') # temp # create a mock animation for the required duration anim = rest.copy() anim.positions = anim.positions.repeat(normalizedPose.shape[0], axis=0) anim.rotations.qs = anim.rotations.qs.repeat(normalizedPose.shape[0], axis=0) # get the FK solved global positions cmuMocapJoints = Animation.positions_global(anim) # calculate CMU skeleton height cmuThigh = cmuMocapJoints[:, 2, :] - cmuMocapJoints[:, 3, :] cmuThigh = cmuThigh**2 cmuMocapHeight = np.mean(np.sqrt(np.sum(cmuThigh, axis=1))) cmuMocapHeight = cmuMocapHeight * 0.9 # scale the skelton appropriately scaleRatio = cmuMocapHeight / panopticHeight print("cmuMocapHeight: %f, panopticHeight %f, scaleRatio: %f " % (cmuMocapHeight, panopticHeight, scaleRatio)) normalizedPose = normalizedPose * scaleRatio # rescaling # compute mean across vector across1 = normalizedPose[:, 3] - normalizedPose[:, 9] # Right -> left (3) Shoulder across0 = normalizedPose[:, 6] - normalizedPose[:, 12] # Right -> left (6) Hips across = across0 + across1 # frame x 3 across = across / np.sqrt( (across**2).sum(axis=-1))[..., np.newaxis] ##frame x 3. Unit vectors # compute forward direction forward = np.cross(across, np.array([[0, -1, 0]])) forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) # Set root's movement by hipCenter joints (idx=2) anim.positions[:, 0] = normalizedPose[:, 2] + np.array([0.0, 2.4, 0.0]) anim.rotations[:, 0:1] = -Quaternions.between(forward, target)[:, np.newaxis] targetmap = {} for k in self.mapping: targetmap[k] = normalizedPose[:, self.mapping[k], :] # Retarget using JacobianIK ik = JacobianInverseKinematics(anim, targetmap, iterations=20, damping=10.0, silent=True) ik() # scale skeleton appropriately anim.positions = anim.positions * 6.25 anim.offsets = anim.offsets * 6.25 # Do FK recover 3D joint positions, select required Joints only positions = Animation.positions_global(anim) positions = positions[:, self.jointIdx] return positions
def main(): init() global width, height, animator size = width, height = 1920, 1080 screen = pygame.display.set_mode(size, FULLSCREEN) gameClock = time.Clock() animator = Animation() #load default background background = pygame.sprite.Group() bg1 = SpriteRemix.Background( transform.scale( image.load("Assets\\backgrounds\outsidebg.png").convert(), (1920, 1080))) bg2 = SpriteRemix.Background( transform.scale( image.load("Assets\\backgrounds\outsidebg.png").convert(), (1920, 1080))) bg1.stateVal = 1 #slowscroll bg2.stateVal = 1 #slowscroll bg1.add(background) bg2.add(background) #load ui, TODO: encapsulate this shit ui = pygame.sprite.Group() health = SpriteRemix.UI( transform.scale( image.load("Assets\\sprites\\ui\\health.png").convert(), (596, 72))) healthbar = SpriteRemix.UI( transform.scale( image.load("Assets\\sprites\\ui\\healthbar.png").convert_alpha(), (840, 84))) health.add(ui) healthbar.add(ui) #create cursor and add it to a sprite group, can only hold 1 cursor at a time cursors = pygame.sprite.GroupSingle() crsr = SpriteRemix.Cursor( transform.scale( pygame.image.load( "Assets\\sprites\\cursors\\crosshair1.png").convert_alpha(), (70, 70))) crsr.add(cursors) #create pc and add it to a sprite group #TODO: need an initializer class for player that loads projectiles and weapons and shit pc = pygame.sprite.Group() playerSprite = PlayerCharacterSprite() animator.load(playerSprite) playerSprite.add(pc) #weapon, this shit is f*****g retarded pcAccessory = pygame.sprite.Group() playerWeapon = SpriteRemix.Weapon() animator.load(playerWeapon) playerWeapon.add(pcAccessory) #create baddies and add them to a sprite group baddies = sprite.Group() baddySprite = EnemyCharacterSprite("notzigrunt") animator.load(baddySprite) baddySprite.add(baddies) #create doodads and add them to a sprite group doodads = sprite.Group() box = SpriteRemix.Doodad( pygame.image.load("Assets\\sprites\\doodads\\box.png").convert()) #alsoBox = Doodad(pygame.image.load("Assets\\sprites\\doodads\\box.png").convert()) box.add(doodads) #alsoBox.add(doodads) #initialize projectile sprite group (obv nothing to put here at startup projectiles = sprite.Group() #floating combat text combatTextArr = [] #place everything bg1.rect.topleft = [-1920, 0] bg2.rect.topleft = [0, 0] healthbar.rect.topleft = [50, 50] health.rect.topleft = [healthbar.rect.left + 239, healthbar.rect.top + 5] playerSprite.rect.bottomleft = [100, height - 50] playerWeapon.rect.midright = playerSprite.rect.midleft baddySprite.rect.bottom = height baddySprite.rect.left = 960 box.rect.left = 540 box.rect.bottom = height '''alsoBox.rect.left = 920 alsoBox.rect.bottom = height''' #create a list of all sprite groups entities = [pc.sprites(), baddies.sprites()] sprites = [ pc, pcAccessory, baddies, doodads, projectiles, background, ui, cursors ] while 1: now = time.get_ticks() #this for loop processes all inputs in the event queue events = pygame.event.get() for event in events: #close window and quit if x is clicked or esc is pressed if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE): quit() sys.exit() #track the cursor if event.type == MOUSEMOTION: crsr.rect.centerx = event.pos[0] crsr.rect.centery = event.pos[1] #if no input is given, this remains True, animation reflects that. if not playerSprite.state["ducking"]: playerSprite.state["idle"] = True #only control pc if pc not dead #may be simplified by banning control input events when pc dies. if not playerSprite.state["dying"] and not playerSprite.state[ "dead"]: #movement d-right a-left space-jump if not playerSprite.state["ducking"]: if event.type == KEYUP and event.key == K_d: playerSprite.rightDash = now Movement.accel(playerSprite, -playerSprite.velocity[0]) Movement.coast(playerSprite, playerSprite.velocity[0]) if playerSprite.velocity[0] == 0: playerSprite.state["running"] = False playerSprite.idleTime = 0 playerSprite.state["idle"] = False elif event.type == KEYUP and event.key == K_a: playerSprite.leftDash = now Movement.accel(playerSprite, -playerSprite.velocity[0]) Movement.coast(playerSprite, playerSprite.velocity[0]) if playerSprite.velocity[0] == 0: playerSprite.state["running"] = False playerSprite.idleTime = 0 playerSprite.state["idle"] = False elif event.type == KEYDOWN and event.key == K_d: if now - playerSprite.rightDash > 250: Movement.accel(playerSprite, 12) else: Movement.accel(playerSprite, 24) playerSprite.leftDash = 0 playerSprite.xflip = False if not playerSprite.state[ "jumping"] and not playerSprite.state[ "falling"]: playerSprite.state["running"] = True playerSprite.idleTime = 0 playerSprite.state["idle"] = False elif event.type == KEYDOWN and event.key == K_a: if now - playerSprite.leftDash > 250: Movement.accel(playerSprite, -12) else: Movement.accel(playerSprite, -24) playerSprite.rightDash = 0 playerSprite.xflip = True if not playerSprite.state[ "jumping"] and not playerSprite.state[ "falling"]: playerSprite.state["running"] = True playerSprite.idleTime = 0 playerSprite.state["idle"] = False if playerSprite.velocity[0] == 0 and playerSprite.velocity[ 1] == 0: if event.type == KEYUP and event.key == K_s: playerSprite.idleTime = 0 playerSprite.state["ducking"] = False playerSprite.state["idle"] = False elif event.type == KEYDOWN and event.key == K_s: #crouching provides traction playerSprite.xcoast = playerSprite.xcoast / 2.0 playerSprite.state["ducking"] = True playerSprite.idleTime = 0 playerSprite.state["idle"] = False if event.type == KEYUP and event.key == K_SPACE: playerSprite.velocity[1] = max(0, playerSprite.velocity[1]) playerSprite.state["jumping"] = False playerSprite.idleTime = 0 playerSprite.state["idle"] = False if event.type == KEYDOWN and event.key == K_SPACE: Movement.jump(playerSprite) playerSprite.state["idle"] = False playerSprite.state["jumping"] = True playerSprite.idleTime = 0 playerSprite.state["idle"] = False #melee attack if event.type == MOUSEBUTTONDOWN and event.button == 1 and now - playerSprite.lastMelee > 300: playerSprite.state["attacking"] = True playerSprite.last["meleed"] = now playerSprite.idleTime = 0 playerWeapon.hostile = True playerSprite.state["idle"] = False if event.type == MOUSEBUTTONUP and event.button == 1: playerWeapon.hostile = False playerSprite.state["idle"] = False playerSprite.state["attacking"] = False #ranged attack if event.type == MOUSEBUTTONDOWN and event.button == 3 and playerSprite.ammo > 0 and now - playerSprite.lastShot > 250: playerSprite.ammo -= 1 projLoc = [ playerSprite.rect.right, playerSprite.rect.bottom - 130 ] newProj = SpriteRemix.Projectile(projLoc, event.pos, speed=45) animator.load(newProj) newProj.add(projectiles) newProj.rect.center = projLoc playerSprite.last["shot"] = now playerSprite.state["shooting"] = True playerSprite.idleTime = 0 playerSprite.state["idle"] = False #ragdoll pc else: playerSprite.xcoast = playerSprite.velocity[0] playerSprite.ycoast = playerSprite.velocity[1] playerSprite.velocity = [0, 0] if playerSprite.state["idle"]: playerSprite.idleTime += gameClock.get_time() if playerSprite.idleTime >= 2000: playerSprite.state["idle"] = True elif playerSprite.idleTime >= 300: playerSprite.state["ready"] = True #baddy behavior '''if (now%1000 < 20) and baddySprite.stateVal != 1: Movement.jump(baddySprite)''' #replenish ammo over time if (now % 100 < 20) and playerSprite.ammo < 4: playerSprite.ammo += 1 if (now % 5000 < 20): print(playerSprite.state) #sprites move, but these moves haven't been drawn yet for i in range(len(sprites) - 2): groupList = sprites[i].sprites() for aSprite in groupList: if aSprite.xcoast > 0: if aSprite.xcoast > .6: aSprite.xcoast += min(-aSprite.xcoast * .1, -.6) else: aSprite.xcoast = 0 elif aSprite.xcoast < 0: if aSprite.xcoast < -.6: aSprite.xcoast += max(-aSprite.xcoast * .1, .6) else: aSprite.xcoast = 0 if aSprite.ycoast > 0: if aSprite.ycoast > .6: aSprite.ycoast += min(-aSprite.ycoast * .1, -.6) else: aSprite.ycoast = 0 elif aSprite.ycoast < 0: if aSprite.ycoast < -.6: aSprite.ycoast += max(-aSprite.ycoast * .1, .6) else: aSprite.ycoast = 0 aSprite.rect = aSprite.rect.move([ aSprite.velocity[0] + aSprite.xcoast, aSprite.velocity[1] + aSprite.ycoast ]) # keeps characters in frame and handles collisions resolveFrame(sprites, entities, combatTextArr) # position the pc's weapon # TODO: encapsulate this, preferably in Animation once I figure out why it wasn't working there. playerWeapon.state = playerSprite.state if playerSprite.xflip: if playerWeapon.state["dead"] or playerWeapon.state["idle"]: playerWeapon.rect.topleft = [0, 0] elif playerWeapon.state["attacking"] or playerWeapon.state[ "shooting"]: playerWeapon.rect.midright = [ playerSprite.rect.midleft[0] + 8, playerSprite.rect.midleft[1] - 62 ] else: playerWeapon.rect.midleft = [ playerSprite.rect.midright[0], playerSprite.rect.midright[1] + 58 ] playerWeapon.xflip = True else: if playerWeapon.state["dead"] or playerWeapon.state["idle"]: playerWeapon.rect.topleft = [0, 0] elif playerWeapon.state["attacking"] or playerWeapon.state[ "shooting"]: playerWeapon.rect.midleft = [ playerSprite.rect.midright[0] - 8, playerSprite.rect.midright[1] - 62 ] else: playerWeapon.rect.midright = [ playerSprite.rect.midleft[0], playerSprite.rect.midleft[1] + 58 ] playerWeapon.xflip = False # only animate characters and projectiles so far (i = 0 is pc, i = 1 is baddies, i = 3 is projectiles, i = 4 is background) animator.animate([ sprites[0].sprites(), sprites[1].sprites(), sprites[2].sprites(), sprites[4].sprites(), sprites[5].sprites() ], now) # refresh screen by drawing over previous frame with background screen.blit(bg1.image, bg1.rect) screen.blit(bg2.image, bg2.rect) # draw active CombatText objects and remove faded ones for combatText in combatTextArr[:]: if combatText.progress(now): combatText.draw(screen) else: combatTextArr.remove(combatText) # draw all the rest of the in-use assets for i in range(len(sprites)): if i != 5: #don't draw UI # only draw visible sprites in each group # NOTE: this is probably bad, as I'd assume .draw() (sprite method that blits all sprites in a sprite group)is better # optimized, but we can't make it optionally draw # sprites unless we change everything to DirtySprites (a type built into pygame) for aSprite in sprites[i].sprites(): if aSprite.visible: screen.blit(aSprite.image, aSprite.rect) # draw UI last if health.rect.width > 5.96 * playerSprite.health: health.image = transform.scale( health.image, (max(0, health.rect.width - 3), health.rect.height)) health.rect = health.image.get_rect() health.rect.topleft = (289, 56) screen.blit(health.image, health.rect) screen.blit(healthbar.image, healthbar.rect) gameClock.tick(60) #game over check if playerSprite.health <= 0: defaultText = font.Font(None, 120) gameOverSurface = defaultText.render("Game Over man, Game Over!", True, (255, 0, 0)) gameOverRect = gameOverSurface.get_rect() gameOverRect.center = (960, 540) screen.blit(gameOverSurface, gameOverRect) playerSprite.state["dead"] = True #victory check enemies = sprites[2].sprites() allDead = True for enemy in enemies: if enemy.stateVal != 4: allDead = False if allDead: defaultText = font.Font(None, 200) conglaturationSurface = defaultText.render("Conglaturation", True, (255, 255, 255)) conglaturationRect = conglaturationSurface.get_rect() conglaturationRect.center = (960, 540) screen.blit(conglaturationSurface, conglaturationRect) pygame.display.flip()
class Tear: """Main tear class""" def __init__(self, xyv, xy, ixy, speed, damage, shotRange, friendly, textures, sounds): self.xVel, self.yVel = xyv # X, Y velocity # Stats self.speed = int(speed * 2) + 4 self.damage = damage + 3 self.friendly = friendly self.range = (shotRange * 20) + 200 self.distance = 0 # sounds self.sounds = sounds self.x = xy[0] self.y = xy[1] # Inherited x and y velocity self.iXVel = ixy[0] self.iYVel = ixy[1] self.poped = False self.frames = [ textures[1].subsurface( Rect((i * 128 - ((i) // 4) * 128 * 4), ((i // 4) * 128), 128, 128)) for i in range(12) ] self.popping = Animation(self.frames, 0.24) self.ox = self.x self.oy = self.y offX = 0 offY = 0 if damage > 7: offX = -7 offY = 1 if not friendly: offY += 2 # Play random shoot sound sounds[randint(0, 1)].play() # Texture setup self.texture = textures[0].subsurface( Rect((self.damage + offX) * 64, offY * 64, 64, 64)) self.width = self.texture.get_width() self.height = self.texture.get_height() def step(self): self.texture = self.frames[self.frameIndex] self.frameIndex += 1 def pop(self, collision): self.poped = True if collision: self.sounds[2].play() # Play collison pop else: self.sounds[1].play() # Play normal pop return True def render(self, surface, time, bounds, obsticals): if self.poped: # Return popping tear frame = self.popping.render(time) if self.popping.looped: return False surface.blit(frame, (self.x - self.popping.width // 2, self.y - self.popping.height // 2)) return True if abs(self.x - self.ox) < self.range and abs(self.y - self.oy) < self.range: dx = 0 dy = 0 dx += self.xVel * self.speed dy += self.yVel * self.speed # Add inherited X and Y velocity dx += self.iXVel dy += self.iYVel inBoundsX = bounds.collidepoint(self.x + dx, self.y) inBoundsY = bounds.collidepoint(self.x, self.y + dx) rockColX = False rockColY = False for ob in obsticals: # Collide with ob try: if ob.destroyed: continue except: pass # Collude with object rcx = ob.bounds.collidepoint(self.x + self.speed, self.y) rcy = ob.bounds.collidepoint(self.x, self.y + self.speed) if rcx or rcy: try: ob.hurt(1) except: pass if not ob.collideable: rockColX = rockColY = False return self.pop(True) if not inBoundsX or not inBoundsY: # Ensure tear is within level bounds return self.pop(True) # Add to x and y self.x += dx self.y += dy surface.blit(self.texture, (self.x - self.width // 2, self.y - self.height // 2)) return True return self.pop(False)
continue m1 = re.match('(\d+_\d+)\s+([^\n]*)\n', line) if m1: id0, id1 = m1.group(1).split('_') database.append((id0, id1)) info.close() baddata = set([('90', '10')]) database = [data for data in database if (data[0], data[1]) not in baddata] """ Begin Processing """ rest, names, _ = BVH.load(dbroot + '01/01_01.bvh') rest_targets = Animation.positions_global(rest) rest_height = rest_targets[0, :, 1].max() skel = rest.copy() skel.positions = rest.positions[0:1] skel.rotations = rest.rotations[0:1] skel.positions[:, 0, 0] = 0 skel.positions[:, 0, 2] = 0 skel.offsets[0, 0] = 0 skel.offsets[0, 2] = 0 skel.offsets = skel.offsets * 6.25 skel.positions = skel.positions * 6.25 BVH.save('./skel_motionbuilder.bvh', skel, names) rest.positions = rest.offsets[np.newaxis]
def process_file_body_speech_face(faceParamDir, filename, window=240, window_step=120): ######################### ## Load Speech Data seqName = os.path.basename(filename) fileName_pkl = seqName[:-7] + '.pkl' speechPath = './panopticDB_pkl_speech_hagglingProcessed/' + fileName_pkl speechData = pickle.load(open(speechPath, "rb")) if '_p0.bvh' in filename: speechData = speechData['speechData'][0] elif '_p1.bvh' in filename: speechData = speechData['speechData'][1] elif '_p2.bvh' in filename: speechData = speechData['speechData'][2] ######################### ## Load Face Data facePath = faceParamDir + fileName_pkl faceParamData = pickle.load(open(facePath, "rb")) if '_p0.bvh' in filename: subjectRole = 0 elif '_p1.bvh' in filename: subjectRole = 1 elif '_p2.bvh' in filename: subjectRole = 2 faceParamData = faceParamData['subjects'][subjectRole][ 'face_exp'] #200 x frames faceParamData = np.swapaxes(faceParamData, 0, 1) # frames x 200 ######################### ## Load Bdoy Data anim, names, frametime = BVH.load(filename) # """ Convert to 60 fps """ # anim = anim[::2] # Origianl Human3.6 has 50 fps. So, no smapling is done """ Do FK """ global_positions = Animation.positions_global(anim) """ Remove Uneeded Joints """ positions = global_positions[:, np.array([ 0, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 16, 18, 19, 20, 22, 25, 26, 27, 29 ])] """ Put on Floor """ fid_l, fid_r = np.array([4, 5]), np.array([8, 9]) foot_heights = np.minimum(positions[:, fid_l, 1], positions[:, fid_r, 1]).min(axis=1) floor_height = softmin(foot_heights, softness=0.5, axis=0) positions[:, :, 1] -= floor_height """ Add Reference Joint """ trajectory_filterwidth = 3 reference = positions[:, 0] * np.array([1, 0, 1]) reference = filters.gaussian_filter1d(reference, trajectory_filterwidth, axis=0, mode='nearest') positions = np.concatenate([reference[:, np.newaxis], positions], axis=1) """ Get Foot Contacts """ velfactor, heightfactor = np.array([0.05, 0.05]), np.array([3.0, 2.0]) feet_l_x = (positions[1:, fid_l, 0] - positions[:-1, fid_l, 0])**2 feet_l_y = (positions[1:, fid_l, 1] - positions[:-1, fid_l, 1])**2 feet_l_z = (positions[1:, fid_l, 2] - positions[:-1, fid_l, 2])**2 feet_l_h = positions[:-1, fid_l, 1] feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor) & (feet_l_h < heightfactor)).astype(np.float) feet_r_x = (positions[1:, fid_r, 0] - positions[:-1, fid_r, 0])**2 feet_r_y = (positions[1:, fid_r, 1] - positions[:-1, fid_r, 1])**2 feet_r_z = (positions[1:, fid_r, 2] - positions[:-1, fid_r, 2])**2 feet_r_h = positions[:-1, fid_r, 1] feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor) & (feet_r_h < heightfactor)).astype(np.float) """ Get Root Velocity """ velocity = (positions[1:, 0:1] - positions[:-1, 0:1]).copy() """ Remove Translation """ positions[:, :, 0] = positions[:, :, 0] - positions[:, 0:1, 0] positions[:, :, 2] = positions[:, :, 2] - positions[:, 0:1, 2] """ Get Forward Direction """ sdr_l, sdr_r, hip_l, hip_r = 14, 18, 2, 6 across1 = positions[:, hip_l] - positions[:, hip_r] across0 = positions[:, sdr_l] - positions[:, sdr_r] across = across0 + across1 across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] direction_filterwidth = 20 forward = np.cross(across, np.array([[0, 1, 0]])) forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] """ Remove Y Rotation """ target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) rotation = Quaternions.between(forward, target)[:, np.newaxis] positions = rotation * positions """ Get Root Rotation """ velocity = rotation[1:] * velocity rvelocity = Pivots.from_quaternions(rotation[1:] * -rotation[:-1]).ps """ Add Velocity, RVelocity, Foot Contacts to vector """ positions = positions[:-1] positions = positions.reshape(len(positions), -1) positions = np.concatenate([positions, velocity[:, :, 0]], axis=-1) positions = np.concatenate([positions, velocity[:, :, 2]], axis=-1) positions = np.concatenate([positions, rvelocity], axis=-1) positions = np.concatenate([positions, feet_l, feet_r], axis=-1) ################################################## ## Chunk Generation """ Slide over windows """ windows_body = [] windows_face = [] windows_speech = [] print("skelSize {0} vs speechSize {1}".format( positions.shape[0], speechData['indicator'].shape[0])) for j in range(0, len(positions) - window // 8, window_step): ## Face Part ############################v face_slice = faceParamData[j:j + window] # faceParamData: (frames,200) if len(face_slice) < window: break if len(face_slice) != window: raise Exception() #Check Bad data (abs(value)>2) maxValue = np.max(abs(face_slice)) if (maxValue > 2.0): continue #Face Param Cropping (just use initial 5 dim) face_slice = face_slice[:, :5] ## Body Part ############################v body_slice = positions[j:j + window] # position: (frames,73) if len(body_slice) < window: break if len(body_slice) != window: raise Exception() ## Speech Part ############################v speech_slice = speechData['indicator'][ j:j + window] # speechData['indicator']: (frames,) ## Append ############################v windows_body.append(body_slice) windows_face.append(face_slice) windows_speech.append(speech_slice) return windows_body, windows_face, windows_speech
def setUp(self): super(BaseTestCase, self).setUp() self.launcher, self.test_type = self.get_launcher_and_type() self.app = Animation.TouchApp(self.launcher(), self.test_type)
def process_file(filename, window=1, window_step=1): anim, names, frametime = BVH.load(filename) # """ Convert to 60 fps """ # anim = anim[::2] # Origianl Human3.6 has 50 fps. So, no smapling is done """ Do FK """ global_positions = Animation.positions_global(anim) """ Remove Uneeded Joints """ positions = global_positions[:, np.array([ 0, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 16, 18, 19, 20, 22, 25, 26, 27, 29 ])] """ Put on Floor """ fid_l, fid_r = np.array([4, 5]), np.array([8, 9]) foot_heights = np.minimum(positions[:, fid_l, 1], positions[:, fid_r, 1]).min(axis=1) floor_height = softmin(foot_heights, softness=0.5, axis=0) positions[:, :, 1] -= floor_height """ Add Reference Joint """ trajectory_filterwidth = 3 reference = positions[:, 0] * np.array([1, 0, 1]) reference = filters.gaussian_filter1d(reference, trajectory_filterwidth, axis=0, mode='nearest') positions = np.concatenate([reference[:, np.newaxis], positions], axis=1) """ Get Foot Contacts """ velfactor, heightfactor = np.array([0.05, 0.05]), np.array([3.0, 2.0]) feet_l_x = (positions[1:, fid_l, 0] - positions[:-1, fid_l, 0])**2 feet_l_y = (positions[1:, fid_l, 1] - positions[:-1, fid_l, 1])**2 feet_l_z = (positions[1:, fid_l, 2] - positions[:-1, fid_l, 2])**2 feet_l_h = positions[:-1, fid_l, 1] feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor) & (feet_l_h < heightfactor)).astype(np.float) feet_r_x = (positions[1:, fid_r, 0] - positions[:-1, fid_r, 0])**2 feet_r_y = (positions[1:, fid_r, 1] - positions[:-1, fid_r, 1])**2 feet_r_z = (positions[1:, fid_r, 2] - positions[:-1, fid_r, 2])**2 feet_r_h = positions[:-1, fid_r, 1] feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor) & (feet_r_h < heightfactor)).astype(np.float) """ Get Root Velocity """ velocity = (positions[1:, 0:1] - positions[:-1, 0:1]).copy() """ Remove Translation """ positions[:, :, 0] = positions[:, :, 0] - positions[:, 0:1, 0] positions[:, :, 2] = positions[:, :, 2] - positions[:, 0:1, 2] """ Get Forward Direction """ sdr_l, sdr_r, hip_l, hip_r = 14, 18, 2, 6 across1 = positions[:, hip_l] - positions[:, hip_r] across0 = positions[:, sdr_l] - positions[:, sdr_r] across = across0 + across1 across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] direction_filterwidth = 20 forward = np.cross(across, np.array([[0, 1, 0]])) forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] """ Remove Y Rotation """ target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) rotation = Quaternions.between(forward, target)[:, np.newaxis] positions = rotation * positions """ Get Root Rotation """ velocity = rotation[1:] * velocity rvelocity = Pivots.from_quaternions(rotation[1:] * -rotation[:-1]).ps """ Add Velocity, RVelocity, Foot Contacts to vector """ positions = positions[:-1] positions = positions.reshape(len(positions), -1) positions = np.concatenate([positions, velocity[:, :, 0]], axis=-1) positions = np.concatenate([positions, velocity[:, :, 2]], axis=-1) positions = np.concatenate([positions, rvelocity], axis=-1) positions = np.concatenate([positions, feet_l, feet_r], axis=-1) """ Slide over windows """ windows = [] windows_classes = [] for j in range(0, len(positions) - window // 8, window_step): """ If slice too small pad out by repeating start and end poses """ slice = positions[j:j + window] if len(slice) < window: left = slice[:1].repeat( (window - len(slice)) // 2 + (window - len(slice)) % 2, axis=0) left[:, -7:-4] = 0.0 right = slice[-1:].repeat((window - len(slice)) // 2, axis=0) right[:, -7:-4] = 0.0 slice = np.concatenate([left, slice, right], axis=0) if len(slice) != window: raise Exception() windows.append(slice) """ Find Class """ cls = -1 if filename.startswith('hdm05'): cls_name = os.path.splitext(os.path.split(filename)[1])[0][7:-8] cls = class_names.index( class_map[cls_name]) if cls_name in class_map else -1 if filename.startswith('styletransfer'): cls_name = os.path.splitext(os.path.split(filename)[1])[0] cls = np.array([ styletransfer_motions.index('_'.join( cls_name.split('_')[1:-1])), styletransfer_styles.index(cls_name.split('_')[0]) ]) windows_classes.append(cls) return windows, windows_classes
def process_file_withSpeech_face_byGroup(filename, window=240, window_step=120): if not '_p0.bvh' in filename: return ######################### ## Load Speech Data seqName = os.path.basename(filename) fileName_pkl = seqName[:-7] + '.pkl' speechPath = './panopticDB_pkl_speech_hagglingProcessed/' + fileName_pkl speechData_raw = pickle.load(open(speechPath, "rb")) ######################### ## Load Face Data faceParamDir = '/ssd/codes/pytorch_motionSynth/motionsynth_data/data/processed_panoptic/panopticDB_faceMesh_pkl_hagglingProcessed/' facePath = faceParamDir + fileName_pkl faceParamData_group = pickle.load(open(facePath, "rb")) faceParamData_group = faceParamData_group['subjects'] positions_list = list() speechData_list = list() absoluteInfo_list = list() # to go back to the absolute pos + orientation for pIdx in range(0, 3): """ Do FK """ if pIdx == 0: anim, names, frametime = BVH.load(filename) else: newFileName = filename.replace('_p0.bvh', '_p{0}.bvh'.format(pIdx)) anim, names, frametime = BVH.load(newFileName) if pIdx == 0: #_p0.bvh' in filename: speechData = speechData_raw['speechData'][0] elif pIdx == 1: #'_p1.bvh' in filename: speechData = speechData_raw['speechData'][1] elif pIdx == 2: #'_p2.bvh' in filename: speechData = speechData_raw['speechData'][2] # """ Convert to 60 fps """ # anim = anim[::2] # Origianl Human3.6 has 50 fps. So, no smapling is done """ Do FK """ global_positions = Animation.positions_global(anim) """ Remove Uneeded Joints """ positions = global_positions[:, np.array([ 0, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 16, 18, 19, 20, 22, 25, 26, 27, 29 ])] """ Put on Floor """ fid_l, fid_r = np.array([4, 5]), np.array([8, 9]) foot_heights = np.minimum(positions[:, fid_l, 1], positions[:, fid_r, 1]).min(axis=1) floor_height = softmin(foot_heights, softness=0.5, axis=0) positions[:, :, 1] -= floor_height """ Add Reference Joint """ trajectory_filterwidth = 3 reference = positions[:, 0] * np.array([1, 0, 1]) #reference = filters.gaussian_filter1d(reference, trajectory_filterwidth, axis=0, mode='nearest') positions = np.concatenate([reference[:, np.newaxis], positions], axis=1) # """ Save Initial Pos Info, not to lose global information""" abPos = positions[:, 1:2, :].copy() #(frames, 1(rootJoint), 3) """ Get Foot Contacts """ velfactor, heightfactor = np.array([0.05, 0.05]), np.array([3.0, 2.0]) feet_l_x = (positions[1:, fid_l, 0] - positions[:-1, fid_l, 0])**2 feet_l_y = (positions[1:, fid_l, 1] - positions[:-1, fid_l, 1])**2 feet_l_z = (positions[1:, fid_l, 2] - positions[:-1, fid_l, 2])**2 feet_l_h = positions[:-1, fid_l, 1] feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor) & (feet_l_h < heightfactor)).astype(np.float) feet_r_x = (positions[1:, fid_r, 0] - positions[:-1, fid_r, 0])**2 feet_r_y = (positions[1:, fid_r, 1] - positions[:-1, fid_r, 1])**2 feet_r_z = (positions[1:, fid_r, 2] - positions[:-1, fid_r, 2])**2 feet_r_h = positions[:-1, fid_r, 1] feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor) & (feet_r_h < heightfactor)).astype(np.float) """ Get Root Velocity """ velocity = (positions[1:, 0:1] - positions[:-1, 0:1]).copy() """ Remove Translation """ positions[:, :, 0] = positions[:, :, 0] - positions[:, 0:1, 0] positions[:, :, 2] = positions[:, :, 2] - positions[:, 0:1, 2] """ Get Forward Direction """ sdr_l, sdr_r, hip_l, hip_r = 14, 18, 2, 6 across1 = positions[:, hip_l] - positions[:, hip_r] across0 = positions[:, sdr_l] - positions[:, sdr_r] across = across0 + across1 across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] direction_filterwidth = 20 forward = np.cross(across, np.array([[0, 1, 0]])) #forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] """ Remove Y Rotation """ target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) rotation = Quaternions.between(forward, target)[:, np.newaxis] positions = rotation * positions #""" Save normalized -> origial rotation""" abRot = -rotation #(frames,1) Inverse to move [0,0,1] -> original Forward """ Get Root Rotation """ velocity = rotation[1:] * velocity rvelocity = Pivots.from_quaternions(rotation[1:] * -rotation[:-1]).ps """ Add Velocity, RVelocity, Foot Contacts to vector """ positions = positions[:-1] positions = positions.reshape(len(positions), -1) positions = np.concatenate([positions, velocity[:, :, 0]], axis=-1) positions = np.concatenate([positions, velocity[:, :, 2]], axis=-1) positions = np.concatenate([positions, rvelocity], axis=-1) positions = np.concatenate([positions, feet_l, feet_r], axis=-1) speechData_list.append(speechData) #Save speech info positions_list.append(positions) #Save skeleton info absoluteInfo_list.append({ 'pos': abPos, 'rot': abRot }) #Save initial trans and rot information for the first frame if len(positions_list[0]) != len(positions_list[1]): raise Exception() if len(positions_list[1]) != len(positions_list[2]): raise Exception() if len(speechData_list[0]) != len(speechData_list[1]): raise Exception() if len(speechData_list[1]) != len(speechData_list[2]): raise Exception() """ Slide over windows """ windows = [list(), list(), list()] windows_speech = [list(), list(), list()] windows_face = [list(), list(), list()] windows_abPos = [list(), list(), list()] windows_abRot = [list(), list(), list()] print("skelSize {0} vs speechSize {1}".format( positions.shape[0], speechData['indicator'].shape[0])) for j in range(0, len(positions) - window // 8, window_step): #check validity bSkip = False for pIdx in range(len(positions_list)): faceParamData = faceParamData_group[pIdx][ 'face_exp'] #200 x frames faceParamData = np.swapaxes(faceParamData, 0, 1) # frames x 200 face_slice = faceParamData[j:j + window] # faceParamData: (frames,200) #Check Bad data (abs(value)>2) maxValue = np.max(abs(face_slice)) if (maxValue > 2.0): bSkip = True break if bSkip: continue for pIdx in range(len(positions_list)): """ Face data """ faceParamData = faceParamData_group[pIdx][ 'face_exp'] #200 x frames faceParamData = np.swapaxes(faceParamData, 0, 1) # frames x 200 face_slice = faceParamData[j:j + window] # faceParamData: (frames,200) if len(face_slice) < window: break #Check Bad data (abs(value)>2) maxValue = np.max(abs(face_slice)) if (maxValue > 2.0): continue if len(face_slice) != window: raise Exception() #only save part of them face_slice = face_slice[:, :5] #Only use 5 dim for face features """ motion data""" slice = positions_list[pIdx][j:j + window] if len(slice) < window: break if len(slice) != window: raise Exception() windows_face[pIdx].append(face_slice) windows[pIdx].append(slice) """ init pos data""" #slice = absoluteInfo_list[pIdx]['pos'][j:j+window] slice = absoluteInfo_list[pIdx]['pos'][ j] #take only the first frame's windows_abPos[pIdx].append(slice) """ init rot data""" #slice = absoluteInfo_list[pIdx]['rot'][j:j+window] slice = absoluteInfo_list[pIdx]['rot'][ j] #take only the first frame's #windows_abRot[pIdx].append(slice) windows_abRot[pIdx].append(slice.qs) """ Speacking data """ cls = speechData_list[pIdx]['indicator'][j:j + window] windows_speech[pIdx].append(cls) return windows, windows_speech, windows_face, windows_abPos, windows_abRot
class NPC: # Non-player characters. People to interact with in-game that are run by the computer def __init__(self, name): self.name = name # For display purposes and for finding the right save file self.savefilename = str( self.name ) + "SaveFile.txt" # Saves general things like location, trades, and possessions self.defaultfile = "npcDefaultSave.txt" # In case the save file gets lost try: self.readSaveFile(self.savefilename) except: self.readSaveFile(self.defaultfile) self.displayImage = Animation( str(self.name) + "-" + "no-still", 1, 1 ) # "no-still" stands for facing north, view overhead, standing still. I need that image generator self.moveLeft = 0 # How much is left in the move, not how much to move in the leftwards direction self.nextMove = round(random( 300)) # To make it look like they're doing something important def readSaveFile(self, filename): file = open(filename, "r") saveData = " ".join(file.readlines()) self.attributes = json.loads(saveData) file.close() def writeSaveFile(self): newSaveFile = open(self.saveFilename, "w") newSaveFile.write(json.dumps(self.attributes)) newSaveFile.close() self.updateImage() def updateImage(self): # Like the player if self.attributes["state"] == "still": self.displayImage = Animation( self.name + "-" + self.attributes["facing"] + self.attributes["view"] + "-still", 1, 1) elif self.attributes["state"] == "mov": self.displayImage = Animation( self.name + "-" + self.attributes["facing"] + self.attributes["view"] + "-mov", 4, 10) # TODO: Make this more modular def run(self): self.display() self.nextPixel = self.findNextPxl() # For finding boundries if self.nextMove <= 0: self.setMovePoint() self.nextMove = round(random(300)) if self.moveLeft <= 0: self.attributes["state"] = "still" self.updateImage() self.nextMove -= 1 if self.moveLeft > 0: self.move() if self.nextPixel == intToRGB( -3815995): # For running into a boundry. Not yet modular if self.attributes["facing"] == "n": self.attributes["y"] += self.attributes["speed"] + 1 if self.attributes["facing"] == "s": self.attributes["y"] -= self.attributes["speed"] + 1 if self.attributes["facing"] == "e": self.attributes["x"] -= self.attributes["speed"] + 1 if self.attributes["facing"] == "w": self.attributes["x"] += self.attributes["speed"] + 1 self.moveLeft = 0 # TODO: Make this work with any color def display(self): self.displayImage.display(self.attributes["x"], self.attributes["y"], self.attributes["w"], self.attributes["h"]) def move(self): # For moving based on direction faced self.attributes["state"] = "mov" self.nextPixel = self.findNextPxl() self.pastX = self.attributes["x"] self.pastY = self.attributes["y"] if self.attributes["view"] == "o": if self.attributes["facing"] == "n": self.attributes["y"] -= self.attributes["speed"] if self.attributes["facing"] == "s": self.attributes["y"] += self.attributes["speed"] if self.attributes["facing"] == "e": self.attributes["x"] += self.attributes["speed"] if self.attributes["facing"] == "w": self.attributes["x"] -= self.attributes["speed"] self.moveLeft -= self.attributes["speed"] def setMovePoint(self): # Deciding which direction to go orientation = floor(random(3.99)) if orientation == 0: self.attributes["facing"] = "n" if orientation == 1: self.attributes["facing"] = "s" if orientation == 2: self.attributes["facing"] = "e" if orientation == 3: self.attributes["facing"] = "w" self.updateImage() self.moveLeft = random(300) def findNextPxl(self): # For finding color if self.attributes["facing"] == "n": nextPxl = get(self.attributes["x"], self.attributes["y"] - 10) fill(255, 0, 0) #ellipse(self.attributes["x"], self.attributes["y"] - 10, 10, 10) return intToRGB(nextPxl) if self.attributes["facing"] == "s": nextPxl = get(self.attributes["x"], self.attributes["y"] + 10) fill(255, 0, 0) #ellipse(self.attributes["x"], self.attributes["y"] + 10, 10, 10) return intToRGB(nextPxl) if self.attributes["facing"] == "w": nextPxl = get(self.attributes["x"] - 10, self.attributes["y"]) fill(255, 0, 0) #ellipse(self.attributes["x"] - 10, self.attributes["y"], 10, 10) return intToRGB(nextPxl) if self.attributes["facing"] == "e": nextPxl = get(self.attributes["x"] + 10, self.attributes["y"]) fill(255, 0, 0) #ellipse(self.attributes["x"] + 10, self.attributes["y"], 10, 10) return intToRGB(nextPxl)
def process_data(anim, phase, gait, type='flat'): """ Do FK """ global_xforms = Animation.transforms_global(anim) global_positions = global_xforms[:, :, :3, 3] / global_xforms[:, :, 3:, 3] # (F, J, 3) global_rotations = Quaternions.from_transforms( global_xforms) # (F, J) quats """ Extract Forward Direction """ across = ( (global_positions[:, skd.SDR_L] - global_positions[:, skd.SDR_R]) + (global_positions[:, skd.HIP_L] - global_positions[:, skd.HIP_R])) across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] """ Smooth Forward Direction """ direction_filterwidth = 20 forward = filters.gaussian_filter1d(np.cross(across, np.array([[0, 1, 0]])), direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] root_rotation = Quaternions.between( forward, np.array([[0, 0, 1]]).repeat(len(forward), axis=0))[:, np.newaxis] """ Local Space """ local_positions = global_positions.copy() local_positions[:, :, 0] = local_positions[:, :, 0] - local_positions[:, 0:1, 0] local_positions[:, :, 2] = local_positions[:, :, 2] - local_positions[:, 0:1, 2] local_positions = root_rotation[:-1] * local_positions[:-1] # (F-1, J, 3) local_velocities = root_rotation[:-1] * ( global_positions[1:] - global_positions[:-1]) # (F-1, J, 3) local_rotations = ( (root_rotation[:-1] * global_rotations[:-1])) # (F-1, J) quats #print('hips (w,x,y,z)=' + str(abs((root_rotation[:-1] * global_rotations[:-1]))[0][0])) #print('hips log(w,x,y,z)=' + str(local_rotations[0][0])) root_velocity = root_rotation[:-1] * (global_positions[1:, 0:1] - global_positions[:-1, 0:1]) root_rvelocity = Pivots.from_quaternions(root_rotation[1:] * -root_rotation[:-1]).ps """ Foot Contacts """ fid_l, fid_r = np.array(skd.FOOT_L), np.array(skd.FOOT_R) velfactor = np.array([0.02, 0.02]) feet_l_x = (global_positions[1:, fid_l, 0] - global_positions[:-1, fid_l, 0])**2 feet_l_y = (global_positions[1:, fid_l, 1] - global_positions[:-1, fid_l, 1])**2 feet_l_z = (global_positions[1:, fid_l, 2] - global_positions[:-1, fid_l, 2])**2 feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor)).astype(np.float) feet_r_x = (global_positions[1:, fid_r, 0] - global_positions[:-1, fid_r, 0])**2 feet_r_y = (global_positions[1:, fid_r, 1] - global_positions[:-1, fid_r, 1])**2 feet_r_z = (global_positions[1:, fid_r, 2] - global_positions[:-1, fid_r, 2])**2 feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor)).astype(np.float) """ Phase """ dphase = phase[1:] - phase[:-1] dphase[dphase < 0] = (1.0 - phase[:-1] + phase[1:])[dphase < 0] """ Adjust Crouching Gait Value """ if type == 'flat': crouch_low, crouch_high = 80, 130 head = skd.HEAD gait[:-1, 3] = 1 - np.clip( (global_positions[:-1, head, 1] - 80) / (130 - 80), 0, 1) gait[-1, 3] = gait[-2, 3] """ Load prev rotations across files (poles maybe adjusted) """ global prev_rotations if prev_rotations is None: prev_rotations = local_rotations[window - 1] """ Start Windows """ Pc, Xc, Yc = [], [], [] for i in range(window, len(anim) - window - 1, 1): rootposs = root_rotation[i:i + 1, 0] * ( global_positions[i - window:i + window:10, 0] - global_positions[i:i + 1, 0]) rootdirs = root_rotation[i:i + 1, 0] * forward[i - window:i + window:10] rootgait = gait[i - window:i + window:10] Pc.append(phase[i]) """ Unify Quaternions To Single Pole """ """ Between Prev vs Next Keys """ """ [Grassia1998]: The procedure followed by Yahia [13] of limiting the range of the log map to |log(r)| ≤ π does not suffice. A log mapping that does guarantee the geodesic approximation picks the mapping for each successive key that minimizes the Euclidean distance to the mapping of the previous key. Given such a log map that considers the previous mapping when calculating the current mapping, the results of interpolating in S3 and R3 may be visually indistinguishable for many applications, including keyframing. """ antipode = prev_rotations.dot(local_rotations[i]) < 0 local_rotations[i][antipode] = Quaternions( -local_rotations[i][antipode].qs) prev_rotations = local_rotations[i] # print("*********************************") # print(i) # #print(*antipode, sep=' ') # for j in range(antipode.size): # print("%6d " % (j+1), end='' if j < antipode.size-1 else '\n') # for j in range(antipode.size): # print("%6s " % antipode[j], end='' if j < antipode.size-1 else '\n') # for j in range(antipode.size): # print("%06.3f " % local_rotations[i-1][j].reals, end='' if j < antipode.size-1 else '\n') # for j in range(antipode.size): # print("%06.3f " % local_rotations[i][j].reals, end='' if j < antipode.size-1 else '\n') # print(*local_rotations[i-1][antipode], sep=' ') # print(*local_rotations[i][antipode], sep=' ') # # print("*********************************") # # print(local_rotations[i][antipode]) # # print("*********************************") Xc.append( np.hstack([ rootposs[:, 0].ravel(), rootposs[:, 2].ravel(), # Trajectory Pos rootdirs[:, 0].ravel(), rootdirs[:, 2].ravel(), # Trajectory Dir rootgait[:, 0].ravel(), rootgait[:, 1].ravel(), # Trajectory Gait rootgait[:, 2].ravel(), rootgait[:, 3].ravel(), rootgait[:, 4].ravel(), rootgait[:, 5].ravel(), local_positions[i - 1].ravel(), # Joint Pos local_velocities[i - 1].ravel(), # Joint Vel ])) rootposs_next = root_rotation[i + 1:i + 2, 0] * ( global_positions[i + 1:i + window + 1:10, 0] - global_positions[i + 1:i + 2, 0]) rootdirs_next = root_rotation[i + 1:i + 2, 0] * forward[i + 1:i + window + 1:10] Yc.append( np.hstack([ root_velocity[i, 0, 0].ravel(), # Root Vel X root_velocity[i, 0, 2].ravel(), # Root Vel Y root_rvelocity[i].ravel(), # Root Rot Vel dphase[i], # Change in Phase np.concatenate([feet_l[i], feet_r[i]], axis=-1), # Contacts rootposs_next[:, 0].ravel(), rootposs_next[:, 2].ravel(), # Next Trajectory Pos rootdirs_next[:, 0].ravel(), rootdirs_next[:, 2].ravel(), # Next Trajectory Dir local_positions[i].ravel(), # Joint Pos local_velocities[i].ravel(), # Joint Vel local_rotations[i].log().ravel() # Joint Rot ])) return np.array(Pc), np.array(Xc), np.array(Yc)
def prepare_input(anim_bvh, floor_file, contacts_file, out_dir, character, \ start_idx=None, end_idx=None, dt=(1.0 / 30.0), combined_contacts=False): ''' This prepares all data input to feed to the trajectory optimization: - skel_info.txt : hip offsets, leg length, heel distance, mass, and moments of inertia over time - motion_info.txt : COM trajectory/orientation, feet trajectory - terrain_info.txt : ground plane normal and one point on the plane - contact_info.txt : durations of contacts for toes and heels, and whether they're in contact with the ground at start ''' ''' Writes out the necessary data files passed to physics optimization ''' if not os.path.exists(anim_bvh): print('Could not find animated bvh file ' + anim_bvh) return if not os.path.exists(floor_file): print('Could not find floor file ' + floor_file) return if not os.path.exists(contacts_file): print('Could not find contacts file ' + contacts_file) return if not os.path.exists(out_dir): os.mkdir(out_dir) if start_idx is None: start_idx = 0 if end_idx is None: end_idx = anim_COM.shape[0] num_frames = end_idx - start_idx # load the actual motion, zero out the root orientation and position, and # calculate the inertia matrix for every single timestep anim, names, _ = BVH.load(anim_bvh) zero_root = np.zeros((anim.shape[0], 3)) zero_root = Quaternions.from_euler(zero_root, order='xyz', world=True) anim.rotations[:,0,:] = zero_root anim.positions[:,0,:] = np.zeros((anim.shape[0], 3)) normalized_positions = Animation.positions_global(anim) # find the leg length left_leg_chain = get_character_leg_chain(character, 'left') bone_lengths = np.linalg.norm(anim.offsets[left_leg_chain[1:]], axis=1) max_leg_length = np.sum(bone_lengths) * 0.01 # to meters # print('Max leg length (m)') # print(max_leg_length) # find COM at each frame and move the root there (since our orientations are about the root) hip_joints = get_character_hip_inds(character) map_segment_to_joints = get_character_seg_to_joint_map(character) map_segment_to_mass_perc = get_character_seg_to_mass_perc_map(character) frame_coms = [] hip_offsets = np.zeros((anim.shape[0], 2, 3)) for frame in range(anim.shape[0]): frame_COM = np.zeros(3) for key in map_segment_to_joints.keys(): seg_pos = np.mean(normalized_positions[frame, map_segment_to_joints[key], :], axis=0) frame_COM += map_segment_to_mass_perc[key] * 0.01 * seg_pos frame_coms.append(frame_COM) for j in range(len(hip_joints)): hip_offsets[frame, j] = (normalized_positions[frame, hip_joints[j]] - frame_COM) frame_coms = np.array(frame_coms) hip_offsets *= 0.01 # to meters hip_offsets[:,:,:] *= -1.0 # flip hip_offsets = hip_offsets[:,:,[0,2,1]] # swap y and z anim.positions[:,0,:] -= frame_coms # move so COM is at origin normalized_positions = Animation.positions_global(anim) * 0.01 normalized_positions[:,:,:] *= -1.0 # flip y normalized_positions = normalized_positions[:,:,[0,2,1]] # swap y and z # then calculate inertia about COM total_mass = get_character_mass(character) inertia_mats = [] for frame in range(anim.shape[0]): I_frame= np.zeros((3, 3)) for key in map_segment_to_joints.keys(): seg_pos = np.mean(normalized_positions[frame, map_segment_to_joints[key], :], axis=0) seg_mass = map_segment_to_mass_perc[key] * 0.01 * total_mass I_seg = (np.eye(3)*np.dot(seg_pos, seg_pos) - np.outer(seg_pos, seg_pos)) * seg_mass I_frame += I_seg inertia_mats.append(I_frame) toe_inds = get_character_toe_inds(character) left_toe_idx, right_toe_idx = toe_inds ankle_inds = get_character_ankle_inds(character) left_ankle_idx, right_ankle_idx = ankle_inds # animated motion # get COM trajectory, root orientation, left/right foot trajectories anim, names, _ = BVH.load(anim_bvh) # print('LEFT FOOT OFF:') # print(anim.offsets[left_toe_idx]) # print('RIGHT FOOT OFF:') # print(anim.offsets[right_toe_idx]) # append a heel to the character at the same height as foot if not character in heeled_characters: # must add a heel if doesn't already have one anim, heel_offsets = add_heel_to_anim(anim, toe_inds, ankle_inds) anim_pos = Animation.positions_global(anim) anim_pos[:,:,:] *= -1.0 # flip y anim_pos = anim_pos[:,:,[0,2,1]] # swap y and z anim_pos *= 0.01 # CONVERTED TO meters since towr uses them (and to make physically reasonable) root_pos = anim_pos[:,0,:] left_foot_pos = anim_pos[:,left_toe_idx,:] right_foot_pos = anim_pos[:, right_toe_idx,:] left_ankle_pos = anim_pos[:,left_ankle_idx,:] right_ankle_pos = anim_pos[:,right_ankle_idx,:] left_heel_idx = anim_pos.shape[1] - 2 right_heel_idx = anim_pos.shape[1] - 1 if character in heeled_characters: # already has a heel joint left_heel_idx, right_heel_idx = get_character_heel_inds(character) left_heel_pos = anim_pos[:, left_heel_idx, :] right_heel_pos = anim_pos[:, right_heel_idx, :] heel_dist = np.mean(np.linalg.norm(left_foot_pos - left_heel_pos, axis=1)) left_leg_chain = get_character_leg_chain(character, 'left') bone_lengths = np.linalg.norm(anim.offsets[left_leg_chain[1:-1]], axis=1) # only down to ankle max_heel_length = (np.sum(bone_lengths) + np.linalg.norm(anim.offsets[left_heel_idx])) * 0.01 # to meters # print('Max heel length (m)') # print(max_heel_length) skel_out_path = os.path.join(out_dir, 'skel_info.txt') with open(skel_out_path, 'w') as skel_file: # left hip offset for frame in range(start_idx, end_idx): skel_file.write(str(hip_offsets[frame, 0, 0]) + ' ' + str(hip_offsets[frame, 0, 1]) + ' ' + str(hip_offsets[frame, 0, 2]) + '\n') # right hip offset for frame in range(start_idx, end_idx): skel_file.write(str(hip_offsets[frame, 1, 0]) + ' ' + str(hip_offsets[frame, 1, 1]) + ' ' + str(hip_offsets[frame, 1, 2]) + '\n') # leg length (hip to toe) skel_file.write(str(max_leg_length) + '\n') # heel length (hip to heel) skel_file.write(str(max_heel_length) + '\n') # heel distance (from toe) skel_file.write(str(heel_dist) + '\n') # total mass skel_file.write(str(total_mass) + '\n') # Ixx, Iyy, Izz, Ixy, Ixz, Iyz for frame in range(start_idx, end_idx): I_cur = inertia_mats[frame] skel_file.write(str(I_cur[0, 0]) + ' ' + str(I_cur[1, 1]) + ' ' + str(I_cur[2, 2]) + ' ' + str(I_cur[0, 1]) + ' ' + str(I_cur[0, 2]) + ' ' + str(I_cur[1, 2]) + '\n') rot_angle, rot_axis = anim.rotations.angle_axis() rot_axis[:,:,:] *= -1.0 # flip y rot_axis = rot_axis[:, :, [0,2,1]] # swap y and z] root_rot = Quaternions.from_angle_axis(rot_angle, rot_axis).euler(order='xyz')[:,0,:] # fix root rot to be smooth for dim in range(3): cur_val = root_rot[0, dim] for frame_idx in range(1, root_rot.shape[0]): pre_mult = 1.0 if cur_val >= 0.0 else -1.0 next_val = root_rot[frame_idx, dim] while abs(next_val - cur_val) > np.pi: next_val += pre_mult * 2*np.pi root_rot[frame_idx, dim] = next_val cur_val = next_val # plot_3curve(left_foot_pos, dt, 'time(s)', 'Left foot goal pos (m)') # plot_3curve(left_heel_pos, dt, 'time(s)', 'Left heel goal pos (m)') # plot_3curve(right_foot_pos, dt, 'time(s)', 'Right foot goal pos (m)') # plot_3curve(right_heel_pos, dt, 'time(s)', 'Right heel goal pos (m)') # plot_3curve(root_rot, dt, 'time(s)', 'target euler angle') # calc COM over time anim_COM = np.zeros((anim_pos.shape[0], 3)) for i in range(anim_pos.shape[0]): cur_COM = np.zeros(3) for key in map_segment_to_joints.keys(): seg_pos = np.mean(anim_pos[i, map_segment_to_joints[key], :], axis=0) mass_frac = map_segment_to_mass_perc[key] * 0.01 cur_COM += mass_frac * seg_pos anim_COM[i] = cur_COM motion_out_path = os.path.join(out_dir, 'motion_info.txt') with open(motion_out_path, 'w') as motion_file: motion_file.write(str(dt) + '\n') # COM trajectory for i in range(start_idx, end_idx): motion_file.write(str(anim_COM[i, 0]) + ' ' + str(anim_COM[i, 1]) + ' ' + str(anim_COM[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # COM (root) orientation for i in range(start_idx, end_idx): motion_file.write(str(root_rot[i, 0]) + ' ' + str(root_rot[i, 1]) + ' ' + str(root_rot[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # left foot trajectory for i in range(start_idx, end_idx): motion_file.write(str(left_foot_pos[i, 0]) + ' ' + str(left_foot_pos[i, 1]) + ' ' + str(left_foot_pos[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # left heel trajectory for i in range(start_idx, end_idx): motion_file.write(str(left_heel_pos[i, 0]) + ' ' + str(left_heel_pos[i, 1]) + ' ' + str(left_heel_pos[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # right foot trajectory for i in range(start_idx, end_idx): motion_file.write(str(right_foot_pos[i, 0]) + ' ' + str(right_foot_pos[i, 1]) + ' ' + str(right_foot_pos[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # right heel trajectory for i in range(start_idx, end_idx): motion_file.write(str(right_heel_pos[i, 0]) + ' ' + str(right_heel_pos[i, 1]) + ' ' + str(right_heel_pos[i, 2])) if i < end_idx - 1: motion_file.write(' ') motion_file.write('\n') # floor information # already have it, just copy file floor_out_path = os.path.join(out_dir, 'terrain_info.txt') with open(floor_file, 'r') as f: normal_line = f.readline() normal_str = normal_line.split(' ') plane_normal = np.array([float(x) for x in normal_str]) # to meters point_line = f.readline().split('\n')[0] point_str = point_line.split(' ') plane_loc = np.array([float(x) for x in point_str]) * 0.01 # to meters plane_normal[:] *= -1.0 # flip y plane_normal = plane_normal[[0,2,1]] # swap y and z plane_loc[:] *= -1.0 # flip y plane_loc = plane_loc[[0,2,1]] # swap y and z with open(os.path.join(floor_out_path), 'w') as floor_file: floor_file.write(str(plane_normal[0])) floor_file.write(' ') floor_file.write(str(plane_normal[1])) floor_file.write(' ') floor_file.write(str(plane_normal[2])) floor_file.write('\n') floor_file.write(str(plane_loc[0])) floor_file.write(' ') floor_file.write(str(plane_loc[1])) floor_file.write(' ') floor_file.write(str(plane_loc[2])) foot_contacts = np.load(contacts_file) # heel = 0, toe = 1 contacts_left = foot_contacts[:,[0,1]] contacts_left = np.amax(contacts_left, axis=1) # if either are in contact contacts_right = foot_contacts[:,[2,3]] contacts_right = np.amax(contacts_right, axis=1) # if either are in contact contacts_left = contacts_left[start_idx:end_idx] contacts_right = contacts_right[start_idx:end_idx] # left toe, left heel, right toe, right heel contacts_all = foot_contacts[start_idx:end_idx,[1, 0, 3, 2]] left_toe_start_in_contact = contacts_left[0] #contacts_all[0, 0] if combined_contacts: left_toe_start_in_contact = contacts_all[0, 0] left_heel_start_in_contact = contacts_all[0, 1] right_toe_start_in_contact = contacts_right[0] #contacts_all[0, 2] if combined_contacts: right_toe_start_in_contact = contacts_all[0, 2] right_heel_start_in_contact = contacts_all[0, 3] # figure out durations if not combined_contacts: left_toe_durations = find_contact_durations(contacts_all[:,0], dt) else: left_toe_durations = find_contact_durations(contacts_left, dt) left_heel_durations = find_contact_durations(contacts_all[:,1], dt) if not combined_contacts: right_toe_durations = find_contact_durations(contacts_all[:,2], dt) else: right_toe_durations = find_contact_durations(contacts_right, dt) right_heel_durations = find_contact_durations(contacts_all[:,3], dt) contacts_out_path = os.path.join(out_dir, 'contact_info.txt') with open(contacts_out_path, 'w') as contacts_file: # left toe start in contact contacts_file.write(str(left_toe_start_in_contact) + '\n') # left toe durations contacts_file.write(str(len(left_toe_durations)) + '\n') for i in range(len(left_toe_durations)): contacts_file.write(str(left_toe_durations[i])) if i < len(left_toe_durations) - 1: contacts_file.write(' ') contacts_file.write('\n') # left heel start in contact contacts_file.write(str(left_heel_start_in_contact) + '\n') # left heel durations contacts_file.write(str(len(left_heel_durations)) + '\n') for i in range(len(left_heel_durations)): contacts_file.write(str(left_heel_durations[i])) if i < len(left_heel_durations) - 1: contacts_file.write(' ') contacts_file.write('\n') # right toe start in contact contacts_file.write(str(right_toe_start_in_contact) + '\n') # right toe durations contacts_file.write(str(len(right_toe_durations)) + '\n') for i in range(len(right_toe_durations)): contacts_file.write(str(right_toe_durations[i])) if i < len(right_toe_durations) - 1: contacts_file.write(' ') contacts_file.write('\n') # right heel start in contact contacts_file.write(str(right_heel_start_in_contact) + '\n') # right heel durations contacts_file.write(str(len(right_heel_durations)) + '\n') for i in range(len(right_heel_durations)): contacts_file.write(str(right_heel_durations[i])) if i < len(right_heel_durations) - 1: contacts_file.write(' ')
def process_heights(anim, nsamples=10, type='flat'): """ Do FK """ global_xforms = Animation.transforms_global(anim) global_positions = global_xforms[:, :, :3, 3] / global_xforms[:, :, 3:, 3] global_rotations = Quaternions.from_transforms(global_xforms) """ Extract Forward Direction """ across = ( (global_positions[:, skd.SDR_L] - global_positions[:, skd.SDR_R]) + (global_positions[:, skd.HIP_L] - global_positions[:, skd.HIP_R])) across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] """ Smooth Forward Direction """ direction_filterwidth = 20 forward = filters.gaussian_filter1d(np.cross(across, np.array([[0, 1, 0]])), direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] root_rotation = Quaternions.between( forward, np.array([[0, 0, 1]]).repeat(len(forward), axis=0))[:, np.newaxis] """ Foot Contacts """ fid_l, fid_r = np.array(skd.FOOT_L), np.array(skd.FOOT_R) velfactor = np.array([0.02, 0.02]) feet_l_x = (global_positions[1:, fid_l, 0] - global_positions[:-1, fid_l, 0])**2 feet_l_y = (global_positions[1:, fid_l, 1] - global_positions[:-1, fid_l, 1])**2 feet_l_z = (global_positions[1:, fid_l, 2] - global_positions[:-1, fid_l, 2])**2 feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor)) feet_r_x = (global_positions[1:, fid_r, 0] - global_positions[:-1, fid_r, 0])**2 feet_r_y = (global_positions[1:, fid_r, 1] - global_positions[:-1, fid_r, 1])**2 feet_r_z = (global_positions[1:, fid_r, 2] - global_positions[:-1, fid_r, 2])**2 feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor)) feet_l = np.concatenate([feet_l, feet_l[-1:]], axis=0) feet_r = np.concatenate([feet_r, feet_r[-1:]], axis=0) """ Toe and Heel Heights """ toe_h, heel_h = 4.0, 5.0 """ Foot Down Positions """ feet_down = np.concatenate([ global_positions[feet_l[:, 0], fid_l[0]] - np.array([0, heel_h, 0]), global_positions[feet_l[:, 1], fid_l[1]] - np.array([0, toe_h, 0]), global_positions[feet_r[:, 0], fid_r[0]] - np.array([0, heel_h, 0]), global_positions[feet_r[:, 1], fid_r[1]] - np.array([0, toe_h, 0]) ], axis=0) """ Foot Up Positions """ feet_up = np.concatenate([ global_positions[~feet_l[:, 0], fid_l[0]] - np.array([0, heel_h, 0]), global_positions[~feet_l[:, 1], fid_l[1]] - np.array([0, toe_h, 0]), global_positions[~feet_r[:, 0], fid_r[0]] - np.array([0, heel_h, 0]), global_positions[~feet_r[:, 1], fid_r[1]] - np.array([0, toe_h, 0]) ], axis=0) """ Down Locations """ feet_down_xz = np.concatenate([feet_down[:, 0:1], feet_down[:, 2:3]], axis=-1) feet_down_xz_mean = feet_down_xz.mean(axis=0) feet_down_y = feet_down[:, 1:2] feet_down_y_mean = feet_down_y.mean(axis=0) feet_down_y_std = feet_down_y.std(axis=0) """ Up Locations """ feet_up_xz = np.concatenate([feet_up[:, 0:1], feet_up[:, 2:3]], axis=-1) feet_up_y = feet_up[:, 1:2] if len(feet_down_xz) == 0: """ No Contacts """ terr_func = lambda Xp: np.zeros_like(Xp)[:, :1][np.newaxis].repeat( nsamples, axis=0) elif type == 'flat': """ Flat """ terr_func = lambda Xp: np.zeros_like(Xp)[:, :1][np.newaxis].repeat( nsamples, axis=0) + feet_down_y_mean else: """ Terrain Heights """ terr_down_y = patchfunc(patches, feet_down_xz - feet_down_xz_mean) terr_down_y_mean = terr_down_y.mean(axis=1) terr_down_y_std = terr_down_y.std(axis=1) terr_up_y = patchfunc(patches, feet_up_xz - feet_down_xz_mean) """ Fitting Error """ terr_down_err = 0.1 * ( ((terr_down_y - terr_down_y_mean[:, np.newaxis]) - (feet_down_y - feet_down_y_mean)[np.newaxis])**2)[..., 0].mean(axis=1) terr_up_err = (np.maximum( (terr_up_y - terr_down_y_mean[:, np.newaxis]) - (feet_up_y - feet_down_y_mean)[np.newaxis], 0.0)**2)[..., 0].mean(axis=1) """ Jumping Error """ if type == 'jumpy': terr_over_minh = 5.0 terr_over_err = (np.maximum( ((feet_up_y - feet_down_y_mean)[np.newaxis] - terr_over_minh) - (terr_up_y - terr_down_y_mean[:, np.newaxis]), 0.0)**2)[..., 0].mean(axis=1) else: terr_over_err = 0.0 """ Fitting Terrain to Walking on Beam """ if type == 'beam': beam_samples = 1 beam_min_height = 40.0 beam_c = global_positions[:, 0] beam_c_xz = np.concatenate([beam_c[:, 0:1], beam_c[:, 2:3]], axis=-1) beam_c_y = patchfunc(patches, beam_c_xz - feet_down_xz_mean) beam_o = (beam_c.repeat(beam_samples, axis=0) + np.array([50, 0, 50]) * rng.normal(size=(len(beam_c) * beam_samples, 3))) beam_o_xz = np.concatenate([beam_o[:, 0:1], beam_o[:, 2:3]], axis=-1) beam_o_y = patchfunc(patches, beam_o_xz - feet_down_xz_mean) beam_pdist = np.sqrt(((beam_o[:, np.newaxis] - beam_c[np.newaxis, :])**2).sum(axis=-1)) beam_far = (beam_pdist > 15).all(axis=1) terr_beam_err = (np.maximum( beam_o_y[:, beam_far] - (beam_c_y.repeat(beam_samples, axis=1)[:, beam_far] - beam_min_height), 0.0)**2)[..., 0].mean(axis=1) else: terr_beam_err = 0.0 """ Final Fitting Error """ terr = terr_down_err + terr_up_err + terr_over_err + terr_beam_err """ Best Fitting Terrains """ terr_ids = np.argsort(terr)[:nsamples] terr_patches = patches[terr_ids] terr_basic_func = lambda Xp: ( (patchfunc(terr_patches, Xp - feet_down_xz_mean) - terr_down_y_mean[terr_ids][:, np.newaxis]) + feet_down_y_mean) """ Terrain Fit Editing """ terr_residuals = feet_down_y - terr_basic_func(feet_down_xz) terr_fine_func = [ RBF(smooth=0.1, function='linear', epsilon=1e-10) for _ in range(nsamples) ] for i in range(nsamples): terr_fine_func[i].fit(feet_down_xz, terr_residuals[i]) terr_func = lambda Xp: (terr_basic_func(Xp) + np.array( [ff(Xp) for ff in terr_fine_func])) """ Get Trajectory Terrain Heights """ root_offsets_c = global_positions[:, 0] root_offsets_r = (-root_rotation[:, 0] * np.array([[+25, 0, 0]])) + root_offsets_c root_offsets_l = (-root_rotation[:, 0] * np.array([[-25, 0, 0]])) + root_offsets_c root_heights_c = terr_func(root_offsets_c[:, np.array([0, 2])])[..., 0] root_heights_r = terr_func(root_offsets_r[:, np.array([0, 2])])[..., 0] root_heights_l = terr_func(root_offsets_l[:, np.array([0, 2])])[..., 0] """ Find Trajectory Heights at each Window """ root_terrains = [] root_averages = [] for i in range(window, len(anim) - window, 1): root_terrains.append( np.concatenate([ root_heights_r[:, i - window:i + window:10], root_heights_c[:, i - window:i + window:10], root_heights_l[:, i - window:i + window:10] ], axis=1)) root_averages.append(root_heights_c[:, i - window:i + window:10].mean(axis=1)) root_terrains = np.swapaxes(np.array(root_terrains), 0, 1) root_averages = np.swapaxes(np.array(root_averages), 0, 1) return root_terrains, root_averages
def viz_results(towr_results, skeletons, start_idx, end_idx, floor_normal=None, floor_point=None, flip_floor=True, interval=33.33, save_path=None, draw_trace=True, draw_forces=True, draw_towr=True, draw_skel=True, fps=30, draw_floor=True, flip_anim=[1], show=True, names=[]): fig = plt.figure(figsize=(12,8)) ax = fig.add_subplot(111, projection='3d') offset = np.array([[2.0, 0.0, 0.0]]) # in meters for extra_res_idx in range(1, len(towr_results)): res_copy = TowrResults() res_copy.copy_from(towr_results[extra_res_idx]) # then apply our offset res_copy.base_pos += offset * extra_res_idx for foot_idx in range(res_copy.num_feet): res_copy.feet_pos[:, foot_idx] += offset * extra_res_idx towr_results[extra_res_idx] = res_copy contacts = [res.feet_contact for res in towr_results] body_pos = [Animation.positions_global(skeleton) * 0.01 for skeleton in skeletons] # to meters for jnt_idx in flip_anim: for cur_body_pos in body_pos: cur_body_pos[:, :, jnt_idx] *= -1.0 # offset body positions too for extra_res_idx in range(1, len(skeletons)): body_pos[extra_res_idx] += offset * extra_res_idx base_pos = [res.base_pos for res in towr_results] maxes = np.amax(np.concatenate(base_pos, axis=0), axis=0) mins = np.amin(np.concatenate(base_pos, axis=0), axis=0) move_rad = (np.amax(np.abs(maxes - mins) / 2.0) + 1.0) / 1.5 mov_avg = (maxes + mins) / 2.0 ax.set_xlim3d(mov_avg[0] - move_rad, mov_avg[0] + move_rad) ax.set_zlim3d(mov_avg[1] - move_rad, mov_avg[1] + move_rad) ax.set_ylim3d(mov_avg[2] - move_rad, mov_avg[2] + move_rad) ax.set_xlabel('x') ax.set_ylabel('z') plt.axis('off') plt.grid(b=None) ax.azim = -127.15384 ax.elev = 15.35064 if draw_floor and floor_normal is not None and floor_point is not None: draw_floor = True else: draw_floor = False skel_color = ['r', 'purple', 'blue', 'green'] base_color = 'orange' feet_color = ['g', 'b', 'pink', 'purple'] forces_color = 'r' robot_color = 'yellow' if not names is None and len(names) == len(towr_results): text_offset = np.array([0.0, 1.3, 0.0]) for res_idx in range(len(towr_results)): text_pos = np.mean(towr_results[res_idx].base_pos, axis=0) + text_offset ax.text(text_pos[0], text_pos[2], text_pos[1], names[res_idx], color=skel_color[res_idx]) if draw_trace: for cur_towr_result in towr_results: for i in range(cur_towr_result.base_pos.shape[0] - 1): from_pt = cur_towr_result.base_pos[i, :] to_pt = cur_towr_result.base_pos[i+1, :] plt.plot([from_pt[0], to_pt[0]], [from_pt[2], to_pt[2]], [from_pt[1], to_pt[1]], lw=3, color=base_color, linestyle='dashed') for j in range(cur_towr_result.feet_pos.shape[1]): from_pt = cur_towr_result.feet_pos[i, j, :] to_pt = cur_towr_result.feet_pos[i+1, j, :] plt.plot([from_pt[0], to_pt[0]], [from_pt[2], to_pt[2]], [from_pt[1], to_pt[1]], lw=3, color=feet_color[j], linestyle='dashed') if draw_floor: floor_center_xz = mov_avg[[0, 2]] floor_center_y = eval_plane(floor_normal, floor_point, floor_center_xz) floor_cent = np.array([floor_center_xz[0], floor_center_y, floor_center_xz[1]]) tan1_xz = floor_center_xz + np.array([-10.0, 0.0]) tan1_y = eval_plane(floor_normal, floor_point, tan1_xz) tan2_xz = floor_center_xz + np.array([0.0, 10.0]) tan2_y = eval_plane(floor_normal, floor_point, tan2_xz) tan1 = np.array([tan1_xz[0], tan1_y, tan1_xz[1]]) - floor_cent tan1 /= np.linalg.norm(tan1) tan2 = np.array([tan2_xz[0], tan2_y, tan2_xz[1]]) - floor_cent tan2 /= np.linalg.norm(tan2) tile_width = 0.5 tile_diam = 20 tile_rad = tile_diam // 2 start_pt = floor_cent + tile_rad*tile_width*tan1 + tile_rad*tile_width*tan2 for i in range(tile_diam): for j in range(tile_diam): line1_start = start_pt - i*tile_width*tan1 - j*tile_width*tan2 line1_end = (start_pt - tile_width*tan1) - i*tile_width*tan1 - j*tile_width*tan2 if flip_floor: premult = -1.0 else: premult=1.0 plt.plot([line1_start[0],line1_end[0]], [line1_start[2],line1_end[2]], [premult*line1_start[1],premult*line1_end[1]], color='grey', lw=2, path_effects=[pe.Stroke(linewidth=1, foreground='black'), pe.Normal()]) line2_start = line1_end line2_end = line1_end - tile_width*tan2 plt.plot([line2_start[0],line2_end[0]], [line2_start[2],line2_end[2]], [premult*line2_start[1],premult*line2_end[1]], color='grey', lw=2, path_effects=[pe.Stroke(linewidth=1, foreground='black'), pe.Normal()]) if j == tile_diam - 1: line3_start = line2_end line3_end = line2_end + tile_width*tan1 plt.plot([line3_start[0],line3_end[0]], [line3_start[2],line3_end[2]], [premult*line3_start[1],premult*line3_end[1]], color='grey', lw=2, path_effects=[pe.Stroke(linewidth=1, foreground='black'), pe.Normal()]) if i == 0: line3_end = line2_end + tile_width*tan1 line4_start = line3_end line4_end = line3_end + tile_width*tan2 plt.plot([line4_start[0],line4_end[0]], [line4_start[2],line4_end[2]], [premult*line4_start[1],premult*line4_end[1]], color='grey', lw=2, path_effects=[pe.Stroke(linewidth=1, foreground='black'), pe.Normal()]) if draw_towr: base_joints = [plt.plot([0] ,[0], [0], 'o', color=base_color, markersize=10.0)[0] for i in range(len(towr_results))] all_joints = [] bone_lines = [] if draw_skel: for skel_idx in range(len(skeletons)): cur_all_joints = [] cur_bone_lines = [] for i in range(body_pos[skel_idx].shape[1]): cur_all_joints.append(plt.plot([0] ,[0], [0], 'o', color=skel_color[skel_idx])[0]) all_joints.append(cur_all_joints) for i in range(body_pos[skel_idx].shape[1] - 1): cur_bone_lines.append(plt.plot([0,0], [0,0], [0,0], color=skel_color[skel_idx], lw=3, path_effects=[pe.Stroke(linewidth=3, foreground='black'), pe.Normal()])[0]) bone_lines.append(cur_bone_lines) feet_joints = [] hip_joints = [] legs = [] forces = [] robot_lines = [] for res_idx in range(len(towr_results)): cur_feet_joints = [] cur_legs = [] cur_forces = [] for i in range(towr_results[res_idx].num_feet): if draw_towr: cur_feet_joints.append(plt.plot([0] ,[0], [0], 'o', color=feet_color[i], markersize=10.0)[0]) cur_legs.append(plt.plot([0,0], [0,0], [0,0], color=feet_color[i], lw=3, path_effects=[pe.Stroke(linewidth=3, foreground='black'), pe.Normal()])[0]) if draw_forces: cur_forces.append(plt.plot([0,0], [0,0], [0,0], color=forces_color, lw=1, path_effects=[pe.Stroke(linewidth=3), pe.Normal()])[0]) feet_joints.append(cur_feet_joints) legs.append(cur_legs) forces.append(cur_forces) if draw_towr: cur_robot_lines = [] robot_verts = np.array([[0.0, 0.0, 0.0], [0.0, -0.25, 0.0], [0.05, -0.2, 0.0], [-0.05, -0.2, 0.0], [0.0, -0.25, 0.0]]) for i in range(robot_verts.shape[0] - 1): cur_robot_lines.append(plt.plot([0,0], [0,0], [0,0], color=robot_color, lw=3, path_effects=[pe.Stroke(linewidth=3, foreground='black'), pe.Normal()])[0]) robot_lines.append(cur_robot_lines) animate_forces = [res.feet_force*0.001 for res in towr_results] def animate(i): # print('azim: ' + str(ax.azim)) # print('elev: ' + str(ax.elev)) # print('dist: ' + str(ax.dist)) changed = [] if draw_towr: for res_idx in range(len(towr_results)): base_joints[res_idx].set_data([towr_results[res_idx].base_pos[i, 0]], [towr_results[res_idx].base_pos[i, 2]]) base_joints[res_idx].set_3d_properties([towr_results[res_idx].base_pos[i, 1]]) cur_robot_joints = np.dot(towr_results[res_idx].base_R[i], robot_verts.T).T + np.expand_dims(towr_results[res_idx].base_pos[i], axis=0) for j in range(len(robot_lines[res_idx])): robot_lines[res_idx][j].set_data( [ cur_robot_joints[j, 0], cur_robot_joints[j+1, 0]], [cur_robot_joints[j, 2], cur_robot_joints[j+1, 2]]) robot_lines[res_idx][j].set_3d_properties( [ cur_robot_joints[j, 1], cur_robot_joints[j+1, 1]]) if draw_skel: for skel_idx in range(len(skeletons)): for j in range(body_pos[skel_idx].shape[1]): cur_all_joint = body_pos[skel_idx][i, j] all_joints[skel_idx][j].set_data([cur_all_joint[0]], [cur_all_joint[2]]) all_joints[skel_idx][j].set_3d_properties([cur_all_joint[1]]) for j in range(1, body_pos[skel_idx].shape[1]): cur_all_joint = body_pos[skel_idx][i, j] cur_par_joint = body_pos[skel_idx][i, skeletons[skel_idx].parents[j]] bone_lines[skel_idx][j-1].set_data( [ cur_all_joint[0], cur_par_joint[0]], [cur_all_joint[2], cur_par_joint[2]]) bone_lines[skel_idx][j-1].set_3d_properties( [ cur_all_joint[1], cur_par_joint[1]]) if draw_towr: for res_idx in range(len(towr_results)): for j in range(towr_results[res_idx].num_feet): feet_joints[res_idx][j].set_data([towr_results[res_idx].feet_pos[i, j, 0]], [towr_results[res_idx].feet_pos[i, j, 2]]) feet_joints[res_idx][j].set_3d_properties([towr_results[res_idx].feet_pos[i, j, 1]]) if contacts[res_idx] is not None and contacts[res_idx][i, j]: feet_joints[res_idx][j].set_color(forces_color) else: feet_joints[res_idx][j].set_color(feet_color[j]) legs[res_idx][j].set_data( [ towr_results[res_idx].base_pos[i, 0], towr_results[res_idx].feet_pos[i, j, 0]], [towr_results[res_idx].base_pos[i, 2], towr_results[res_idx].feet_pos[i, j, 2]]) legs[res_idx][j].set_3d_properties( [ towr_results[res_idx].base_pos[i, 1], towr_results[res_idx].feet_pos[i, j, 1]]) if draw_forces: for res_idx in range(len(towr_results)): for j in range(towr_results[res_idx].num_feet): forces[res_idx][j].set_data( [ towr_results[res_idx].feet_pos[i, j, 0] - animate_forces[res_idx][i, j, 0], towr_results[res_idx].feet_pos[i, j, 0]], [towr_results[res_idx].feet_pos[i, j, 2] - animate_forces[res_idx][i, j, 2], towr_results[res_idx].feet_pos[i, j, 2]]) forces[res_idx][j].set_3d_properties( [towr_results[res_idx].feet_pos[i, j, 1] - animate_forces[res_idx][i, j, 1], towr_results[res_idx].feet_pos[i, j, 1]]) changed = legs return changed plt.tight_layout() ani = animation.FuncAnimation(fig, animate, np.arange(towr_results[0].base_pos.shape[0]), interval=interval) if save_path != None: Writer = animation.writers['ffmpeg'] writer = Writer(fps=fps, metadata=dict(artist='Me'), bitrate=1800) ani.save(save_path, writer=writer) if show: plt.show()
def __call__(self, descendants=None, maxjoints=4, gamma=1.0, transpose=False): """ Calculate Masses """ if self.weights is None: self.weights = np.ones(self.animation.shape[1]) if self.weights_translate is None: self.weights_translate = np.ones(self.animation.shape[1]) nf = len(self.animation) nj = self.animation.shape[1] nv = self.goal.shape[1] weightids = np.argsort(-self.vweights, axis=1)[:, :maxjoints] weightvls = np.array( list(map(lambda w, i: w[i], self.vweights, weightids))) weightvls = weightvls / weightvls.sum(axis=1)[..., np.newaxis] if descendants is None: self.descendants = AnimationStructure.descendants_mask( self.animation.parents) else: self.descendants = descendants des_r = np.eye(nj) + self.descendants des_r = des_r[:, weightids].repeat(3, axis=0) des_t = np.eye(nj) + self.descendants des_t = des_t[:, weightids].repeat(3, axis=0) if not self.silent: curr = Animation.skin(self.animation, self.rest, self.vweights, self.mesh, maxjoints=maxjoints) error = np.mean(np.sqrt(np.sum((curr - self.goal)**2.0, axis=-1))) print('[ICP] Start | Error: %f' % error) for i in range(self.iterations): """ Get Global Rotations & Positions """ gt = Animation.transforms_global(self.animation) gp = gt[:, :, :, 3] gp = gp[:, :, :3] / gp[:, :, 3, np.newaxis] gr = Quaternions.from_transforms(gt) x = self.animation.rotations.euler().reshape(nf, -1) w = self.weights.repeat(3) if self.translate: x = np.hstack([x, self.animation.positions.reshape(nf, -1)]) w = np.hstack([w, self.weights_translate.repeat(3)]) """ Get Current State """ curr = Animation.skin(self.animation, self.rest, self.vweights, self.mesh, maxjoints=maxjoints) """ Find Cloest Points """ if self.find_closest: mapping = np.argmin((curr[:, :, np.newaxis] - self.goal[:, np.newaxis, :])**2.0, axis=2) e = gamma * (np.array( list(map(lambda g, m: g[m], self.goal, mapping))) - curr).reshape(nf, -1) else: e = gamma * (self.goal - curr).reshape(nf, -1) """ Generate Jacobian """ if self.recalculate or i == 0: j = self.jacobian(x, gp, gr, self.goal, weightvls, des_r, des_t) """ Update Variables """ l = self.damping * (1.0 / (w + 1e-10)) d = (l * l) * np.eye(x.shape[1]) if transpose: x += np.array(list(map(lambda jf, ef: jf.T.dot(ef), j, e))) else: x += np.array( list( map( lambda jf, ef: linalg.lu_solve( linalg.lu_factor(jf.T.dot(jf) + d), jf.T.dot( ef)), j, e))) """ Set Back Rotations / Translations """ self.animation.rotations = Quaternions.from_euler( x[:, :nj * 3].reshape((nf, nj, 3)), order='xyz', world=True) if self.translate: self.animation.positions = x[:, nj * 3:].reshape((nf, nj, 3)) if not self.silent: curr = Animation.skin(self.animation, self.rest, self.vweights, self.mesh) error = np.mean( np.sqrt(np.sum((curr - self.goal)**2.0, axis=-1))) print('[ICP] Iteration %i | Error: %f' % (i + 1, error))
(position2[2] - position1[2])**2) return distance def treshold_check(distance1, distance2): activate = False if distance1 <= treshold_value and distance2 <= treshold_value: activate = True return activate file_object = open(file_path + file_name + "_footsteps.txt", 'w') anim, names, frametime = BVH.load(file_path + file_name + ".bvh") frames_number = len(anim) global_positions = Animation.positions_global(anim) left_foot_id = 0 left_toe_id = 0 right_foot_id = 0 right_toe_id = 0 for i in range(0, len(names)): if names[i] == "LeftFoot": left_foot_id = i if names[i] == "LeftToeBase": left_toe_id = i if names[i] == "RightFoot": right_foot_id = i if names[i] == "RightToeBase":
def __init__(self): super(LookComponent, self).__init__() # Initialize all Animation objects: self.animations = {} self.animations["stand_right"] = Animation( split_tiled_image( pygame.image.load(j_path( "images", "ANI_Wario_stand_r.png")).convert_alpha(), (20, 29)), [(0, 250), (1, 100), (2, 5), (1, 20), (2, 10), (1, 100)]) self.animations["stand_left"] = self.animations[ "stand_right"].make_x_mirror() self.animations["walk_right"] = Animation( split_tiled_image( pygame.image.load(j_path( "images", "ANI_Wario_walk_r.png")).convert_alpha(), (24, 29)), 5) self.animations["walk_left"] = self.animations[ "walk_right"].make_x_mirror() self.animations["jump_right"] = Animation([ pygame.image.load(j_path("images", "ANI_Wario_jump_r.png")).convert_alpha() ], 1) self.animations["jump_left"] = self.animations[ "jump_right"].make_x_mirror() # Load images for the next couple of animations: gotosleep_imgs = split_tiled_image( pygame.image.load(j_path( "images", "ANI_Wario_gotosleep_r.png")).convert_alpha(), (28, 30)) self.animations["gotosleep_right"] = Animation(gotosleep_imgs, [(0, 15), (1, 15), (2, 15), (3, 15), (4, 15)]) self.animations["gotosleep_left"] = self.animations[ "gotosleep_right"].make_x_mirror() self.animations["sleep_right"] = Animation(gotosleep_imgs, [(4, 30), (5, 20), (6, 100), (5, 20)]) self.animations["sleep_left"] = self.animations[ "sleep_right"].make_x_mirror() self.animations["wakeup_right"] = Animation(gotosleep_imgs, [(4, 25), (3, 25), (2, 25), (1, 25), (0, 25)]) self.animations["wakeup_left"] = self.animations[ "wakeup_right"].make_x_mirror() turn_around_img = split_tiled_image( pygame.image.load(j_path("images", "ANI_Wario_turn.png")).convert_alpha(), (28, 29), (225, 0, 225)) self.animations["turn_left"] = Animation(turn_around_img, [(3, 4), (2, 4), (1, 4)]) self.animations["turn_right"] = Animation(turn_around_img, [(1, 4), (2, 4), (3, 4)]) fist_img = split_tiled_image( pygame.image.load(j_path( "images", "ANI_Wario_softfist_l.png")).convert_alpha(), (32, 30)) self.animations["fist_left"] = Animation(fist_img, 3) self.animations["fist_right"] = self.animations[ "fist_left"].make_x_mirror() # Save the current animation self.current_animation = self.animations["stand_right"] # Save the last animation to check if a new animation has started: self.current_animation_name = "stand_right" # Play the current animation self.current_animation.play()
def readAnimation(self, name, root, skeletonData): if not skeletonData: raise Exception('skeletonData cannot be null.') timelines = [] duration = 0.0 bones = root.get('bones', {}) for boneName in bones.keys(): boneIndex = skeletonData.findBoneIndex(boneName) if boneIndex == -1: raise Exception('Bone not found: %s' % boneName) timelineMap = bones[boneName] for timelineName in timelineMap.keys(): values = timelineMap[timelineName] if timelineName == 'rotate': timeline = Animation.Timeline.RotateTimeline(len(values)) timeline.boneIndex = boneIndex keyframeIndex = 0 for valueMap in values: time = valueMap['time'] timeline.setKeyframe(keyframeIndex, time, valueMap['angle']) timeline = readCurve(timeline, keyframeIndex, valueMap) keyframeIndex += 1 timelines.append(timeline) if timeline.getDuration() > duration: duration = timeline.getDuration() elif timelineName == 'translate' or timelineName == 'scale': timeline = None timelineScale = 1.0 if timelineName == 'scale': timeline = Animation.Timeline.ScaleTimeline( len(values)) else: timeline = Animation.Timeline.TranslateTimeline( len(values)) timelineScale = self.scale timeline.boneIndex = boneIndex keyframeIndex = 0 for valueMap in values: time = valueMap['time'] timeline.setKeyframe(keyframeIndex, valueMap['time'], valueMap.get('x', 0.0), valueMap.get('y', 0.0)) timeline = readCurve(timeline, keyframeIndex, valueMap) keyframeIndex += 1 timelines.append(timeline) if timeline.getDuration() > duration: duration = timeline.getDuration() else: raise Exception( 'Invalid timeline type for a bone: %s (%s)' % (timelineName, boneName)) slots = root.get('slots', {}) for slotName in slots.keys(): slotIndex = skeletonData.findSlotIndex(slotName) if slotIndex == -1: raise Exception('Slot not found: %s' % slotName) timelineMap = slots[slotName] for timelineName in timelineMap.keys(): values = timelineMap[timelineName] if timelineName == 'color': timeline = Animation.Timeline.ColorTimeline(len(values)) timeline.slotIndex = slotIndex keyframeIndex = 0 for valueMap in values: timeline.setKeyframe(keyframeIndex, valueMap['time'], int(valueMap['color'][0:2], 16), int(valueMap['color'][2:4], 16), int(valueMap['color'][4:6], 16), int(valueMap['color'][6:8], 16)) timeline = readCurve(timeline, keyframeIndex, valueMap) keyframeIndex += 1 timelines.append(timeline) if timeline.getDuration > duration: duration = timeline.getDuration() elif timelineName == 'attachment': timeline = Animation.Timeline.AttachmentTimeline( len(values)) timeline.slotIndex = slotIndex keyframeIndex = 0 for valueMap in values: valueName = valueMap['name'] timeline.setKeyframe( keyframeIndex, valueMap['time'], '' if not valueName else valueName) keyframeIndex += 1 timelines.append(timeline) if timeline.getDuration > duration: duration = timeline.getDuration() else: raise Exception( 'Invalid timeline type for a slot: %s (%s)' % (timelineName, slotName)) animation = Animation.Animation(name, timelines, duration) return animation
def Event_re ( **args ): """ 새롭게 다시 만든 이벤트입니다. 매개변수를 사전형으로 받아 드리립니다. 따라서 여러가지 인수를 추가적으로 여기서 기역할 필요 없음""" print( " Start , MainFrame.enable = ",engine.Main_Frame.enable ) try: id = args["id"] Object = args["Object"] except: id = args["id"] print("----Event_re") if id == "Button":# 클릭시 파란색 이팩트 print(Object) #Object.c = Color.Color.c4 Color.ColorChanger ( engine ,engine.root , Object.c , Color.Color.c4, Object , 3 ) Event_re ( id = "DrawAll" ) elif id == "ButtonRelease":# 원래 색으로 돌아옴 Color.ColorChanger ( engine ,engine.root , Object.c , Object.GetOrigenColor() , Object , 10 ) Event_re ( id = "DrawMainFrame" ) elif id == "DrawMainFrame": engine.Main_Frame.Draw( g ) elif id == "ButtonLock": if engine.Main_Frame.enable == True: engine.Main_Frame.Enable( False ) else: engine.Main_Frame.Enable( True ) elif id[0:8] == "ClickBox": if id == "ClickBox": engine.ThreadStart () if args["Object"].id[0:2] == engine.View_Frame.날자범위.id[0:2]: if args["Object"].id == engine.View_Frame.날자범위.id: engine.View_Frame.날자.text.FontSize ( int( engine.View_Frame.날자.text.FontSize() ) - 5 ) engine.View_Frame.날자글.text.FontSize ( int( engine.View_Frame.날자글.text.FontSize() ) - 5 ) elif args["Object"].id == engine.View_Frame.금액범위.id: engine.View_Frame.금액.text.FontSize ( int ( engine.View_Frame.금액.text.FontSize() ) - 5 ) engine.View_Frame.금액글.text.FontSize(int ( engine.View_Frame.금액글.text.FontSize () ) -5 ) elif args["Object"].id == engine.View_Frame.태그범위.id: engine.View_Frame.태그.text.FontSize ( int ( engine.View_Frame.태그.text.FontSize () ) - 5 ) engine.View_Frame.태그글.text.FontSize(int( engine.View_Frame.태그글.text.FontSize()) - 5 ) elif args["Object"].id == engine.View_Frame.내용범위.id: engine.View_Frame.내용.text.FontSize ( int ( engine.View_Frame.내용.text.FontSize () ) - 5 ) engine.View_Frame.내용글.text.FontSize(int ( engine.View_Frame.내용글.text.FontSize())- 5 ) else: if args["Object"].id == engine.Plus_Frame.날자범위.id: engine.Plus_Frame.날자.text.FontSize ( int ( engine.Plus_Frame.날자.text.FontSize () ) - 5 ) engine.Plus_Frame.날자글.text.FontSize(int( engine.Plus_Frame.날자글.text.FontSize()) - 5 ) elif args["Object"].id == engine.Plus_Frame.금액범위.id : engine.Plus_Frame.금액.text.FontSize ( int ( engine.Plus_Frame.금액.text.FontSize() ) - 5 ) engine.Plus_Frame.금액글.text.FontSize(int( engine.Plus_Frame.금액글.text.FontSize())- 5 ) elif args["Object"].id == engine.Plus_Frame.태그범위.id: engine.Plus_Frame.태그.text.FontSize ( int ( engine.Plus_Frame.태그.text.FontSize () ) - 5 ) engine.Plus_Frame.태그글.text.FontSize(int ( engine.Plus_Frame.태그글.text.FontSize())- 5 ) elif args["Object"].id == engine.Plus_Frame.내용범위.id: engine.Plus_Frame.내용.text.FontSize ( int ( engine.Plus_Frame.내용.text.FontSize () ) - 5 ) engine.Plus_Frame.내용글.text.FontSize(int( engine.Plus_Frame.내용글.text.FontSize()) - 5 ) else: if args["Object"].id[0:2] == engine.View_Frame.날자범위.id[0:2]: if args["Object"].id == engine.View_Frame.날자범위.id: Animation.FontSize ( engine.View_Frame.날자 , engine, 5 , int ( engine.View_Frame.날자.text.FontSize() ) , int ( engine.View_Frame.날자.text.FontSize ( ) ) + 5 ) Animation.FontSize ( engine.View_Frame.날자글 , engine, 5 , int ( engine.View_Frame.날자글.text.FontSize() ) , int ( engine.View_Frame.날자글.text.FontSize ( ) ) + 5 ) elif args["Object"].id == engine.View_Frame.금액범위.id: Animation.FontSize ( engine.View_Frame.금액 , engine, 5 , int ( engine.View_Frame.금액.text.FontSize () ) , int ( engine.View_Frame.금액.text.FontSize ( ) ) + 5 ) Animation.FontSize ( engine.View_Frame.금액글, engine,5, int ( engine.View_Frame.금액글.text.FontSize()) , int ( engine.View_Frame.금액글.text.FontSize()) + 5 ) elif args["Object"].id == engine.View_Frame.태그범위.id: Animation.FontSize ( engine.View_Frame.태그 , engine , 5 , int ( engine.View_Frame.태그.text.FontSize ( ) ) , int ( engine.View_Frame.태그.text.FontSize() ) + 5) Animation.FontSize ( engine.View_Frame.태그글,engine , 5, int ( engine.View_Frame.태그글.text.FontSize() ) , int ( engine.View_Frame.태그글.text.FontSize())+ 5) elif args["Object"].id == engine.View_Frame.내용범위.id: Animation.FontSize ( engine.View_Frame.내용 , engine , 5 , int ( engine.View_Frame.내용.text.FontSize () ) , int ( engine.View_Frame.내용.text.FontSize ( ) ) + 5 ) Animation.FontSize ( engine.View_Frame.내용글,engine , 5 , int ( engine.View_Frame.내용글.text.FontSize()),int ( engine.View_Frame.내용글.text.FontSize() ) + 5 ) else: if args["Object"].id == engine.Plus_Frame.날자범위.id: Animation.FontSize ( engine.Plus_Frame.날자 , engine , 5 , int ( engine.Plus_Frame.날자.text.FontSize ( ) ) , int ( engine.Plus_Frame.날자.text.FontSize ( ) ) + 5 ) Animation.FontSize ( engine.Plus_Frame.날자글 , engine,5, int ( engine.Plus_Frame.날자글.text.FontSize()) , int ( engine.Plus_Frame.날자글.text.FontSize() ) + 5 ) elif args["Object"].id == engine.Plus_Frame.금액범위.id: Animation.FontSize ( engine.Plus_Frame.금액 , engine , 5 , int ( engine.Plus_Frame.금액.text.FontSize ( ) ) , int ( engine.Plus_Frame.금액.text.FontSize () ) + 5 ) Animation.FontSize ( engine.Plus_Frame.금액글,engine, 5 , int ( engine.Plus_Frame.금액글.text.FontSize() ) , int ( engine.Plus_Frame.금액글.text.FontSize()) + 5 ) elif args["Object"].id == engine.Plus_Frame.태그범위.id: Animation.FontSize ( engine.Plus_Frame.태그 , engine , 5 , int ( engine.Plus_Frame.태그.text.FontSize ( ) ) , int ( engine.Plus_Frame.태그.text.FontSize () ) + 5 ) Animation.FontSize ( engine.Plus_Frame.태그글,engine , 5, int ( engine.Plus_Frame.태그글.text.FontSize() ) , int ( engine.Plus_Frame.태그글.text.FontSize()) + 5 ) elif args["Object"].id == engine.Plus_Frame.내용범위.id: Animation.FontSize ( engine.Plus_Frame.내용 , engine , 5 , int ( engine.Plus_Frame.내용.text.FontSize ( ) ) , int ( engine.Plus_Frame.내용.text.FontSize ( ) ) + 5 ) Animation.FontSize ( engine.Plus_Frame.내용글,engine, 5 , int ( engine.Plus_Frame.내용글.text.FontSize() ) , int ( engine.Plus_Frame.내용글.text.FontSize() ) + 5 ) engine.ThreadEnd () elif id == "TextClick": engine.ThreadStart () args["Object"].text.FontSize ( int(args["Object"].text.FontSize()) -5 ) engine.ThreadEnd () elif id == "TextClickRelease": Animation.FontSize ( args["Object"] , engine , 5 , int ( args["Object"].text.FontSize () ) , int ( args["Object"].text.FontSize ( ) ) + 5 ) elif id == "MakeGraph": data = engine.data.sumsameList ( "태그" ) data = engine.data.tool.percentData ( data ) if len( data ) > 0 and data[0]["금액"] < 0: engine.Graph_Frame.첫이름.text.text = data[0]["태그"] + "\n" + str(-data[0]["금액"]) + "%" engine.Graph_Frame.첫그래프.pSize보조.y = ( data[0]["금액"]/100 + 1 )* engine.Graph_Frame.첫그래프.pSizeORIGEN.y if len( data ) > 1 and data[1]["금액"] < 0: engine.Graph_Frame.둘이름.text.text = data[1]["태그"] + "\n" + str(-data[1]["금액"]) + "%" engine.Graph_Frame.둘그래프.pSize보조.y = ( data[1]["금액"]/100 + 1 )* engine.Graph_Frame.둘그래프.pSizeORIGEN.y if len( data ) > 2 and data[2]["금액"] < 0: engine.Graph_Frame.삼이름.text.text = data[2]["태그"] + "\n" + str(-data[2]["금액"]) + "%" engine.Graph_Frame.삼그래프.pSize보조.y = ( data[2]["금액"]/100 + 1 )* engine.Graph_Frame.삼그래프.pSizeORIGEN.y if len( data ) > 3 and data[3]["금액"] < 0: engine.Graph_Frame.넷이름.text.text = data[3]["태그"] + "\n" + str(-data[3]["금액"]) + "%" engine.Graph_Frame.넷그래프.pSize보조.y = ( data[3]["금액"]/100 + 1 )* engine.Graph_Frame.넷그래프.pSizeORIGEN.y if len( data ) > 4 and data[4]["금액"] < 0: engine.Graph_Frame.오이름.text.text = data[4]["태그"] + "\n" + str(-data[4]["금액"]) + "%" engine.Graph_Frame.오그래프.pSize보조.y = ( data[4]["금액"]/100 + 1 )* engine.Graph_Frame.오그래프.pSizeORIGEN.y if len( data ) > 0: 지출 = engine.data.tool.plusData ( data, False ) engine.Graph_Frame.전체이름.text.text = "전체\n" + str (-지출) + "%" engine.Graph_Frame.전체그래프.pSize보조.y = ( 지출/100 + 1 )* engine.Graph_Frame.전체그래프.pSizeORIGEN.y elif id == "PlusData": error = engine.data.PlusData ( 날자 = engine.Plus_Frame.날자글.text.text, 금액 = engine.Plus_Frame.금액글.text.text, 태그 = engine.Plus_Frame.태그글.text.text, 내용 = engine.Plus_Frame.내용글.text.text) if error == "성공": Event_re ( id = "MakeGraph" ) # 그래프 최신화 Color.ColorChanger ( engine , engine.root , Color.Color.c4,Color.Color.c3 , engine.Plus_Frame.큰바 , 20 ) selected = int ( (engine.Plus_Frame.작은바.pStart.y - engine.Plus_Frame.창바.pStart.y) / 100 ) engine.Plus_Frame.날자글.text.text = "" engine.Plus_Frame.금액글.text.text = "" engine.Plus_Frame.태그글.text.text = "" engine.Plus_Frame.내용글.text.text = "" engine.Plus_Frame.설명글.text.text = "저장이 되었습니다." if selected == 0: # 조회 항목이 보고 있는 것으로 업데이트 id = "날자" elif selected == 1: id = "금액" elif selected == 2: id = "태그" elif selected == 3: id = "내용" engine.data.MakeViewData( "날자" ) engine.Warning_Frame.창바.text.text = "" # 버튼 클릭으로 했을때, 저장했으므로 다시 쓰기 상태가 풀려야 함 elif error[0:2] == "날자": engine.Plus_Frame.설명글.text.text = error Color.ColorChanger ( engine , engine.root , Color.Color.c2,Color.Color.c3 , engine.Plus_Frame.작은바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c3,Color.Color.c2 , engine.Plus_Frame.큰바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c2 , engine.Plus_Frame.창바 , 20 ) Animation.Move ( engine.Plus_Frame.큰바 , engine , 20 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 300 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 300 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 25 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 300 ) ) elif error[0:2] == "금액": Color.ColorChanger ( engine , engine.root , Color.Color.c2,Color.Color.c3 , engine.Plus_Frame.작은바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c3,Color.Color.c2 , engine.Plus_Frame.큰바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c2 , engine.Plus_Frame.창바 , 20 ) engine.Plus_Frame.설명글.text.text = error Animation.Move ( engine.Plus_Frame.큰바 , engine , 20 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 400 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 400 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 25 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 400 ) ) elif error[0:2] == "태그": Color.ColorChanger ( engine , engine.root , Color.Color.c2,Color.Color.c3 , engine.Plus_Frame.작은바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c3,Color.Color.c2 , engine.Plus_Frame.큰바 , 20 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c2 , engine.Plus_Frame.창바 , 20 ) engine.Plus_Frame.설명글.text.text = error Animation.Move ( engine.Plus_Frame.큰바 , engine , 20 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 500 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 500 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 25 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 500 ) ) elif id == "KeyEvent": if engine.Plus_Frame.enable == True: engine.ThreadStart( ) print("실행된 char = ", args["char"]) selected = int ( (engine.Plus_Frame.작은바.pStart.y - engine.Plus_Frame.창바.pStart.y) / 100 ) args["char"] = engine.event.Tool.Filter ( args["char"] , int(selected/2) ) if selected == 0: if args["char"] != "Eraser": if args["char"] != "Enter": if args["char"] != "Tab" and args["char"] != "Space": engine.Plus_Frame.날자글.text.text = engine.Plus_Frame.날자글.text.text + args["char"] else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) Event_re( id = "추가.금액범위" ) else: Event_re( id = "PlusData" ) else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 5 ) engine.Plus_Frame.날자글.text.text = engine.Plus_Frame.날자글.text.text[ 0 : len(engine.Plus_Frame.날자글.text.text) - 1 ] elif selected == 1: if args["char"] != "Eraser": if args["char"] != "Enter": if args["char"] != "Tab": if args["char"] != "Space": if engine.Plus_Frame.금액글.text.text == "":##아무것도 없을 경우 +를 추가합니다. Color.ColorChanger ( engine , engine.root , Color.Color.c4,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) engine.Plus_Frame.금액글.text.text = "+" engine.Plus_Frame.금액글.text.text = engine.Plus_Frame.금액글.text.text + args["char"] else: if engine.Plus_Frame.금액글.text.text[0:1] == "+": Color.ColorChanger ( engine , engine.root , Color.Color.c4,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) engine.Plus_Frame.금액글.text.text = "-" + engine.Plus_Frame.금액글.text.text[1:] else: Color.ColorChanger ( engine , engine.root , Color.Color.c4,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) engine.Plus_Frame.금액글.text.text = "+" + engine.Plus_Frame.금액글.text.text[1:] else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) Event_re( id = "추가.태그범위" ) else: Event_re( id = "PlusData" ) else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 5 ) engine.Plus_Frame.금액글.text.text = engine.Plus_Frame.금액글.text.text[ 0 : 1] +engine.Plus_Frame.금액글.text.text[ 1 : len(engine.Plus_Frame.금액글.text.text) - 1 ] elif selected == 2: if args["char"] != "Eraser": if args["char"] != "Enter": if args["char"] != "Tab": if args["char"] != "Space": if engine.Plus_Frame.태그글.text.text == "":##아무것도 없을 경우 +를 추가합니다. engine.Plus_Frame.태그글.text.text = "#" engine.Plus_Frame.태그글.text.text = engine.Plus_Frame.태그글.text.text + args["char"] else: if engine.Plus_Frame.태그글.text.text[0:1] == "#": engine.Plus_Frame.태그글.text.text = engine.Plus_Frame.태그글.text.text[1:] else: engine.Plus_Frame.태그글.text.text = "#" + engine.Plus_Frame.태그글.text.text else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) Event_re( id = "추가.내용범위" ) else: Event_re( id = "PlusData" ) else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 5 ) engine.Plus_Frame.태그글.text.text = engine.Plus_Frame.태그글.text.text[ 0 : len(engine.Plus_Frame.태그글.text.text) - 1 ] elif selected == 3: if args["char"] != "Eraser": if args["char"] != "Enter": if args["char"] != "Tab": if args["char"] != "Space": engine.Plus_Frame.내용글.text.text = engine.Plus_Frame.내용글.text.text + args["char"] else: engine.Plus_Frame.내용글.text.text = engine.Plus_Frame.내용글.text.text + " " else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 15 ) Event_re( id = "추가.날자범위" ) else: Event_re( id = "PlusData" ) else: Color.ColorChanger ( engine , engine.root , Color.Color.c6,Color.Color.c3 , engine.Plus_Frame.작은바 , 5 ) engine.Plus_Frame.내용글.text.text = engine.Plus_Frame.내용글.text.text[ 0 : len(engine.Plus_Frame.내용글.text.text) - 1 ] engine.ThreadEnd() print("selected = ", selected) elif id == engine.Main_Frame.메인.id: Event_re ( id = "ButtonLock" ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.메인.c , Color.Color.c3 , engine.Main_Frame.메인 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.내역.c , Color.Color.c6 , engine.Main_Frame.내역 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.추가.c , Color.Color.c6 , engine.Main_Frame.추가 , 10 ) engine.root.after ( 3000 , _ButtonLock ) _Closer ( 1 ) if engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment or engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.취소ment engine.Warning_Frame.Active( True , engine ) elif id == engine.Main_Frame.내역.id: Event_re ( id = "ButtonLock" ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.내역.c , Color.Color.c3 , engine.Main_Frame.내역 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.메인.c , Color.Color.c6 , engine.Main_Frame.메인 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.추가.c , Color.Color.c6 , engine.Main_Frame.추가 , 10 ) engine.root.after ( 3000 , _ButtonLock ) _Closer ( 2 ) if engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment or engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.취소ment engine.Warning_Frame.Active( True , engine ) elif id == engine.Main_Frame.추가.id: Event_re ( id = "ButtonLock" ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.추가.c , Color.Color.c3 , engine.Main_Frame.추가 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.메인.c , Color.Color.c6 , engine.Main_Frame.메인 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.내역.c , Color.Color.c6 , engine.Main_Frame.내역 , 10 ) engine.root.after ( 3000 , _ButtonLock ) _Closer ( 3 ) elif id == "내역.이전글": if engine.View_Frame.이전글.text.text != ' ': engine.View_Frame.창바.c engine.View_Frame.큰바.c engine.View_Frame.작은바.c #Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c2 , engine.View_Frame.창바 , 2 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c2 , engine.View_Frame.큰바 , 4 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c3 , engine.View_Frame.작은바,6 ) engine.data.PageDown( ) _ViewPage() elif id == "내역.다음글": if engine.View_Frame.다음글.text.text != " ": engine.View_Frame.창바.c engine.View_Frame.큰바.c engine.View_Frame.작은바.c #Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c2 , engine.View_Frame.창바 , 2 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c2 , engine.View_Frame.큰바 , 4 ) Color.ColorChanger ( engine , engine.root , Color.Color.c6 , Color.Color.c3 , engine.View_Frame.작은바,6 ) engine.data.PageUp( ) _ViewPage() elif id == "내역.날자범위": Animation.Move ( engine.View_Frame.다음글 , engine , 15 , engine.View_Frame.다음글.pStart , Point (1200,300) ) Animation.Move ( engine.View_Frame.이전글 , engine , 15 , engine.View_Frame.이전글.pStart , Point (0,300) ) Animation.Move ( engine.View_Frame.큰바 , engine , 15 , engine.View_Frame.큰바.pStart , Point (0,300) ) Animation.Move ( engine.View_Frame.작은바 , engine , 15 , engine.View_Frame.작은바.pStart , Point (500,300) ) engine.data.MakeViewData( "날자" ) _ViewPage() elif id == "내역.금액범위": Animation.Move ( engine.View_Frame.다음글 , engine , 15 , engine.View_Frame.다음글.pStart , Point (1200,400) ) Animation.Move ( engine.View_Frame.이전글 , engine , 15 , engine.View_Frame.이전글.pStart , Point (0,400) ) Animation.Move ( engine.View_Frame.큰바 , engine , 15 , engine.View_Frame.큰바.pStart , Point (0,400) ) Animation.Move ( engine.View_Frame.작은바 , engine , 15 , engine.View_Frame.작은바.pStart , Point (500,400) ) engine.data.MakeViewData( "금액" ) _ViewPage() elif id == "내역.태그범위": Animation.Move ( engine.View_Frame.다음글 , engine , 15 , engine.View_Frame.다음글.pStart , Point (1200,500) ) Animation.Move ( engine.View_Frame.이전글 , engine , 15 , engine.View_Frame.이전글.pStart , Point (0,500) ) Animation.Move ( engine.View_Frame.큰바 , engine , 15 , engine.View_Frame.큰바.pStart , Point (0,500) ) Animation.Move ( engine.View_Frame.작은바 , engine , 15 , engine.View_Frame.작은바.pStart , Point (500,500) ) engine.data.MakeViewData( "태그" ) _ViewPage() elif id == "내역.내용범위": Animation.Move ( engine.View_Frame.다음글 , engine , 15 , engine.View_Frame.다음글.pStart , Point (1200,600) ) Animation.Move ( engine.View_Frame.이전글 , engine , 15 , engine.View_Frame.이전글.pStart , Point (0,600) ) Animation.Move ( engine.View_Frame.큰바 , engine , 15 , engine.View_Frame.큰바.pStart , Point (0,600) ) Animation.Move ( engine.View_Frame.작은바 , engine , 15 , engine.View_Frame.작은바.pStart , Point (500,600) ) engine.data.MakeViewData( "내용" ) _ViewPage() elif id == "추가.날자범위": engine.Plus_Frame.설명글.text.text = "8글자를 입력하세요!" Animation.Move ( engine.Plus_Frame.큰바 , engine , 15 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 300 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 300 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 15 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 300 ) ) elif id == "추가.금액범위": engine.Plus_Frame.설명글.text.text = "스페이스바로 금액이 +,-를 설정할수 있어요!" Animation.Move ( engine.Plus_Frame.큰바 , engine , 15 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 400 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 400 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 15 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 400 ) ) elif id == "추가.태그범위": engine.Plus_Frame.설명글.text.text = "4글자 이내로 입력하세요!" Animation.Move ( engine.Plus_Frame.큰바 , engine , 15 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 500 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 500 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 15 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 500 ) ) elif id == "추가.내용범위": engine.Plus_Frame.설명글.text.text = "자유롭게 입력하세요!" Animation.Move ( engine.Plus_Frame.큰바 , engine , 15 , engine.Plus_Frame.큰바.pStart , Point ( 0 , 600 ) ) Animation.Move ( engine.Plus_Frame.작은바 , engine , 15 , engine.Plus_Frame.작은바.pStart , Point ( 600 , 600 ) ) Animation.Move ( engine.Plus_Frame.설명글 , engine , 15 , engine.Plus_Frame.설명글.pStart , Point ( 0 , 600 ) ) elif id == "메인.종료": # 4 Event_re ( id = "ButtonLock" ) engine.root.after ( 1600 , _ButtonLock ) _Closer ( 4 ) #컨트롤박스_조회.다시쓰기 elif id[0:5] == "컨트롤박스": Color.ColorChanger ( engine , engine.root , Color.Color.c4 , Color.Color.c1 , args["Object"] , 10 ) engine.root.after ( 400 , engine.controlbox.AnimationUp ) if id[6:8] == "조회": if id[9:] == "다시쓰기": print("다시쓰기를 클릭함") engine.Warning_Frame.창바.text.text = engine.controlbox.내역.다시쓰기ment engine.Warning_Frame.Active( True , engine ) elif id[9:] == "찾기": engine.Warning_Frame.창바.text.text = engine.controlbox.내역.찾기ment engine.Warning_Frame.Active( True , engine ) elif id[9:] == "삭제": engine.Warning_Frame.창바.text.text = engine.controlbox.내역.삭제ment engine.Warning_Frame.Active( True , engine ) elif id[6:8] == "추가":# 내역에서 넘오는 경우가 있어 조금 김 if id[9:] == "삭제": if engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: # 내역에서 다시쓰기로 넘어온 경우가 있으므로 engine.Warning_Frame.창바.text.text = engine.controlbox.추가.삭제ment engine.Warning_Frame.Active( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment: engine.Warning_Frame.Active( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment:# 새로 만들기가 넘어운 경우로 받았을때 engine.Warning_Frame.창바.text.text = engine.controlbox.추가.삭제ment engine.Warning_Frame.Active( True , engine ) else: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.삭제에러ment engine.Warning_Frame.Active( True , engine ) elif id[9:] == "새로만들기": if engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: # 내역에서 다시쓰기로 넘어온 경우때문에 engine.Warning_Frame.창바.text.text = engine.controlbox.추가.새로만들기에러ment engine.Warning_Frame.Active( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment: engine.Warning_Frame.Active( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.새로만들기에러ment engine.Warning_Frame.Active( True , engine ) else: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.새로만들기ment engine.Warning_Frame.Active( True , engine ) elif id[9:] == "저장": if engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.저장_다시쓰기ment engine.Warning_Frame.Active( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment: engine.Warning_Frame.Active ( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.저장_다시쓰기ment engine.Warning_Frame.Active( True , engine ) else: engine.Warning_Frame.창바.text.text = engine.controlbox.추가.저장ment engine.Warning_Frame.Active( True , engine ) else: engine.Warning_Frame.창바.text.text = "구현중입니다." engine.Warning_Frame.Active( True , engine ) elif id[0:3] == "경고창": engine.Warning_Frame.Active( False , engine ) engine.Warning_Frame.Enable ( False ) if engine.Warning_Frame.창바.text.text == engine.start_ment: ### 시작시 나오는 알림창 선택시 Event_re ( id = "MakeGraph" ) elif id[4:] == "확인버튼": if engine.Warning_Frame.창바.text.text == engine.controlbox.내역.삭제ment: engine.data.delete() engine.data.reMakeViewData() engine.data.MakeList() _ViewPage() elif engine.Warning_Frame.창바.text.text == engine.controlbox.내역.다시쓰기ment: engine.Plus_Frame.날자글.text.text = str(engine.View_Frame.날자글.text.text) engine.Plus_Frame.금액글.text.text = str(engine.View_Frame.금액글.text.text) engine.Plus_Frame.태그글.text.text = engine.View_Frame.태그글.text.text engine.Plus_Frame.내용글.text.text = engine.View_Frame.내용글.text.text Color.ColorChanger ( engine , engine.root , engine.Main_Frame.추가.c , Color.Color.c3 , engine.Main_Frame.추가 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.메인.c , Color.Color.c6 , engine.Main_Frame.메인 , 10 ) Color.ColorChanger ( engine , engine.root , engine.Main_Frame.내역.c , Color.Color.c6 , engine.Main_Frame.내역 , 10 ) _Closer ( 3 ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기ment: engine.Plus_Frame.날자글.text.text = "" engine.Plus_Frame.금액글.text.text = "" engine.Plus_Frame.태그글.text.text = "" engine.Plus_Frame.내용글.text.text = "" engine.Warning_Frame.창바.text.text = "" engine.Plus_Frame.설명글.text.text = "새로 작성해주세요." elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.새로만들기에러ment: engine.Plus_Frame.날자글.text.text = "" engine.Plus_Frame.금액글.text.text = "" engine.Plus_Frame.태그글.text.text = "" engine.Plus_Frame.내용글.text.text = "" engine.Warning_Frame.창바.text.text = "" engine.Plus_Frame.설명글.text.text = "새로 작성해주세요" elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.삭제ment: engine.Warning_Frame.창바.text.text = "" engine.data.delete() engine.data.reMakeViewData() engine.data.MakeList() _ViewPage() engine.root.update() engine.root.after ( 650 ) engine.root.update() engine.Warning_Frame.창바.text.text = engine.controlbox.추가.삭제완료ment engine.Warning_Frame.Active ( True , engine ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장_다시쓰기ment or engine.Warning_Frame.창바.text.text == engine.controlbox.추가.저장ment: Event_re( id = "PlusData" ) elif engine.Warning_Frame.창바.text.text == engine.controlbox.추가.취소ment: engine.Plus_Frame.날자글.text.text = "" engine.Plus_Frame.금액글.text.text = "" engine.Plus_Frame.태그글.text.text = "" engine.Plus_Frame.내용글.text.text = "" engine.Warning_Frame.창바.text.text = ""
class Butterfly(): def __init__(self, x, y, color = (255, 255, 255), objectList = [], spriteList = []): self.objectList = objectList self.spriteList = spriteList self.rect = pygame.Rect(x, y, 15, 15) self.screen = pygame.display.get_surface() self.butterflyAnim = Animation("butterfly", 8) self.butterflyAnim.updateColor(color) self.butterflyAnim.setFrameRange(1, 8); self.butterflyAnim.setCurrentFrame(randint(1, 8)) self.sprite = pygame.sprite.RenderPlain(self.butterflyAnim) self.butterflyAnim.playAnim() self.area = self.screen.get_rect() self.color = color self.floorLevel = self.screen.get_height() - self.rect.h self.movingLeft = False self.movingRight = False self.movingUp = False self.movingDown = False self.degree = randint(0, 360) self.speed = 4 self.detlaUpdate = 0 self.collide = False self.movePos = [0,0.01] def update(self): if(self.detlaUpdate == 1): self.detlaUpdate = 0 limitBottom = self.degree - 20 limitTop = self.degree + 20 self.degree = randint(limitBottom, limitTop) self.degree = self.degree % 360 if(randint(0, 1) == 0): if(self.speed < 6): self.speed += 1 else: if(self.speed > 2): self.speed -= 1 self.movePos[0] = math.cos(math.radians(self.degree)) * self.speed self.movePos[1] = math.sin(math.radians(self.degree)) * self.speed #self.movePos[0] = randint(-8, 8) #self.movePos[1] = randint(-8, 8) self.checkForCollision() newpos = self.rect.move(self.movePos) if self.area.contains(newpos) and not self.collide: self.rect = newpos self.butterflyAnim.getRect().x = self.rect.x self.butterflyAnim.getRect().y = self.rect.y if self.degree >= 90 and self.degree <= 240: self.movingLeft = True self.movingRight = False else: self.movingLeft = False self.movingRight = True if self.degree >= 0 and self.degree <= 180: self.movingDown = True self.movingUp = False else: self.movingDown = False self.movingUp = True else: self.detlaUpdate += 1 self.butterflyAnim.update() self.sprite.update() self.sprite.draw(self.screen) pygame.event.pump() def collisionDetection(self, obj, rabbit = False): #FLEE BEHAVIOR !!! objCenterX = obj.rect.x + obj.rect.w/2 objCenterY = obj.rect.y + obj.rect.h/2 butterflyCenterX = self.rect.x + self.rect.w/2 butterflyCenterY = self.rect.y + self.rect.h/2 dist = math.fabs(math.sqrt(((objCenterX - butterflyCenterX) * (objCenterX - butterflyCenterX)) + ((objCenterY - butterflyCenterY) * (objCenterY - butterflyCenterY)))) if dist < 50: distX = math.fabs(objCenterX - butterflyCenterX) angle = math.degrees(math.acos(distX/dist)) if (objCenterX <= butterflyCenterX) and (objCenterY <= butterflyCenterY): angle = 240 - angle elif (objCenterX > butterflyCenterX) and (objCenterY <= butterflyCenterY): angle = 360 - angle elif (objCenterX <= butterflyCenterX) and (objCenterY > butterflyCenterY): angle = 180 - angle angle += 180 angle = angle % 360 self.degree = int(angle) #FLEE BEHAVIOR !!! # if (self.rect.x < (obj.rect.x + obj.rect.w)) and (obj.rect.x < self.rect.x): # if (self.rect.y + self.rect.h) > (obj.rect.y + 1): # if self.rect.y < (obj.rect.y + obj.rect.h): # self.movePos[0] = 5 # if (obj.rect.x < (self.rect.x + self.rect.w)) and (obj.rect.x > self.rect.x): # if (self.rect.y + self.rect.h) > (obj.rect.y + 1): # if self.rect.y < (obj.rect.y + obj.rect.h): # self.movePos[0] = -5 # if (self.rect.y <= (obj.rect.y + obj.rect.h)) and (obj.rect.y <= self.rect.y): # if (self.rect.x + self.rect.w) > (obj.rect.x + 3): # if self.rect.x < (obj.rect.x + obj.rect.w - 5): # self.movePos[1] = 5 # if ((self.rect.y + self.rect.h) >= obj.rect.y) and (self.rect.y <= obj.rect.y): # if (self.rect.x + self.rect.w) > (obj.rect.x + 3): # if self.rect.x < (obj.rect.x + obj.rect.w - 5): # if self.movePos[1] >= 0: # self.rect.y = obj.rect.y - self.rect.h # self.movePos[1] = -5 def screenCollisionDetection(self): butterflyCenterX = self.rect.x + self.rect.w/2 butterflyCenterY = self.rect.y + self.rect.h/2 distBorder = butterflyCenterX if distBorder < 10: self.degree = 0 if (butterflyCenterY) < distBorder: distBorder = butterflyCenterY if distBorder < 10: self.degree = 90 if (self.screen.get_rect().w - butterflyCenterX) < distBorder: distBorder = self.screen.get_rect().w - butterflyCenterX if distBorder < 10: self.degree = 180 if (self.screen.get_rect().h - butterflyCenterY) < distBorder: distBorder = self.screen.get_rect().h - butterflyCenterY if distBorder < 10: self.degree = 240 def checkForCollision(self): #if not self.movingLeft and not self.movingRight and self.movePos[1] == 0 and self.velocity == 0: # return for obj in self.objectList: if obj.getType() is not "carrot": self.collisionDetection(obj, False) self.screenCollisionDetection() #for rabbit in self.rabbitList: # self.collisionDetection(rabbit, True) def moveLeftStart(self): self.movingLeft = True self.movingRight = False def moveLeftStop(self): self.movingLeft = False self.movePos[0] = 0 def moveRightStart(self): self.movingRight = True self.movingLeft = False def moveRightStop(self): self.movingRight = False self.movePos[0] = 0 def getAnim(self): return self.butterflyAnim
import VRScript import Animation ghost = Animation.AnimationObject("Ghost") ghost.LoadAnimation("Ghosts\\005-03end.fbx", [90, 0, 0], VRScript.Math.Vector(1, 1, 1)) ghost.Play(VRScript.Core.PlayMode.Loop)
App.setActiveDocument("Unnamed") App.ActiveDocument=App.getDocument("Unnamed") Gui.ActiveDocument=Gui.getDocument("Unnamed") import Animation Animation.createManager() App.ActiveDocument.addObject("Part::Box","Box") App.ActiveDocument.addObject("Part::Box","Box") App.ActiveDocument.addObject("Part::Box","Box") App.ActiveDocument.addObject("Part::Box","Box") App.ActiveDocument.addObject("Part::Cone","Cone") import Placer s1=Placer.createPlacer("B1") s1.target=App.ActiveDocument.Box001 s2=Placer.createPlacer("B2") s2.target=App.ActiveDocument.Box002 s2.y="10" s3=Placer.createPlacer("B3") s3.target=App.ActiveDocument.Box003 s3.y="20" import Diagram c=Diagram.createDiagram("dia","0.200*time","0.2*(0.01*time-0.5)**2","10+time+1","-10*time")
def old__process_file_withSpeech_byGroup(filename, window=240, window_step=120): if not '_p0.bvh' in filename: return #Load speech info seqName = os.path.basename(filename) speech_fileName = seqName[:-7] + '.pkl' speechPath = './panopticDB_pkl_speech_hagglingProcessed/' + speech_fileName speechData_raw = pickle.load(open(speechPath, "rb")) positions_list = list() speechData_list = list() for pIdx in range(0, 3): """ Do FK """ if pIdx == 0: anim, names, frametime = BVH.load(filename) else: newFileName = filename.replace('_p0.bvh', '_p{0}.bvh'.format(pIdx)) anim, names, frametime = BVH.load(newFileName) if pIdx == 0: #_p0.bvh' in filename: speechData = speechData_raw['speechData'][0] elif pIdx == 1: #'_p1.bvh' in filename: speechData = speechData_raw['speechData'][1] elif pIdx == 2: #'_p2.bvh' in filename: speechData = speechData_raw['speechData'][2] # """ Convert to 60 fps """ # anim = anim[::2] # Origianl Human3.6 has 50 fps. So, no smapling is done """ Do FK """ global_positions = Animation.positions_global(anim) """ Remove Uneeded Joints """ positions = global_positions[:, np.array([ 0, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 16, 18, 19, 20, 22, 25, 26, 27, 29 ])] """ Put on Floor """ fid_l, fid_r = np.array([4, 5]), np.array([8, 9]) foot_heights = np.minimum(positions[:, fid_l, 1], positions[:, fid_r, 1]).min(axis=1) floor_height = softmin(foot_heights, softness=0.5, axis=0) positions[:, :, 1] -= floor_height """ Add Reference Joint """ trajectory_filterwidth = 3 reference = positions[:, 0] * np.array([1, 0, 1]) reference = filters.gaussian_filter1d(reference, trajectory_filterwidth, axis=0, mode='nearest') positions = np.concatenate([reference[:, np.newaxis], positions], axis=1) """ Get Foot Contacts """ velfactor, heightfactor = np.array([0.05, 0.05]), np.array([3.0, 2.0]) feet_l_x = (positions[1:, fid_l, 0] - positions[:-1, fid_l, 0])**2 feet_l_y = (positions[1:, fid_l, 1] - positions[:-1, fid_l, 1])**2 feet_l_z = (positions[1:, fid_l, 2] - positions[:-1, fid_l, 2])**2 feet_l_h = positions[:-1, fid_l, 1] feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor) & (feet_l_h < heightfactor)).astype(np.float) feet_r_x = (positions[1:, fid_r, 0] - positions[:-1, fid_r, 0])**2 feet_r_y = (positions[1:, fid_r, 1] - positions[:-1, fid_r, 1])**2 feet_r_z = (positions[1:, fid_r, 2] - positions[:-1, fid_r, 2])**2 feet_r_h = positions[:-1, fid_r, 1] feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor) & (feet_r_h < heightfactor)).astype(np.float) """ Get Root Velocity """ velocity = (positions[1:, 0:1] - positions[:-1, 0:1]).copy() """ Remove Translation """ positions[:, :, 0] = positions[:, :, 0] - positions[:, 0:1, 0] positions[:, :, 2] = positions[:, :, 2] - positions[:, 0:1, 2] """ Get Forward Direction """ sdr_l, sdr_r, hip_l, hip_r = 14, 18, 2, 6 across1 = positions[:, hip_l] - positions[:, hip_r] across0 = positions[:, sdr_l] - positions[:, sdr_r] across = across0 + across1 across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] direction_filterwidth = 20 forward = np.cross(across, np.array([[0, 1, 0]])) forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] """ Remove Y Rotation """ target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) rotation = Quaternions.between(forward, target)[:, np.newaxis] positions = rotation * positions """ Get Root Rotation """ velocity = rotation[1:] * velocity rvelocity = Pivots.from_quaternions(rotation[1:] * -rotation[:-1]).ps """ Add Velocity, RVelocity, Foot Contacts to vector """ positions = positions[:-1] positions = positions.reshape(len(positions), -1) positions = np.concatenate([positions, velocity[:, :, 0]], axis=-1) positions = np.concatenate([positions, velocity[:, :, 2]], axis=-1) positions = np.concatenate([positions, rvelocity], axis=-1) positions = np.concatenate([positions, feet_l, feet_r], axis=-1) speechData_list.append(speechData) #Save speech info positions_list.append(positions) #Save skeleton info if len(positions_list[0]) != len(positions_list[1]): raise Exception() if len(positions_list[1]) != len(positions_list[2]): raise Exception() if len(speechData_list[0]) != len(speechData_list[1]): raise Exception() if len(speechData_list[1]) != len(speechData_list[2]): raise Exception() """ Slide over windows """ windows = [list(), list(), list()] windows_speech = [list(), list(), list()] print("skelSize {0} vs speechSize {1}".format( positions.shape[0], speechData['indicator'].shape[0])) for j in range(0, len(positions) - window // 8, window_step): for pIdx in range(len(positions_list)): """ If slice too small pad out by repeating start and end poses """ slice = positions_list[pIdx][j:j + window] if len(slice) < window: break # left = slice[:1].repeat((window-len(slice))//2 + (window-len(slice))%2, axis=0) # left[:,-7:-4] = 0.0 # right = slice[-1:].repeat((window-len(slice))//2, axis=0) # right[:,-7:-4] = 0.0 # slice = np.concatenate([left, slice, right], axis=0) if len(slice) != window: raise Exception() windows[pIdx].append(slice) # """ Find Class """ # cls = -1 # if filename.startswith('hdm05'): # cls_name = os.path.splitext(os.path.split(filename)[1])[0][7:-8] # cls = class_names.index(class_map[cls_name]) if cls_name in class_map else -1 # if filename.startswith('styletransfer'): # cls_name = os.path.splitext(os.path.split(filename)[1])[0] # cls = np.array([ # styletransfer_motions.index('_'.join(cls_name.split('_')[1:-1])), # styletransfer_styles.index(cls_name.split('_')[0])]) cls = speechData_list[pIdx]['indicator'][j:j + window] windows_speech[pIdx].append(cls) return windows, windows_speech
class Duke(Enemy): x = 6 y = 3 health = 100 hurtDistance = 1.3 def __init__(self, textures, sounds): self.texture = textures["bosses"]["duke"].subsurface(0, 128, 160, 128) self.sounds = sounds self.textures = textures self.frames = [ textures["bosses"]["duke"].subsurface(160, 128, 160, 128), textures["bosses"]["duke"].subsurface(160, 0, 160, 128), textures["bosses"]["duke"].subsurface(0, 0, 160, 128) ] self.tearTextures = textures["tears"] self.tearSounds = sounds["tear"] self.animation = Animation(self.frames, 0.5) self.textures = textures self.lastShot = -1 self.flies = [] self.animating = False def die(self): self.dead = True def render(self, surface, time, character, nodes, paths, bounds, obsticals): # Blit head if not self.dead: if not self.animating: surface.blit(self.texture, (GRIDX+GRATIO*self.x-284/4 +10, GRIDY+GRATIO*self.y-320/4)) else: surface.blit(self.animation.render(time), (GRIDX+GRATIO*self.x-284/4 + 10, GRIDY+GRATIO*self.y-320/4)) dx = character.x-(GRIDX+GRATIO*self.x) dy = character.y-(GRIDY+GRATIO*self.y) dist = sqrt(dx**2+dy**2) self.x += (dx/dist)/60 self.y += (dy/dist)/60 if time-self.lastShot >= 3: self.lastShot = time self.animating = False self.flies.append(Fly((self.x+randint(-1, 1), self.y), [self.sounds["deathBurst"]], self.textures["enemies"]["fly"])) elif time-self.lastShot >= 2.5: self.animation.reset(time) self.animating = True self.checkHurt(character, time) for fly in self.flies[:]: if not fly.render(surface, time, character, nodes, paths, bounds, obsticals): self.flies.remove(fly) if len(self.flies) > 0: return True return not self.dead
def selectChar(screen): selection = [1, 1] continuer = True images = [[] for i in range(6)] characters = [0, -1, 1] listPerso = ["Goku", "Gohan", "Picolo", "Végéta", "Freezer", "Cell"] loadImages(images) animP1 = Animation.Animation(True) animP1._getAll("Res/Goku/AnimNormale", 60, True, [60, 80]) animP1._setPos([120, 248 - animP1._getFrame().get_size()[1]]) fontObj = pygame.font.SysFont("Comic Sans MS", 24) animP2 = Animation.Animation() animP2._set([], []) afficherMenu(selection, screen, images) while continuer: for event in pygame.event.get(): if event.type == QUIT: return ["Quit"] elif event.type == KEYDOWN: if event.key == K_UP: if selection[1] > 1: selection[1] -= 1 else: selection[0] = 1 if characters[2] == 1: animP1._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, True) animP1._setPos( [120, 248 - animP1._getFrame().get_size()[1]]) else: animP2._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, False) animP2._setPos( [550, 248 - animP2._getFrame().get_size()[1]]) elif event.key == K_DOWN: if selection[1] < 2: selection[1] += 1 else: selection[0] = 3 if characters[2] == 1: animP1._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, True) animP1._setPos( [120, 248 - animP1._getFrame().get_size()[1]]) else: animP2._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, False) animP2._setPos( [550, 248 - animP2._getFrame().get_size()[1]]) elif event.key == K_LEFT: if selection[0] > 1: selection[0] -= 1 if characters[2] == 1: animP1._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, True) animP1._setPos( [120, 248 - animP1._getFrame().get_size()[1]]) else: animP2._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, False) animP2._setPos( [550, 248 - animP2._getFrame().get_size()[1]]) elif event.key == K_RIGHT: if selection[0] < 3: selection[0] += 1 if characters[2] == 1: animP1._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, True) animP1._setPos( [120, 248 - animP1._getFrame().get_size()[1]]) else: animP2._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, False) animP2._setPos( [550, 248 - animP2._getFrame().get_size()[1]]) elif event.key == K_RETURN or K_KP_ENTER: if characters[2] < 2: characters[2] += 1 animP2._getAll( "Res/" + listPerso[(selection[1] - 1) * 3 + selection[0] - 1] + "/AnimNormale", 60, False) animP2._setPos( [550, 248 - animP2._getFrame().get_size()[1]]) elif characters[2] == 2: retChars = [ listPerso[characters[0]], listPerso[characters[1]] ] return ["Battle", retChars] if characters[2] <= 1: characters[0] = ((selection[1] - 1) * 3) + selection[0] - 1 elif characters[2] == 2: characters[1] = ((selection[1] - 1) * 3) + selection[0] - 1 afficherMenu(selection, screen, images) P1Txt = fontObj.render(listPerso[characters[0]], False, (255, 255, 255)) screen.blit(P1Txt, (10, 0)) animP1._update() animP1._draw(screen) if characters[2] > 1: P2Txt = fontObj.render(listPerso[characters[1]], False, (255, 255, 255)) screen.blit(P2Txt, (500, 0)) animP2._update() animP2._draw(screen) pygame.display.update()
# plt.plot(time, pe_list) # plt.ylabel('Potential Energy') # plt.title('Potential Energy Plot') # plt.xlabel('Time Units') # plt.savefig('prob3_pe.png') # plt.show(block=True) # ke plot # plt.clf() # plt.plot(time, ke_list) # plt.xlabel('Time Units') # plt.ylabel('Kinetic Energy') # plt.title('Kinetic Energy Plot') # plt.savefig('prob3_ke.png') # plt.show(block=True) # pressure plot #plt.figure(2) # plt.clf() # plt.plot(time, pressure_list) # plt.xlabel('Time Units') # plt.ylabel('Pressure Relation') # plt.title('Pressure Relationship Plot') # plt.savefig('prob3_pressure.png') # plt.show(block=True) print 'Starting animation' Animation.show_positions(positions, DELTA_T, NUM_TIMESTEPS, FRAME_RATE, save_file_path='sled_movie')
def process_file(filename, window=240, window_step=120, export_trajectory=False): anim, names, frametime = BVH.load(filename) """ Subsample to 60 fps """ anim = anim[::2] """ Do FK """ global_xforms = Animation.transforms_global(anim) # intermediate global_positions = global_xforms[:, :, :3, 3] / global_xforms[:, :, 3:, 3] global_rotations = Quaternions.from_transforms(global_xforms) """ Remove Uneeded Joints """ #>># done post-hoc in PFNN used_joints = np.array([ 0, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 15, 16, 18, 19, 20, 22, 25, 26, 27, 29 ]) positions = global_positions[:, used_joints] global_rotations = global_rotations[:, used_joints] # ________________________________________________________ """ Put on Floor """ positions[:, :, 1] -= positions[:, :, 1].min() """ Get Foot Contacts """ if True: velfactor, heightfactor = np.array([0.05, 0.05]), np.array([3.0, 2.0]) fid_l, fid_r = np.array([3, 4]), np.array([7, 8]) feet_l_x = (positions[1:, fid_l, 0] - positions[:-1, fid_l, 0])**2 feet_l_y = (positions[1:, fid_l, 1] - positions[:-1, fid_l, 1])**2 feet_l_z = (positions[1:, fid_l, 2] - positions[:-1, fid_l, 2])**2 feet_l_h = positions[:-1, fid_l, 1] feet_l = (((feet_l_x + feet_l_y + feet_l_z) < velfactor) & (feet_l_h < heightfactor)).astype(np.float) feet_r_x = (positions[1:, fid_r, 0] - positions[:-1, fid_r, 0])**2 feet_r_y = (positions[1:, fid_r, 1] - positions[:-1, fid_r, 1])**2 feet_r_z = (positions[1:, fid_r, 2] - positions[:-1, fid_r, 2])**2 feet_r_h = positions[:-1, fid_r, 1] feet_r = (((feet_r_x + feet_r_y + feet_r_z) < velfactor) & (feet_r_h < heightfactor)).astype(np.float) """ Get Root Velocity """ velocity = (positions[1:, 0:1] - positions[:-1, 0:1]).copy() """ Remove Translation """ positions[:, :, 0] = positions[:, :, 0] - positions[:, 0:1, 0] positions[:, :, 2] = positions[:, :, 2] - positions[:, 0:1, 2] """ Get Forward Direction """ sdr_l, sdr_r, hip_l, hip_r = 13, 17, 1, 5 across1 = positions[:, hip_l] - positions[:, hip_r] across0 = positions[:, sdr_l] - positions[:, sdr_r] across = across0 + across1 across = across / np.sqrt((across**2).sum(axis=-1))[..., np.newaxis] direction_filterwidth = 20 forward = np.cross(across, np.array([[0, 1, 0]])) forward = filters.gaussian_filter1d(forward, direction_filterwidth, axis=0, mode='nearest') forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] """ Get Root Rotation """ target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0) root_rotation = Quaternions.between( forward, target)[:, np.newaxis] # rotation needed fwd->z? rvelocity = (root_rotation[1:] * -root_rotation[:-1]).to_pivots() """ Local Space """ # NEW: define position of joints relative to local_positions = positions.copy() local_positions[:, :, 0] = local_positions[:, :, 0] - local_positions[:, 0:1, 0] # x rel to root x local_positions[:, :, 2] = local_positions[:, :, 2] - local_positions[:, 0:1, 2] # z rel to root z local_positions = root_rotation[:-1] * local_positions[: -1] # remove Y rotation from pos local_velocities = local_positions[1:] - local_positions[:-1] local_rotations = abs((root_rotation[:-1] * global_rotations[:-1])).log() root_rvelocity = Pivots.from_quaternions(root_rotation[1:] * -root_rotation[:-1]).ps global_velocities = root_rotation[:-1] * velocity # remove Y rotation from vel assert global_velocities.shape[ 1] == 1, "output assumes global_velocities dim2 = 1." n = root_rvelocity.shape[0] omit_end = range(0, n - 1) out = np.hstack( (root_rvelocity[omit_end, :], global_velocities[omit_end, :, 0], global_velocities[omit_end, :, 2], feet_l[omit_end, :], feet_r[omit_end, :], local_positions[omit_end].reshape(n - 1, -1), local_velocities.reshape(n - 1, -1), local_rotations[omit_end].reshape(n - 1, -1))) return out