Create artificial information for pc imaginative and prescient pipelines on AWS

mkdir nugget_images
ffmpeg -i VIDEO.mov ffmpeg nugget_images/nugget_percent06d.jpg

class Object3D:
	'''
	object container to retailer mesh details about the
	given object

	Returns
	the Object3D object
	'''
	def __init__(self, object: Union[bpy.types.Object, str]):
		"""Creates a Object3D object.

		Args:
		obj (Union[bpy.types.Object, str]): Scene object (or it is identify)
		"""
		self.object = object
		self.obj_poly = None
		self.mat = None
		self.vert = None
		self.poly = None
		self.bvht = None
		self.calc_mat()
		self.calc_world_vert()
		self.calc_poly()
		self.calc_bvht()

	def calc_mat(self) -> None:
		"""retailer an occasion of the article's matrix_world"""
		self.mat = self.object.matrix_world

	def calc_world_vert(self) -> None:
		"""calculate the verticies from object's matrix_world perspective"""
		self.vert = [self.mat @ v.co for v in self.object.data.vertices]
		self.obj_poly = np.array(self.vert)

	def calc_poly(self) -> None:
		"""retailer an occasion of the article's polygons"""
		self.poly = [p.vertices for p in self.object.data.polygons]

	def calc_bvht(self) -> None:
		"""create a BVHTree from the article's polygon"""
		self.bvht = BVHTree.FromPolygons( self.vert, self.poly )

	def regenerate(self) -> None:
		"""reinstantiate the article's variables;
		used when the article is manipulated after it is creation"""
		self.calc_mat()
		self.calc_world_vert()
		self.calc_poly()
		self.calc_bvht()

	def __repr__(self):
		return "Object3D: " + self.object.__repr__()

