formatting and linting improvements

Author: cheind

benchmarks/benchmark.py

@@ -11,59 +11,65 @@
 INSTANCES = 4
 WORKER_INSTANCES = 4
 NUM_ITEMS = 512
-EXAMPLES_DIR = Path(__file__).parent/'..'/'examples'/'datagen'
-        
+EXAMPLES_DIR = Path(__file__).parent / ".." / "examples" / "datagen"
+
+
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('scene', help='Blender scene name to run', default='cube')
+    parser.add_argument("scene", help="Blender scene name to run", default="cube")
     args = parser.parse_args()
 
     launch_args = dict(
-        scene=EXAMPLES_DIR/f'{args.scene}.blend',
-        script=EXAMPLES_DIR/f'{args.scene}.blend.py', 
+        scene=EXAMPLES_DIR / f"{args.scene}.blend",
+        script=EXAMPLES_DIR / f"{args.scene}.blend.py",
         num_instances=INSTANCES,
-        named_sockets=['DATA']
+        named_sockets=["DATA"],
     )
 
-    with btt.BlenderLauncher(**launch_args) as bl:                        
-        ds = btt.RemoteIterableDataset(bl.launch_info.addresses['DATA'])
+    with btt.BlenderLauncher(**launch_args) as bl:
+        ds = btt.RemoteIterableDataset(bl.launch_info.addresses["DATA"])
         ds.stream_length(NUM_ITEMS)
-        dl = data.DataLoader(ds, batch_size=BATCH, num_workers=WORKER_INSTANCES, shuffle=False)
+        dl = data.DataLoader(
+            ds, batch_size=BATCH, num_workers=WORKER_INSTANCES, shuffle=False
+        )
 
         # Wait to avoid timing startup times of Blender
         time.sleep(5)
-        
+
         t0 = None
         tlast = None
         imgshape = None
-        
+
         elapsed = []
         n = 0
         for item in dl:
-            n += len(item['image'])
-            if t0 is None: # 1st is warmup
+            n += len(item["image"])
+            if t0 is None:  # 1st is warmup
                 t0 = time.time()
                 tlast = t0
-                imgshape = item['image'].shape
-            elif n % (50*BATCH) == 0:
+                imgshape = item["image"].shape
+            elif n % (50 * BATCH) == 0:
                 t = time.time()
                 elapsed.append(t - tlast)
                 tlast = t
-                print('.', end='')
+                print(".", end="")
         assert n == NUM_ITEMS
 
-        t1 = time.time()    
+        t1 = time.time()
         N = NUM_ITEMS - BATCH
-        B = NUM_ITEMS//BATCH - 1
-        print(f'Time {(t1-t0)/N:.3f}sec/image, {(t1-t0)/B:.3f}sec/batch, shape {imgshape}')
+        B = NUM_ITEMS // BATCH - 1
+        print(
+            f"Time {(t1-t0)/N:.3f}sec/image, {(t1-t0)/B:.3f}sec/batch, shape {imgshape}"
+        )
 
         fig, _ = plt.subplots()
         plt.plot(np.arange(len(elapsed)), elapsed)
-        plt.title('Receive times between 50 consecutive batches')
-        save_path = EXAMPLES_DIR / 'tmp' / 'batches_elapsed.png'
+        plt.title("Receive times between 50 consecutive batches")
+        save_path = EXAMPLES_DIR / "tmp" / "batches_elapsed.png"
         fig.savefig(str(save_path))
         plt.close(fig)
-        print(f'Figure saved to {save_path}')
+        print(f"Figure saved to {save_path}")
+
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    main()

examples/compositor_normals_depth/compositor_normals_depth.blend.py

@@ -1,6 +1,4 @@
-
 import blendtorch.btb as btb
-import numpy as np
 import bpy
 
 SHAPE = (30, 30)
@@ -22,10 +20,7 @@ def post_frame(render, pub, animation):
         # After frame
         if anim.frameid == 1:
             imgs = render.render()
-            pub.publish(
-                normals=imgs['normals'],
-                depth=imgs['depth']
-            )
+            pub.publish(normals=imgs["normals"], depth=imgs["depth"])
 
     # Parse script arguments passed via blendtorch launcher
     btargs, _ = btb.parse_blendtorch_args()
@@ -40,14 +35,14 @@ def post_frame(render, pub, animation):
     meshes = scene.prepare(NSHAPES, sshape_res=SHAPE)
 
     # Data source