class DensityController:
    """Container that controlls the spacial relationship between 3D objects

    Returns:
        DensityController: The DensityController object.
    """
    def __init__(self):
        self.bvhtrees = None
        self.overlaps = None
        self.occupied = None
        self.unoccupied = None
        self.objects3d = []

    def auto_generate_kdtree_cubes(
        self,
        num_objects: int = 100, # max dimension of nuggets
    ) -> None:
        """
        operate to generate bodily kdtree cubes given a aircraft of -resize- dimension
        this enables us to entry every dice's overlap/occupancy standing at any given
        time
        
        creates a KDTree assortment, a dice, a set of particular person cubes, and the 
        BVHTree object for every particular person dice

        Args:
            resize (Tuple[float]): the dimensions of a dice to create XYZ.
            cuts (int): what number of cuts are made to the dice face
                12 cuts == 13 Rows x 13 Columns  
        """

        # learn the nugget,
        # see how giant the dice must be to embody a single nugget
        # then contact a parameter to permit it to be smaller or bigger (eg extra touching)
        bpy.context.view_layer.objects.energetic = bpy.context.scene.objects.get('nugget_base')
        bpy.ops.object.origin_set(sort="ORIGIN_GEOMETRY", middle="BOUNDS")
        #create a dice for the bounding field
        bpy.ops.mesh.primitive_cube_add(location=Vector((0,0,0))) 
        #our new dice is now the energetic object, so we are able to maintain observe of it in a variable:
        bound_box = bpy.context.active_object
        bound_box.identify="CUBE1"
        bpy.context.view_layer.replace()
        #copy transforms
        nug_dims = bpy.information.objects["nugget_base"].dimensions
        bpy.information.objects["CUBE1"].dimensions = nug_dims
        bpy.context.view_layer.replace()
        bpy.information.objects["CUBE1"].location = bpy.information.objects["nugget_base"].location
        bpy.context.view_layer.replace()
        bpy.information.objects["CUBE1"].rotation_euler = bpy.information.objects["nugget_base"].rotation_euler
        bpy.context.view_layer.replace()
        print("bound_box.dimensions: ", bound_box.dimensions)
        print("bound_box.location:", bound_box.location)

        # this dice created is not all the time sq., however we'll make it sq.
        # to suit into our 
        x, y, z = bound_box.dimensions
        v = max(x, y)
        if np.spherical(v) < v:
            v = np.spherical(v)+1
        bb_x, bb_y = v, v
        bound_box.dimensions = Vector((v, v, z))
        bpy.context.view_layer.replace()
        print("bound_box.dimensions up to date: ", bound_box.dimensions)
        # now we generate a aircraft
        # calc the dimensions of the aircraft given a max variety of containers.

        x, y, z = bound_box.dimensions
        bb_loc = bound_box.location
        bb_rot_eu = bound_box.rotation_euler
        min_area = (x*y)*num_objects
        min_length = min_area / num_objects
        print(min_length)
        # now we generate a aircraft
        # calc the dimensions of the aircraft given a max variety of containers.
        bpy.ops.mesh.primitive_plane_add(location=Vector((0,0,0)), dimension = min_length)
        aircraft = bpy.context.selected_objects[0]
        aircraft.identify="PLANE"
        # transfer our aircraft to our background assortment
        # current_collection = aircraft.users_collection
        link_object('PLANE', 'BACKGROUND')
        bpy.context.view_layer.replace()

        # New Assortment
        my_coll = bpy.information.collections.new("KDTREE")
        # Add assortment to scene assortment
        bpy.context.scene.assortment.kids.hyperlink(my_coll)
        # now we generate cubes based mostly on the dimensions of the aircraft.
        bpy.ops.mesh.primitive_cube_add(location=Vector((0,0,0)), dimension = min_length)
        bpy.context.view_layer.replace()
        dice = bpy.context.selected_objects[0]
        cube_dimensions = dice.dimensions
        bpy.context.view_layer.replace()
        dice.dimensions = Vector((cube_dimensions[0], cube_dimensions[1], z))
        bpy.context.view_layer.replace()
        dice.location = bb_loc
        bpy.context.view_layer.replace()
        dice.rotation_euler = bb_rot_eu
        bpy.context.view_layer.replace()
        dice.identify="dice"
        bpy.context.view_layer.replace()
        current_collection = dice.users_collection
        link_object('dice', 'KDTREE')
        bpy.context.view_layer.replace()

        # get the bb quantity and make the correct cuts to the article 
        bb_vol = x*y*z
        cube_vol = cube_dimensions[0]*cube_dimensions[1]*cube_dimensions[2]
        n_cubes = cube_vol / bb_vol
        cuts = n_cubes / ((x+y) / 2)
        cuts = int(np.spherical(cuts)) - 1 # 
        # choose the dice
        for object in bpy.information.objects:
            object.select_set(False)
        bpy.context.view_layer.replace()
        for object in bpy.information.objects:
            object.select_set(False)
        bpy.information.objects['cube'].select_set(True) # Blender 2.8x
        bpy.context.view_layer.objects.energetic = bpy.context.scene.objects.get('dice')
        # set to edit mode
        bpy.ops.object.mode_set(mode="EDIT", toggle=False)
        print('edit mode success')
        # get face_data
        context = bpy.context
        obj = context.edit_object
        me = obj.information
        mat = obj.matrix_world
        bm = bmesh.from_edit_mesh(me)
        up_face = None
        # choose upwards going through cube-face
        # https://blender.stackexchange.com/questions/43067/get-a-face-selected-pointing-upwards
        for face in bm.faces:
            if (face.normal-UP_VECTOR).size < EPSILON:
                up_face = face
                break
        assert(up_face)
        # subdivide the perimeters to get the right kdtree cubes
        bmesh.ops.subdivide_edges(bm,
                edges=up_face.edges,
                use_grid_fill=True,
                cuts=cuts)
        bpy.context.view_layer.replace()
        # get the middle level of every face

        face_data = {}
        sizes = []
        for f, face in enumerate(bm.faces): 
            face_data[f] = {}
            face_data[f]['calc_center_bounds'] = face.calc_center_bounds()
            loc = mat @ face_data[f]['calc_center_bounds']
            face_data[f]['loc'] = loc
            sizes.append(loc[-1])
        # get the most typical cube-z; we use this to find out the proper loc
        counter = Counter()
        counter.replace(sizes)
        most_common = counter.most_common()[0][0]
        cube_loc = mat @ dice.location
        # get out of edit mode
        bpy.ops.object.mode_set(mode="OBJECT", toggle=False)
        # go to new colection
        bvhtrees = {}
        for f in face_data:
            loc = face_data[f]['loc']
            loc = mat @ face_data[f]['calc_center_bounds']
            print(loc)
            if loc[-1] == most_common:
                # set it again right down to the ground as a result of the face is elevated to the
                # high floor of the dice
                loc[-1] = cube_loc[-1]
                bpy.ops.mesh.primitive_cube_add(location=loc, dimension = x)
                dice = bpy.context.selected_objects[0]
                dice.dimensions = Vector((x, y, z))
                # bpy.context.view_layer.replace()
                dice.identify = "cube_{}".format(f)
                #my_coll.objects.hyperlink(dice)
                link_object("cube_{}".format(f), 'KDTREE')
                #bpy.context.view_layer.replace()
                bvhtrees[f] = {
                    'occupied' : 0,
                    'object' : Object3D(dice)
                }
        for object in bpy.information.objects:
            object.select_set(False)
        bpy.information.objects['CUBE1'].select_set(True) # Blender 2.8x
        bpy.ops.object.delete()
        return bvhtrees

    def find_occupied_space(
        self, 
        objects3d: Record[Object3D],
    ) -> None:
        """
        uncover which dice's bvhtree is occupied in our kdtree house

        Args:
            listing of Object3D objects

        """
        rely = 0
        occupied = []
        for i in self.bvhtrees:
            bvhtree = self.bvhtrees[i]['object']
            for object3d in objects3d:
                if object3d.bvht.overlap(bvhtree.bvht):
                    self.bvhtrees[i]['occupied'] = 1

    def find_overlapping_objects(
        self, 
        objects3d: Record[Object3D],
    ) -> Record[Tuple[int]]:
        """
        returns which Object3D objects are overlapping

        Args:
            listing of Object3D objects
        
        Returns:
            Record of indicies from objects3d which might be overlap
        """
        rely = 0
        overlaps = []
        for i, x_object3d in enumerate(objects3d):
            for ii, y_object3d in enumerate(objects3d[i+1:]):
                if x_object3d.bvht.overlap(y_object3d.bvht):
                    overlaps.append((i, ii))
        return overlaps

    def calc_most_overlapped(
        self,
        overlaps: Record[Tuple[int]]
    ) -> Record[Tuple[int]]:
        """
        Algorithm to rely the variety of edges every index has
        and return a sorted listing from most->least with the quantity
        of edges every index has. 

        Args:
            listing of indicies which might be overlapping
        
        Returns:
            listing of indicies with the whole variety of overlapps they've 
            [index, count]
        """
        keys = {}
        for x,y in overlaps:
            if x not in keys:
                keys[x] = 0
            if y not in keys:
                keys[y] = 0
            keys[x]+=1
            keys[y]+=1
        # type by most edges first
        index_counts = sorted(keys.objects(), key=lambda x: x[1])[::-1]
        return index_counts
    
    def get_random_unoccupied(
        self
    ) -> Union[int,None]:
        """
        returns a randomly chosen unoccuped kdtree dice

        Return
            both the kdtree dice's key or None (which means all areas are
            presently occupied)
            Union[int,None]
        """
        unoccupied = []
        for i in self.bvhtrees:
            if not self.bvhtrees[i]['occupied']:
                unoccupied.append(i)
        if unoccupied:
            random.shuffle(unoccupied)
            return unoccupied[0]
        else:
            return None

    def regenerate(
        self,
        iterable: Union[None, List[Object3D]] = None
    ) -> None:
        """
        this operate recalculates every objects world-view info
        we default to None, which implies we're recalculating the self.bvhtree cubes

        Args:
            iterable (None or Record of Object3D objects). if None, we default to
            recalculating the kdtree
        """
        if isinstance(iterable, listing):
            for object in iterable:
                object.regenerate()
        else:
            for idx in self.bvhtrees:
                self.bvhtrees[idx]['object'].regenerate()
                self.update_tree(idx, occupied=0)       

    def process_trees_and_objects(
        self,
        objects3d: Record[Object3D],
    ) -> Record[Tuple[int]]:
        """
        This operate finds all overlapping objects inside objects3d,
        calculates the objects with probably the most overlaps, searches inside
        the kdtree dice house to see which cubes are occupied. It then returns 
        the edge-counts from probably the most overlapping objects

        Args:
            listing of Object3D objects
        Returns
            this returns the output of most_overlapped
        """
        overlaps = self.find_overlapping_objects(objects3d)
        most_overlapped = self.calc_most_overlapped(overlaps)
        self.find_occupied_space(objects3d)
        return most_overlapped

    def move_objects(
        self, 
        objects3d: Record[Object3D],
        most_overlapped: Record[Tuple[int]],
        z_increase_offset: float = 2.,
    ) -> None:
        """
        This operate iterates by means of most-overlapped, and makes use of 
        the index to extract the matching object from object3d - it then
        finds a random unoccupied kdtree dice and strikes the given overlapping
        object to that house. It does this for every index from the most-overlapped
        operate

        Args:
            objects3d: listing of Object3D objects
            most_overlapped: an inventory of tuples (index, rely) - the place index pertains to
                the place it is present in objects3d and rely - what number of instances it overlaps 
                with different objects
            z_increase_offset: this worth will increase the Z worth of the article so as to
                make it seem as if it is off the ground. In case you do not increase this worth
                the article appears to be like prefer it's 'inside' the bottom aircraft
        """
        for idx, cnt in most_overlapped:
            object3d = objects3d[idx]
            unoccupied_idx = self.get_random_unoccupied()
            if unoccupied_idx:
                object3d.object.location =  self.bvhtrees[unoccupied_idx]['object'].object.location
                # make sure the nuggest is above the groundplane
                object3d.object.location[-1] = z_increase_offset
                self.update_tree(unoccupied_idx, occupied=1)
    
    def dynamic_movement(
        self, 
        objects3d: Record[Object3D],
        tries: int = 100,
        z_offset: float = 2.,
    ) -> None:
        """
        This operate resets all objects to get their present positioning
        and randomly strikes objects round in an try and keep away from any object
        overlaps (we do not need two objects to be spawned in the identical place)

        Args:
            objects3d: listing of Object3D objects
            tries: int the variety of instances we wish to transfer objects to random areas
                to make sure no overlaps are current.
            z_offset: this worth will increase the Z worth of the article so as to
                make it seem as if it is off the ground. In case you do not increase this worth
                the article appears to be like prefer it's 'inside' the bottom aircraft (see `move_objects`)
        """
    
        # reset all objects
        self.regenerate(objects3d)
        # regenerate bvhtrees
        self.regenerate(None)

        most_overlapped = self.process_trees_and_objects(objects3d)
        makes an attempt = 0
        whereas most_overlapped:
            if makes an attempt>=tries:
                break
            self.move_objects(objects3d, most_overlapped, z_offset)
            makes an attempt+=1
            # recalc objects
            self.regenerate(objects3d)
            # regenerate bvhtrees
            self.regenerate(None)
            # recalculate overlaps
            most_overlapped = self.process_trees_and_objects(objects3d)

    def generate_spawn_point(
        self,
    ) -> Vector:
        """
        this operate generates a random spawn level by discovering which
        of the kdtree-cubes are unoccupied, and returns a type of

        Returns
            the Vector location of the kdtree-cube that is unoccupied
        """
        idx = self.get_random_unoccupied()
        print(idx)
        self.update_tree(idx, occupied=1)
        return self.bvhtrees[idx]['object'].object.location

    def update_tree(
        self,
        idx: int,
        occupied: int,
    ) -> None:
        """
        this operate updates the given state (occupied vs. unoccupied) of the
        kdtree given the idx

        Args:
            idx: int
            occupied: int
        """
        self.bvhtrees[idx]['occupied'] = occupied