-    pub = btb.DataPublisher(btargs.btsockets['DATA'], btargs.btid)
+    pub = btb.DataPublisher(btargs.btsockets["DATA"], btargs.btid)
 
     # Setup default image rendering
     cam = btb.Camera()
     render = btb.CompositeRenderer(
         [
-            btb.CompositeSelection('normals', 'Out1', 'Normals', 'RGB'),
-            btb.CompositeSelection('depth', 'Out1', 'Depth', 'V'),
+            btb.CompositeSelection("normals", "Out1", "Normals", "RGB"),
+            btb.CompositeSelection("depth", "Out1", "Depth", "V"),
         ],
         btid=btargs.btid,
         camera=cam,
@@ -57,8 +52,9 @@ def post_frame(render, pub, animation):
     anim = btb.AnimationController()
     anim.pre_animation.add(pre_anim, meshes)
     anim.post_frame.add(post_frame, render, pub, anim)
-    anim.play(frame_range=(0, 1), num_episodes=-1,
-              use_offline_render=False, use_physics=True)
+    anim.play(
+        frame_range=(0, 1), num_episodes=-1, use_offline_render=False, use_physics=True
+    )
 
 
 main()

examples/compositor_normals_depth/generate.py

@@ -3,35 +3,33 @@
 import blendtorch.btt as btt
 import matplotlib.pyplot as plt
 import numpy as np
-import torch
 from torch.utils import data
 
 
 def main():
     # Define how we want to launch Blender
     launch_args = dict(
-        scene=Path(__file__).parent/'compositor_normals_depth.blend',
-        script=Path(__file__).parent/'compositor_normals_depth.blend.py',
+        scene=Path(__file__).parent / "compositor_normals_depth.blend",
+        script=Path(__file__).parent / "compositor_normals_depth.blend.py",
         num_instances=1,
-        named_sockets=['DATA'],
+        named_sockets=["DATA"],
     )
 
     # Launch Blender
     with btt.BlenderLauncher(**launch_args) as bl:
         # Create remote dataset and limit max length to 16 elements.
-        addr = bl.launch_info.addresses['DATA']
+        addr = bl.launch_info.addresses["DATA"]
         ds = btt.RemoteIterableDataset(addr, max_items=4)
         dl = data.DataLoader(ds, batch_size=4, num_workers=0)
 
         for item in dl:
-            normals = item['normals']
+            normals = item["normals"]
             # Note, normals are color-coded (0..1), to convert back to original
             # range (-1..1) use
             # true_normals = (normals - 0.5) * \
             #    torch.tensor([2., 2., -2.]).view(1, 1, 1, -1)
-            depth = item['depth']
-            print('Received', normals.shape, depth.shape,
-                  depth.dtype, np.ptp(depth))
+            depth = item["depth"]
+            print("Received", normals.shape, depth.shape, depth.dtype, np.ptp(depth))
 
             fig, axs = plt.subplots(2, 2)
             axs = np.asarray(axs).reshape(-1)
@@ -44,5 +42,5 @@ def main():
             plt.show()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/compositor_normals_depth/scene_helpers.py

@@ -1,5 +1,4 @@
 import bpy
-import bmesh
 import numpy as np
 import blendtorch.btb as btb
 import supershape as sshape
@@ -8,7 +7,7 @@
 
 
 def create_sshape_mesh(shape, material=None, fake_user=False):
-    new_obj = sshape.make_bpy_mesh(shape, name='sshape', coll=False, weld=True)
+    new_obj = sshape.make_bpy_mesh(shape, name="sshape", coll=False, weld=True)
     new_obj.data.use_fake_user = fake_user
     new_obj.use_fake_user = fake_user
     if material is not None:
@@ -17,17 +16,13 @@ def create_sshape_mesh(shape, material=None, fake_user=False):
     return new_obj
 
 
-def prepare(
-        n_sshapes,
-        sshape_res=(100, 100),
-        collection='Generated',
-        fake_user=False):
+def prepare(n_sshapes, sshape_res=(100, 100), collection="Generated", fake_user=False):
     coll = SCN.collection.children[collection]
 
     # The following material renders camera-space normals
-    mat = btb.materials.create_normal_material('normals')
+    mat = btb.materials.create_normal_material("normals")
 
-    plane = bpy.data.objects['Plane']
+    plane = bpy.data.objects["Plane"]
     plane.active_material = mat
 
     sshapes = [
@@ -41,11 +36,11 @@ def prepare(
         SCN.rigidbody_world.collection.objects.link(s)
         # Rigid body settings
         s.rigid_body.enabled = True
-        s.rigid_body.collision_shape = 'BOX'
+        s.rigid_body.collision_shape = "BOX"
         s.rigid_body.friction = 0.7
         s.rigid_body.linear_damping = 0.3
         s.rigid_body.angular_damping = 0.4
-        s.rigid_body.type = 'ACTIVE'
+        s.rigid_body.type = "ACTIVE"
 
     return sshapes
 
@@ -54,11 +49,10 @@ def update_mesh(mesh, sshape_res=(100, 100)):
     params = np.random.uniform(
         low=[1.00, 1, 1, 6.0, 6.0, 6.0],
         high=[4.00, 1, 1, 10.0, 10.0, 10.0],
-        size=(2, 6)
+        size=(2, 6),
     )
     scale = np.abs(np.random.normal(0.05, 0.05, size=3))
     x, y, z = sshape.supercoords(params, shape=sshape_res)
-    sshape.update_bpy_mesh(x*scale[0], y*scale[1], z*scale[2], mesh)
-    mesh.location = np.random.uniform(
-        low=[-0.5, -0.5, 1], high=[0.5, 0.5, 3], size=(3))
+    sshape.update_bpy_mesh(x * scale[0], y * scale[1], z * scale[2], mesh)
+    mesh.location = np.random.uniform(low=[-0.5, -0.5, 1], high=[0.5, 0.5, 3], size=(3))
     mesh.rotation_euler = np.random.uniform(low=-np.pi, high=np.pi, size=(3))

examples/control/cartpole.py

@@ -16,24 +16,27 @@
 
 KAPPA = 30
 
+
 def control(obs):
     # Simple P controller defining the error as xpole-xcart
     xcart, xpole, _ = obs
-    return (xpole-xcart)*KAPPA
+    return (xpole - xcart) * KAPPA
+
 
 def main():
-    # Create the environment. The environment is registered in 
-    # `cartpole_gym/__init__.py`. Set `real_time=True` when you 
-    # want to keep the simulation running until the agent response. 
-    env = gym.make('blendtorch-cartpole-v0', real_time=False)
-    
-    obs = env.reset()        
+    # Create the environment. The environment is registered in
+    # `cartpole_gym/__init__.py`. Set `real_time=True` when you
+    # want to keep the simulation running until the agent response.
+    env = gym.make("blendtorch-cartpole-v0", real_time=False)
+
+    obs = env.reset()
     while True:
         obs, reward, done, info = env.step(control(obs))
         env.render()
         if done:
             obs = env.reset()
     env.done()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

examples/control/cartpole_gym/__init__.py

@@ -1,6 +1,3 @@
 from gym.envs.registration import register
 
-register(
-    id='blendtorch-cartpole-v0', 
-    entry_point='cartpole_gym.envs:CartpoleEnv'
-)
+register(id="blendtorch-cartpole-v0", entry_point="cartpole_gym.envs:CartpoleEnv")

examples/control/cartpole_gym/envs/__init__.py

@@ -1 +1 @@
-from .cartpole_env import CartpoleEnv
+from .cartpole_env import CartpoleEnv  # noqa

examples/control/cartpole_gym/envs/cartpole.blend.py

@@ -1,5 +1,4 @@
 import bpy
-from mathutils import Matrix
 import numpy as np
 
 from blendtorch import btb

examples/control/cartpole_gym/envs/cartpole_env.py

@@ -3,16 +3,17 @@
 from gym import spaces
 from blendtorch import btt
 
+
 class CartpoleEnv(btt.env.OpenAIRemoteEnv):
     def __init__(self, render_every=10, real_time=False):
 
-        super().__init__(version='0.0.1')
+        super().__init__(version="0.0.1")
         self.launch(
-            scene=Path(__file__).parent/'cartpole.blend',
-            script=Path(__file__).parent/'cartpole.blend.py',
+            scene=Path(__file__).parent / "cartpole.blend",
+            script=Path(__file__).parent / "cartpole.blend.py",
             real_time=real_time,
-            render_every=10,            
+            render_every=10,
         )
-        
+
         self.action_space = spaces.Box(np.float32(-100), np.float32(100), shape=(1,))
-        self.observation_space = spaces.Box(np.float32(-10), np.float32(10), shape=(1,))
+        self.observation_space = spaces.Box(np.float32(-10), np.float32(10), shape=(1,))

examples/datagen/cube.blend.py

@@ -3,6 +3,7 @@
 
 import blendtorch.btb as btb
 
+
 def main():
     # Parse script arguments passed via blendtorch launcher
     btargs, remainder = btb.parse_blendtorch_args()
@@ -12,29 +13,28 @@ def main():
 
     def pre_frame():
         # Randomize cube rotation
-        cube.rotation_euler = np.random.uniform(0,np.pi,size=3)  
-        
+        cube.rotation_euler = np.random.uniform(0, np.pi, size=3)
+
     def post_frame(off, pub, anim, cam):
         # Called every after Blender finished processing a frame.
         # Will be sent to one of the remote dataset listener connected.
         pub.publish(
-            image=off.render(), 
-            xy=cam.object_to_pixel(cube), 
-            frameid=anim.frameid
+            image=off.render(), xy=cam.object_to_pixel(cube), frameid=anim.frameid
         )
 
     # Data source
-    pub = btb.DataPublisher(btargs.btsockets['DATA'], btargs.btid)
+    pub = btb.DataPublisher(btargs.btsockets["DATA"], btargs.btid)
 
     # Setup default image rendering
     cam = btb.Camera()
-    off = btb.OffScreenRenderer(camera=cam, mode='rgb')
-    off.set_render_style(shading='RENDERED', overlays=False)
+    off = btb.OffScreenRenderer(camera=cam, mode="rgb")
+    off.set_render_style(shading="RENDERED", overlays=False)
 
     # Setup the animation and run endlessly
     anim = btb.AnimationController()
     anim.pre_frame.add(pre_frame)
-    anim.post_frame.add(post_frame, off, pub, anim, cam)    
-    anim.play(frame_range=(0,100), num_episodes=-1)
+    anim.post_frame.add(post_frame, off, pub, anim, cam)
+    anim.play(frame_range=(0, 100), num_episodes=-1)
+
 
-main()
+main()