@gin.configurable("run")
@zpy.blender.save_and_revert
def run(
    max_num_nuggets: int = 100,
    jitter_mesh: bool = True,
    jitter_nugget_scale: bool = True,
    jitter_material: bool = True,
    jitter_nugget_material: bool = False,
    number_of_random_materials: int = 50,
    nugget_texture_path: str = os.getcwd()+"/nugget_textures",
    annotations_path = os.getcwd()+'/nugget_data',
):
    """
    Foremost run operate.
    """
    density_controller = DensityController()
    # Random seed ends in distinctive habits
    zpy.blender.set_seed(random.randint(0,1000000000))

    # Create the saver object
    saver = zpy.saver_image.ImageSaver(
        description="Picture of the randomized Amazon nuggets",
        output_dir=annotations_path,
    )
    saver.add_category(identify="nugget")

    # Make an inventory of supply nugget objects
    source_nugget_objects = []
    for obj in zpy.objects.for_obj_in_collections(
        [
            bpy.data.collections["NUGGET"],
        ]
    ):
        assert(obj!=None)

        # move on the whole lot not named nugget
        if 'nugget_base' not in obj.identify:
            print('passing on {}'.format(obj.identify))
            proceed
        zpy.objects.section(obj, identify="nugget", as_category=True) #shade=nugget_seg_color
        print("zpy.objects.section: verify {}".format(obj.identify))
        source_nugget_objects.append(obj.identify)

    # transfer nugget level up 10 z's so it will not collide with base-cube
    bpy.information.objects["nugget_base"].location[-1] = 10

    # Save the place of the digital camera and light-weight
    # create mild and digital camera
    zpy.objects.save_pose("Digital camera")
    zpy.objects.save_pose("Solar")
    zpy.objects.save_pose("Airplane")
    zpy.objects.save_pose("Foremost Axis")
    axis = bpy.information.objects['Main Axis']
    print('saving poses')
    # add some parameters to this 

    # get the plane-3d object
    plane3d = Object3D(bpy.information.objects['Plane'])

    # generate kdtree cubes
    density_controller.generate_kdtree_cubes()

    # Pre-create a bunch of random textures
    #random_materials = [
    #    zpy.material.random_texture_mat() for _ in range(number_of_random_materials)
    #]
    p = os.path.abspath(os.getcwd()+'/random_textures')
    print(p)
    random_materials = []
    for x in os.listdir(p):
        texture_path = Path(os.path.be part of(p,x))
        y = zpy.materials.make_mat_from_texture(texture_path, identify=texture_path.stem)
        random_materials.append(y)
    #print(random_materials[0])

    # Pre-create a bunch of random textures
    random_nugget_materials = [
        random_nugget_texture_mat(Path(nugget_texture_path)) for _ in range(number_of_random_materials)
    ]

    # Run the sim.
    for step_idx in zpy.blender.step():
        density_controller.generate_kdtree_cubes()

        objects3d = []
        num_nuggets = random.randint(40, max_num_nuggets)
        log.information(f"Spawning {num_nuggets} nuggets.")
        spawned_nugget_objects = []
        for _ in vary(num_nuggets):

            # Select location to spawn nuggets
            spawn_point = density_controller.generate_spawn_point()
            # manually spawn above the ground
            # spawn_point[-1] = 1.8 #2.0

            # Decide a random object to spawn
            _name = random.selection(source_nugget_objects)
            log.information(f"Spawning a replica of supply nugget {_name} at {spawn_point}")
            obj = zpy.objects.copy(
                bpy.information.objects[_name],
                assortment=bpy.information.collections["SPAWNED"],
                is_copy=True,
            )

            obj.location = spawn_point
            obj.matrix_world = mathutils.Matrix.Translation(spawn_point)
            spawned_nugget_objects.append(obj)

            # Section the newly spawned nugget for instance
            zpy.objects.section(obj)

            # Jitter last pose of the nugget slightly
            zpy.objects.jitter(
                obj,
                rotate_range=(
                    (0.0, 0.0),
                    (0.0, 0.0),
                    (-math.pi * 2, math.pi * 2),
                ),
            )

            if jitter_nugget_scale:
                # Jitter the size of every nugget
                zpy.objects.jitter(
                    obj,
                    scale_range=(
                        (0.8, 2.0), #1.2
                        (0.8, 2.0), #1.2
                        (0.8, 2.0), #1.2
                    ),
                )

            if jitter_mesh:
                # Jitter (deform) the mesh of every nugget
                zpy.objects.jitter_mesh(
                    obj=obj,
                    scale=(
                        random.uniform(0.01, 0.03),
                        random.uniform(0.01, 0.03),
                        random.uniform(0.01, 0.03),
                    ),
                )

            if jitter_nugget_material:
                # Jitter the fabric (apperance) of every nugget
                for i in vary(len(obj.material_slots)):
                    obj.material_slots[i].materials = random.selection(random_nugget_materials)
                    zpy.materials.jitter(obj.material_slots[i].materials)          

            # create 3d obj for motion
            nugget3d = Object3D(obj)

            # be certain that the underside most a part of the nugget is NOT
            # contained in the plane-object       
            plane_overlap(plane3d, nugget3d)

            objects3d.append(nugget3d)

        # guarantee objects aren't on high of one another
        density_controller.dynamic_movement(objects3d)

        # Return digital camera to authentic place
        zpy.objects.restore_pose("Digital camera")
        zpy.objects.restore_pose("Foremost Axis")
        zpy.objects.restore_pose("Digital camera")
        zpy.objects.restore_pose("Foremost Axis")

        # assert these are the proper variations...
        assert(bpy.information.objects["Camera"].location == Vector((0,0,100)))
        assert(bpy.information.objects["Main Axis"].location == Vector((0,0,0)))
        assert(bpy.information.objects["Main Axis"].rotation_euler == Euler((0,0,0)))

        # alter the Z ditance with the digital camera
        bpy.information.objects["Camera"].location = (0, 0, random.uniform(0.75, 3.5)*100)

        # alter the main-axis beta/gamma params
        top_down_mostly = False 
        if top_down_mostly:
            zpy.objects.rotate(
                bpy.information.objects["Main Axis"],
                rotation=(
                    random.uniform(0.05, 0.05),
                    random.uniform(0.05, 0.05),
                    random.uniform(0.05, 0.05),
                ),
            )
        else:
            zpy.objects.rotate(
                bpy.information.objects["Main Axis"],
                rotation=(
                    random.uniform(-1., 1.),
                    random.uniform(-1., 1.),
                    random.uniform(-1., 1.),
                ),
            )

        print(bpy.information.objects["Main Axis"].rotation_euler)
        print(bpy.information.objects["Camera"].location)

        # change the background materials
        # Randomize texture of shelf, flooring and partitions
        for obj in bpy.information.collections["BACKGROUND"].all_objects:
            for i in vary(len(obj.material_slots)):
                # TODO
                # Decide one of many random supplies
                obj.material_slots[i].materials = random.selection(random_materials)
                if jitter_material:
                    zpy.materials.jitter(obj.material_slots[i].materials)
                # Units the fabric relative to the article
                obj.material_slots[i].hyperlink = "OBJECT"
        # Decide a random hdri (from the native textures folder for background background)
        zpy.hdris.random_hdri()
        # Return mild to authentic place
        zpy.objects.restore_pose("Solar")

        # Jitter the sunshine place
        zpy.objects.jitter(
            "Solar",
            translate_range=(
                (-5, 5),
                (-5, 5),
                (-5, 5),
            ),
        )
        bpy.information.objects["Sun"].information.vitality = random.uniform(0.5, 7)

# we disguise the dice objects<br />for obj in         # we disguise the dice objects
        for obj in bpy.information.objects:
            if 'dice' in obj.identify:
                obj.hide_render = True
                attempt:
                    zpy.objects.toggle_hidden(obj, hidden=True)
                besides:
                    # cope with this exception right here...
                    move
        # we disguise our base nugget object
        bpy.information.objects["nugget_base"].hide_render = True
        zpy.objects.toggle_hidden(bpy.information.objects["nugget_base"], hidden=True)

        # create the picture identify
        image_uuid = str(uuid.uuid4())

        # Identify for every of the output photographs
        rgb_image_name = format_image_string(image_uuid, 'rgb')
        iseg_image_name = format_image_string(image_uuid, 'iseg')
        depth_image_name = format_image_string(image_uuid, 'depth')

        zpy.render.render(
            rgb_path=saver.output_dir / rgb_image_name,
            iseg_path=saver.output_dir / iseg_image_name,
            depth_path=saver.output_dir / depth_image_name,
        )

        # Add photographs to saver
        saver.add_image(
            identify=rgb_image_name,
            type="default",
            output_path=saver.output_dir / rgb_image_name,
            body=step_idx,
        )
    
        saver.add_image(
            identify=iseg_image_name,
            type="segmentation",
            output_path=saver.output_dir / iseg_image_name,
            body=step_idx,
        )
        saver.add_image(
            identify=depth_image_name,
            type="depth",
            output_path=saver.output_dir / depth_image_name,
            body=step_idx,
        )

        # ideally on this thread, we'll open the anno file
        # and write to it straight, saving it after every technology
        for obj in spawned_nugget_objects:
            # Add annotation to segmentation picture
            saver.add_annotation(
                picture=rgb_image_name,
                class="nugget",
                seg_image=iseg_image_name,
                seg_color=tuple(obj.seg.instance_color),
            )

        # Delete the spawned nuggets
        zpy.objects.empty_collection(bpy.information.collections["SPAWNED"])

        # Write out annotations
        saver.output_annotated_images()
        saver.output_meta_analysis()

        # # ZUMO Annotations
        _output_zumo = _OutputZUMO(saver=saver, annotation_filename = Path(image_uuid + ".zumo.json"))
        _output_zumo.output_annotations()
        # change the identify right here..
        saver.output_annotated_images()
        saver.output_meta_analysis()

        # take away the reminiscence of the annotation to free RAM
        saver.annotations = []
        saver.photographs = {}
        saver.image_name_to_id = {}
        saver.seg_annotations_color_to_id = {}

    log.information("Simulation full.")

if __name__ == "__main__":

    # Set the logger ranges
    zpy.logging.set_log_levels("information")

    # Parse the gin-config textual content block
    # hack to learn a particular gin config
    parse_config_from_file('nugget_config.gin')

    # Run the sim
    run()

tar cvf working_blender_dir.tar.gz working_blender_dir
scp -i "your.pem" working_blender_dir.tar.gz [email protected]:/dwelling/ubuntu/working_blender_dir.tar.gz

tar xvf working_blender_dir.tar.gz

blender working_blender_dir/nugget.mix --background --python working_blender_dir/create_synthetic_nuggets.py

{
    "metadata": {
        "description": "3D information of a nugget!",
        "contributor": "Matt Krzus",
        "url": "[email protected]",
        "12 months": "2021",
        "date_created": "20210924_000000",
        "save_path": "/dwelling/ubuntu/working_blender_dir/nugget_data"
    },
    "classes": {
        "0": {
            "identify": "nugget",
            "supercategories": [],
            "subcategories": [],
            "shade": [
                0.0,
                0.0,
                0.0
            ],
            "rely": 6700,
            "subcategory_count": [],
            "id": 0
        }
    },
    "photographs": {
        "0": {
            "identify": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.rgb.png",
            "type": "default",
            "output_path": "/dwelling/ubuntu/working_blender_dir/nugget_data/a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.rgb.png",
            "relative_path": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.rgb.png",
            "body": 97,
            "width": 640,
            "top": 480,
            "id": 0
        },
        "1": {
            "identify": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.iseg.png",
            "type": "segmentation",
            "output_path": "/dwelling/ubuntu/working_blender_dir/nugget_data/a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.iseg.png",
            "relative_path": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.iseg.png",
            "body": 97,
            "width": 640,
            "top": 480,
            "id": 1
        },
        "2": {
            "identify": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.depth.png",
            "type": "depth",
            "output_path": "/dwelling/ubuntu/working_blender_dir/nugget_data/a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.depth.png",
            "relative_path": "a0bb1fd3-c2ec-403c-aacf-07e0c07f4fdd.depth.png",
            "body": 97,
            "width": 640,
            "top": 480,
            "id": 2
        }
    },
    "annotations": [
        {
            "image_id": 0,
            "category_id": 0,
            "id": 0,
            "seg_color": [
                1.0,
                0.6000000238418579,
                0.9333333373069763
            ],
            "shade": [
                1.0,
                0.6,
                0.9333333333333333
            ],
            "segmentation": [
                [
                    299.0,
                    308.99,
                    292.0,
                    308.99,
                    283.01,
                    301.0,
                    286.01,
                    297.0,
                    285.01,
                    294.0,
                    288.01,
                    285.0,
                    283.01,
                    275.0,
                    287.0,
                    271.01,
                    294.0,
                    271.01,
                    302.99,
                    280.0,
                    305.99,
                    286.0,
                    305.99,
                    303.0,
                    302.0,
                    307.99,
                    299.0,
                    308.99
                ]
            ],
            "bbox": [
                283.01,
                271.01,
                22.980000000000018,
                37.98000000000002
            ],
            "space": 667.0802000000008,
            "bboxes": [
                [
                    283.01,
                    271.01,
                    22.980000000000018,
                    37.98000000000002
                ]
            ],
            "areas": [
                667.0802000000008
            ]
        },
        {
            "image_id": 0,
            "category_id": 0,
            "id": 1,
            "seg_color": [
                1.0,
                0.4000000059604645,
                1.0
            ],
            "shade": [
                1.0,
                0.4,
                1.0
            ],
            "segmentation": [
                [
                    241.0,
                    273.99,
                    236.0,
                    271.99,
                    234.0,
                    273.99,
                    230.01,
                    270.0,
                    232.01,
                    268.0,
                    231.01,
                    263.0,
                    233.01,
                    261.0,
                    229.0,
                    257.99,
                    225.0,
                    257.99,
                    223.01,
                    255.0,
                    225.01,
                    253.0,
                    227.01,
                    246.0,
                    235.0,
                    239.01,
                    238.0,
                    239.01,
                    240.0,
                    237.01,
                    247.0,
                    237.01,
                    252.99,
                    245.0,
                    253.99,
                    252.0,
                    246.99,
                    269.0,
                    241.0,
                    273.99
                ]
            ],
            "bbox": [
                223.01,
                237.01,
                30.980000000000018,
                36.98000000000002
            ],
            "space": 743.5502000000008,
            "bboxes": [
                [
                    223.01,
                    237.01,
                    30.980000000000018,
                    36.98000000000002
                ]
            ],
            "areas": [
                743.5502000000008
            ]
        },
...
...
...