ansys-pyensight-core 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -24,98 +24,68 @@
 #
 ###############################################################################
 
-import argparse
 import logging
 import math
 import os
 import shutil
-import sys
+import tempfile
 from typing import Any, Dict, List, Optional
 
-import omni.client
+from ansys.pyensight.core.utils.dsg_server import Part, UpdateHandler
 import png
 from pxr import Gf, Sdf, Usd, UsdGeom, UsdLux, UsdShade
 
-sys.path.append(os.path.dirname(__file__))
-from dsg_server import DSGSession, Part, UpdateHandler  # noqa: E402
 
-
-class OmniverseWrapper:
-    verbose = 0
-
-    @staticmethod
-    def logCallback(threadName: None, component: Any, level: Any, message: str) -> None:
-        """
-        The logger method registered to handle async messages from Omniverse
-
-        If running in verbose mode, reroute the messages to Python Logging.
-        """
-        if OmniverseWrapper.verbose:
-            logging.info(message)
-
-    @staticmethod
-    def connectionStatusCallback(
-        url: Any, connectionStatus: "omni.client.ConnectionStatus"
-    ) -> None:
-        """
-        If no connection to Omniverse can be made, shut down the service.
-        """
-        if connectionStatus is omni.client.ConnectionStatus.CONNECT_ERROR:
-            sys.exit("[ERROR] Failed connection, exiting.")
-
-    def __init__(
-        self,
-        live_edit: bool = False,
-        path: str = "omniverse://localhost/Users/test",
-        verbose: int = 0,
-    ) -> None:
+class OmniverseWrapper(object):
+    def __init__(self, live_edit: bool = False, destination: str = "") -> None:
         self._cleaned_index = 0
         self._cleaned_names: dict = {}
         self._connectionStatusSubscription = None
         self._stage = None
-        self._destinationPath: str = path
+        self._destinationPath: str = ""
         self._old_stages: list = []
         self._stagename = "dsg_scene.usd"
         self._live_edit: bool = live_edit
         if self._live_edit:
             self._stagename = "dsg_scene.live"
-        OmniverseWrapper.verbose = verbose
-
-        omni.client.set_log_callback(OmniverseWrapper.logCallback)
-        if verbose > 1:
-            omni.client.set_log_level(omni.client.LogLevel.DEBUG)
+        # USD time slider will have 120 tick marks per second of animation time
+        self._time_codes_per_second = 120.0
 
-        if not omni.client.initialize():
-            sys.exit("[ERROR] Unable to initialize Omniverse client, exiting.")
+        if destination:
+            self.destination = destination
 
-        self._connectionStatusSubscription = omni.client.register_connection_status_callback(
-            OmniverseWrapper.connectionStatusCallback
-        )
-
-        if not self.isValidOmniUrl(self._destinationPath):
-            self.log("Note technically the Omniverse URL {self._destinationPath} is not valid")
+    @property
+    def destination(self) -> str:
+        """The current output directory."""
+        return self._destinationPath
 
-    def log(self, msg: str) -> None:
-        """
-        Local method to dispatch to whatever logging system has been enabled.
-        """
-        if OmniverseWrapper.verbose:
-            logging.info(msg)
+    @destination.setter
+    def destination(self, directory: str) -> None:
+        self._destinationPath = directory
+        if not self.is_valid_destination(directory):
+            logging.warning(f"Invalid destination path: {directory}")
 
     def shutdown(self) -> None:
         """
         Shutdown the connection to Omniverse cleanly.
         """
-        omni.client.live_wait_for_pending_updates()
         self._connectionStatusSubscription = None
-        omni.client.shutdown()
 
     @staticmethod
-    def isValidOmniUrl(url: str) -> bool:
-        omniURL = omni.client.break_url(url)
-        if omniURL.scheme == "omniverse" or omniURL.scheme == "omni":
-            return True
-        return False
+    def is_valid_destination(path: str) -> bool:
+        """
+        Verify that the target path is a writeable directory.
+
+        Parameters
+        ----------
+        path
+            The path to check
+
+        Returns
+        -------
+            True if the path is a writeable directory, False otherwise.
+        """
+        return os.access(path, os.W_OK)
 
     def stage_url(self, name: Optional[str] = None) -> str:
         """
@@ -131,21 +101,31 @@ class OmniverseWrapper:
         """
         if name is None:
             name = self._stagename
-        return self._destinationPath + "/" + name
+        return os.path.join(self._destinationPath, name)
 
     def delete_old_stages(self) -> None:
         """
         Remove all the stages included in the "_old_stages" list.
+        If a stage is in use and cannot be removed, keep its name in _old_stages
+        to retry later.
         """
+        stages_unremoved = list()
         while self._old_stages:
             stage = self._old_stages.pop()
-            omni.client.delete(stage)
+            try:
+                if os.path.isfile(stage):
+                    os.remove(stage)
+                else:
+                    shutil.rmtree(stage, ignore_errors=True, onerror=None)
+            except OSError:
+                stages_unremoved.append(stage)
+        self._old_stages = stages_unremoved
 
     def create_new_stage(self) -> None:
         """
         Create a new stage. using the current stage name.
         """
-        self.log(f"Creating Omniverse stage: {self.stage_url()}")
+        logging.info(f"Creating Omniverse stage: {self.stage_url()}")
         if self._stage:
             self._stage.Unload()
             self._stage = None
@@ -156,7 +136,7 @@ class OmniverseWrapper:
         UsdGeom.SetStageUpAxis(self._stage, UsdGeom.Tokens.y)
         # in M
         UsdGeom.SetStageMetersPerUnit(self._stage, 1.0)
-        self.log(f"Created stage: {self.stage_url()}")
+        logging.info(f"Created stage: {self.stage_url()}")
 
     def save_stage(self, comment: str = "") -> None:
         """
@@ -165,45 +145,6 @@ class OmniverseWrapper:
         Presently, live connections are disabled.
         """
         self._stage.GetRootLayer().Save()  # type:ignore
-        omni.client.live_process()
-
-    # This function will add a commented checkpoint to a file on Nucleus if
-    # the Nucleus server supports checkpoints
-    def checkpoint(self, comment: str = "") -> None:
-        """
-        Add a checkpoint to the current stage.
-
-        Parameters
-        ----------
-        comment: str
-            If not empty, the comment to be added to the stage
-        """
-        if not comment:
-            return
-        result, serverInfo = omni.client.get_server_info(self.stage_url())
-        if result and serverInfo and serverInfo.checkpoints_enabled:
-            bForceCheckpoint = True
-            self.log(f"Adding checkpoint comment <{comment}> to stage <{self.stage_url()}>")
-            omni.client.create_checkpoint(self.stage_url(), comment, bForceCheckpoint)
-
-    def username(self, display: bool = True) -> Optional[str]:
-        """
-        Get the username of the current user.
-
-        Parameters
-        ----------
-        display : bool, optional if True, send the username to the logging system.
-
-        Returns
-        -------
-        The username or None.
-        """
-        result, serverInfo = omni.client.get_server_info(self.stage_url())
-        if serverInfo:
-            if display:
-                self.log(f"Connected username:{serverInfo.username}")
-            return serverInfo.username
-        return None
 
     def clear_cleaned_names(self) -> None:
         """
@@ -305,6 +246,7 @@ class OmniverseWrapper:
         self,
         name,
         id,
+        part_hash,
         parent_prim,
         verts,
         conn,
@@ -318,46 +260,64 @@ class OmniverseWrapper:
     ):
         # 1D texture map for variables https://graphics.pixar.com/usd/release/tut_simple_shading.html
         # create the part usd object
-        partname = self.clean_name(name + str(id) + str(timeline[0]))
+        partname = self.clean_name(name + part_hash.hexdigest())
         stage_name = "/Parts/" + partname + ".usd"
-        part_stage_url = self.stage_url(stage_name)
-        omni.client.delete(part_stage_url)
-        part_stage = Usd.Stage.CreateNew(part_stage_url)
-        self._old_stages.append(part_stage_url)
-        xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
-        mesh = UsdGeom.Mesh.Define(part_stage, "/" + partname + "/Mesh")
-        # mesh.CreateDisplayColorAttr()
-        mesh.CreateDoubleSidedAttr().Set(True)
-        mesh.CreatePointsAttr(verts)
-        mesh.CreateNormalsAttr(normals)
-        mesh.CreateFaceVertexCountsAttr([3] * int(conn.size / 3))
-        mesh.CreateFaceVertexIndicesAttr(conn)
-        if (tcoords is not None) and variable:
-            # USD 22.08 changed the primvar API
-            if hasattr(mesh, "CreatePrimvar"):
-                texCoords = mesh.CreatePrimvar(
-                    "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
-                )
-            else:
-                primvarsAPI = UsdGeom.PrimvarsAPI(mesh)
-                texCoords = primvarsAPI.CreatePrimvar(
-                    "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
-                )
-            texCoords.Set(tcoords)
-            texCoords.SetInterpolation("vertex")
-        # sphere = part_stage.DefinePrim('/' + partname + '/sphere', 'Sphere')
-        part_prim = part_stage.GetPrimAtPath("/" + partname)
-        part_stage.SetDefaultPrim(part_prim)
-
-        # Currently, this will never happen, but it is a setup for rigid body transforms
-        # At present, the group transforms have been cooked into the vertices so this is not needed
-        matrixOp = xform.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble)
-        matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
-
-        self.create_dsg_material(
-            part_stage, mesh, "/" + partname, diffuse=diffuse, variable=variable
-        )
+        part_stage_url = self.stage_url(os.path.join("Parts", partname + ".usd"))
+        part_stage = None
+
+        if not os.path.exists(part_stage_url):
+            part_stage = Usd.Stage.CreateNew(part_stage_url)
+            self._old_stages.append(part_stage_url)
+            xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
+            mesh = UsdGeom.Mesh.Define(part_stage, "/" + partname + "/Mesh")
+            # mesh.CreateDisplayColorAttr()
+            mesh.CreateDoubleSidedAttr().Set(True)
+            mesh.CreatePointsAttr(verts)
+            mesh.CreateNormalsAttr(normals)
+            mesh.CreateFaceVertexCountsAttr([3] * int(conn.size / 3))
+            mesh.CreateFaceVertexIndicesAttr(conn)
+            if (tcoords is not None) and variable:
+                # USD 22.08 changed the primvar API
+                if hasattr(mesh, "CreatePrimvar"):
+                    texCoords = mesh.CreatePrimvar(
+                        "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
+                    )
+                else:
+                    primvarsAPI = UsdGeom.PrimvarsAPI(mesh)
+                    texCoords = primvarsAPI.CreatePrimvar(
+                        "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
+                    )
+                texCoords.Set(tcoords)
+                texCoords.SetInterpolation("vertex")
+            part_prim = part_stage.GetPrimAtPath("/" + partname)
+            part_stage.SetDefaultPrim(part_prim)
+
+            # Currently, this will never happen, but it is a setup for rigid body transforms
+            # At present, the group transforms have been cooked into the vertices so this is not needed
+            matrixOp = xform.AddXformOp(
+                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
+            )
+            matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
+
+            self.create_dsg_material(
+                part_stage, mesh, "/" + partname, diffuse=diffuse, variable=variable
+            )
 
+        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
+
+        # glue it into our stage
+        path = timestep_prim.GetPath().AppendChild("part_ref_" + partname)
+        part_ref = self._stage.OverridePrim(path)
+        part_ref.GetReferences().AddReference("." + stage_name)
+
+        if part_stage is not None:
+            part_stage.GetRootLayer().Save()
+
+        return part_stage_url
+
+    def add_timestep_group(
+        self, parent_prim: UsdGeom.Xform, timeline: List[float], first_timestep: bool
+    ) -> UsdGeom.Xform:
         # add a layer in the group hierarchy for the timestep
         timestep_group_path = parent_prim.GetPath().AppendChild(
             self.clean_name("t" + str(timeline[0]), None)
@@ -368,17 +328,72 @@ class OmniverseWrapper:
             visibility_attr.Set("inherited", Usd.TimeCode.EarliestTime())
         else:
             visibility_attr.Set("invisible", Usd.TimeCode.EarliestTime())
-        visibility_attr.Set("inherited", timeline[0])
+        visibility_attr.Set("inherited", timeline[0] * self._time_codes_per_second)
         # Final timestep has timeline[0]==timeline[1].  Leave final timestep visible.
         if timeline[0] < timeline[1]:
-            visibility_attr.Set("invisible", timeline[1])
+            visibility_attr.Set("invisible", timeline[1] * self._time_codes_per_second)
+        return timestep_prim
+
+    def create_dsg_points(
+        self,
+        name,
+        id,
+        part_hash,
+        parent_prim,
+        verts,
+        sizes,
+        colors,
+        matrix=[1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+        default_size=1.0,
+        default_color=[1.0, 1.0, 1.0, 1.0],
+        timeline=[0.0, 0.0],
+        first_timestep=False,
+    ):
+        # create the part usd object
+        partname = self.clean_name(name + part_hash.hexdigest())
+        stage_name = "/Parts/" + partname + ".usd"
+        part_stage_url = self.stage_url(os.path.join("Parts", partname + ".usd"))
+        part_stage = None
+
+        if not os.path.exists(part_stage_url):
+            part_stage = Usd.Stage.CreateNew(part_stage_url)
+            self._old_stages.append(part_stage_url)
+            xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
+
+            points = UsdGeom.Points.Define(part_stage, "/" + partname + "/Points")
+            # points.GetPointsAttr().Set(Vt.Vec3fArray(verts.tolist()))
+            points.GetPointsAttr().Set(verts)
+            if sizes is not None and sizes.size == (verts.size // 3):
+                points.GetWidthsAttr().Set(sizes)
+            else:
+                points.GetWidthsAttr().Set([default_size] * (verts.size // 3))
+
+            colorAttr = points.GetPrim().GetAttribute("primvars:displayColor")
+            colorAttr.SetMetadata("interpolation", "vertex")
+            if colors is not None and colors.size == verts.size:
+                colorAttr.Set(colors)
+            else:
+                colorAttr.Set([default_color[0:3]] * (verts.size // 3))
+
+            part_prim = part_stage.GetPrimAtPath("/" + partname)
+            part_stage.SetDefaultPrim(part_prim)
+
+            # Currently, this will never happen, but it is a setup for rigid body transforms
+            # At present, the group transforms have been cooked into the vertices so this is not needed
+            matrixOp = xform.AddXformOp(
+                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
+            )
+            matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
+
+        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
 
         # glue it into our stage
         path = timestep_prim.GetPath().AppendChild("part_ref_" + partname)
         part_ref = self._stage.OverridePrim(path)
         part_ref.GetReferences().AddReference("." + stage_name)
 
-        part_stage.GetRootLayer().Save()
+        if part_stage is not None:
+            part_stage.GetRootLayer().Save()
 
         return part_stage_url
 
@@ -424,25 +439,25 @@ class OmniverseWrapper:
         return material
 
     def create_dsg_variable_textures(self, variables):
-        # make folder:   scratch/Textures/{palette_*.png}
-        shutil.rmtree("scratch", ignore_errors=True, onerror=None)
-        os.makedirs("scratch/Textures", exist_ok=True)
-        for var in variables.values():
-            data = bytearray(var.texture)
-            n_pixels = int(len(data) / 4)
-            row = []
-            for i in range(n_pixels):
-                row.append(data[i * 4 + 0])
-                row.append(data[i * 4 + 1])
-                row.append(data[i * 4 + 2])
-            io = png.Writer(width=n_pixels, height=2, bitdepth=8, greyscale=False)
-            rows = [row, row]
-            name = self.clean_name(var.name)
-            with open(f"scratch/Textures/palette_{name}.png", "wb") as fp:
-                io.write(fp, rows)
-        uriPath = self._destinationPath + "/Parts/Textures"
-        omni.client.delete(uriPath)
-        omni.client.copy("scratch/Textures", uriPath)
+        with tempfile.TemporaryDirectory() as tempdir:
+            # make folder:   {tempdir}/scratch/Textures/{palette_*.png}
+            os.makedirs(f"{tempdir}/scratch/Textures", exist_ok=True)
+            for var in variables.values():
+                data = bytearray(var.texture)
+                n_pixels = int(len(data) / 4)
+                row = []
+                for i in range(n_pixels):
+                    row.append(data[i * 4 + 0])
+                    row.append(data[i * 4 + 1])
+                    row.append(data[i * 4 + 2])
+                io = png.Writer(width=n_pixels, height=2, bitdepth=8, greyscale=False)
+                rows = [row, row]
+                name = self.clean_name(var.name)
+                with open(f"{tempdir}/scratch/Textures/palette_{name}.png", "wb") as fp:
+                    io.write(fp, rows)
+            uriPath = self._destinationPath + "/Parts/Textures"
+            shutil.rmtree(uriPath, ignore_errors=True, onerror=None)
+            shutil.copytree(f"{tempdir}/scratch/Textures", uriPath)
 
     def create_dsg_root(self):
         root_name = "/Root"
@@ -521,99 +536,14 @@ class OmniverseWrapper:
                 UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
             )
             matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
-            self.log(f"Created group:'{name}' {str(obj_type)}")
+            logging.info(f"Created group:'{name}' {str(obj_type)}")
         return group_prim
 
     def uploadMaterial(self):
         uriPath = self._destinationPath + "/Materials"
-        omni.client.delete(uriPath)
+        shutil.rmtree(uriPath, ignore_errors=True, onerror=None)
         fullpath = os.path.join(os.path.dirname(__file__), "resources", "Materials")
-        omni.client.copy(fullpath, uriPath)
-
-    def createMaterial(self, mesh):
-        # Create a material instance for this in USD
-        materialName = "Fieldstone"
-        newMat = UsdShade.Material.Define(self._stage, "/Root/Looks/Fieldstone")
-
-        matPath = "/Root/Looks/Fieldstone"
-
-        # MDL Shader
-        # Create the MDL shader
-        mdlShader = UsdShade.Shader.Define(self._stage, matPath + "/Fieldstone")
-        mdlShader.CreateIdAttr("mdlMaterial")
-
-        mdlShaderModule = "./Materials/Fieldstone.mdl"
-        mdlShader.SetSourceAsset(mdlShaderModule, "mdl")
-        # mdlShader.GetPrim().CreateAttribute("info:mdl:sourceAsset:subIdentifier",
-        #                                    Sdf.ValueTypeNames.Token, True).Set(materialName)
-        # mdlOutput = newMat.CreateSurfaceOutput("mdl")
-        # mdlOutput.ConnectToSource(mdlShader, "out")
-        mdlShader.SetSourceAssetSubIdentifier(materialName, "mdl")
-        shaderOutput = mdlShader.CreateOutput("out", Sdf.ValueTypeNames.Token)
-        shaderOutput.SetRenderType("material")
-        newMat.CreateSurfaceOutput("mdl").ConnectToSource(shaderOutput)
-        newMat.CreateDisplacementOutput("mdl").ConnectToSource(shaderOutput)
-        newMat.CreateVolumeOutput("mdl").ConnectToSource(shaderOutput)
-
-        # USD Preview Surface Shaders
-
-        # Create the "USD Primvar reader for float2" shader
-        primStShader = UsdShade.Shader.Define(self._stage, matPath + "/PrimST")
-        primStShader.CreateIdAttr("UsdPrimvarReader_float2")
-        primStShader.CreateOutput("result", Sdf.ValueTypeNames.Float2)
-        primStShader.CreateInput("varname", Sdf.ValueTypeNames.Token).Set("st")
-
-        # Create the "Diffuse Color Tex" shader
-        diffuseColorShader = UsdShade.Shader.Define(self._stage, matPath + "/DiffuseColorTex")
-        diffuseColorShader.CreateIdAttr("UsdUVTexture")
-        texInput = diffuseColorShader.CreateInput("file", Sdf.ValueTypeNames.Asset)
-        texInput.Set("./Materials/Fieldstone/Fieldstone_BaseColor.png")
-        texInput.GetAttr().SetColorSpace("RGB")
-        diffuseColorShader.CreateInput("st", Sdf.ValueTypeNames.Float2).ConnectToSource(
-            primStShader.CreateOutput("result", Sdf.ValueTypeNames.Float2)
-        )
-        diffuseColorShaderOutput = diffuseColorShader.CreateOutput("rgb", Sdf.ValueTypeNames.Float3)
-
-        # Create the "Normal Tex" shader
-        normalShader = UsdShade.Shader.Define(self._stage, matPath + "/NormalTex")
-        normalShader.CreateIdAttr("UsdUVTexture")
-        normalTexInput = normalShader.CreateInput("file", Sdf.ValueTypeNames.Asset)
-        normalTexInput.Set("./Materials/Fieldstone/Fieldstone_N.png")
-        normalTexInput.GetAttr().SetColorSpace("RAW")
-        normalShader.CreateInput("st", Sdf.ValueTypeNames.Float2).ConnectToSource(
-            primStShader.CreateOutput("result", Sdf.ValueTypeNames.Float2)
-        )
-        normalShaderOutput = normalShader.CreateOutput("rgb", Sdf.ValueTypeNames.Float3)
-
-        # Create the USD Preview Surface shader
-        usdPreviewSurfaceShader = UsdShade.Shader.Define(self._stage, matPath + "/PreviewSurface")
-        usdPreviewSurfaceShader.CreateIdAttr("UsdPreviewSurface")
-        diffuseColorInput = usdPreviewSurfaceShader.CreateInput(
-            "diffuseColor", Sdf.ValueTypeNames.Color3f
-        )
-        diffuseColorInput.ConnectToSource(diffuseColorShaderOutput)
-        normalInput = usdPreviewSurfaceShader.CreateInput("normal", Sdf.ValueTypeNames.Normal3f)
-        normalInput.ConnectToSource(normalShaderOutput)
-
-        # Set the linkage between material and USD Preview surface shader
-        # usdPreviewSurfaceOutput = newMat.CreateSurfaceOutput()
-        # usdPreviewSurfaceOutput.ConnectToSource(usdPreviewSurfaceShader, "surface")
-        # UsdShade.MaterialBindingAPI(mesh).Bind(newMat)
-
-        usdPreviewSurfaceShaderOutput = usdPreviewSurfaceShader.CreateOutput(
-            "surface", Sdf.ValueTypeNames.Token
-        )
-        usdPreviewSurfaceShaderOutput.SetRenderType("material")
-        newMat.CreateSurfaceOutput().ConnectToSource(usdPreviewSurfaceShaderOutput)
-
-        UsdShade.MaterialBindingAPI.Apply(mesh.GetPrim()).Bind(newMat)
-
-    # Create a distant light in the scene.
-    def createDistantLight(self):
-        newLight = UsdLux.DistantLight.Define(self._stage, "/Root/DistantLight")
-        newLight.CreateAngleAttr(0.53)
-        newLight.CreateColorAttr(Gf.Vec3f(1.0, 1.0, 0.745))
-        newLight.CreateIntensityAttr(500.0)
+        shutil.copytree(fullpath, uriPath)
 
     # Create a dome light in the scene.
     def createDomeLight(self, texturePath):
@@ -627,13 +557,6 @@ class OmniverseWrapper:
         rotateOp = xForm.AddXformOp(UsdGeom.XformOp.TypeRotateZYX, UsdGeom.XformOp.PrecisionFloat)
         rotateOp.Set(Gf.Vec3f(270, 0, 0))
 
-    def createEmptyFolder(self, emptyFolderPath):
-        folder = self._destinationPath + emptyFolderPath
-        self.log(f"Creating new folder: {folder}")
-        result = omni.client.create_folder(folder)
-        self.log(f"Finished creating: {result.name}")
-        return result.name
-
 
 class OmniverseUpdateHandler(UpdateHandler):
     """
@@ -670,10 +593,13 @@ class OmniverseUpdateHandler(UpdateHandler):
             self._group_prims[id] = self._root_prim
 
             if self._omni._stage is not None:
-                self._omni._stage.SetStartTimeCode(self.session.time_limits[0])
-                self._omni._stage.SetEndTimeCode(self.session.time_limits[1])
-                self._omni._stage.SetTimeCodesPerSecond(1)
-                self._omni._stage.SetFramesPerSecond(1)
+                self._omni._stage.SetStartTimeCode(
+                    self.session.time_limits[0] * self._omni._time_codes_per_second
+                )
+                self._omni._stage.SetEndTimeCode(
+                    self.session.time_limits[1] * self._omni._time_codes_per_second
+                )
+                self._omni._stage.SetTimeCodesPerSecond(self._omni._time_codes_per_second)
 
             # Send the variable textures.  Safe to do so once the first view is processed.
             if not self._sent_textures:
@@ -685,34 +611,56 @@ class OmniverseUpdateHandler(UpdateHandler):
 
     def finalize_part(self, part: Part) -> None:
         # generate an Omniverse compliant mesh from the Part
-        command, verts, conn, normals, tcoords, var_cmd = part.nodal_surface_rep()
-        if command is None:
+        if part is None or part.cmd is None:
             return
-        parent_prim = self._group_prims[command.parent_id]
+        parent_prim = self._group_prims[part.cmd.parent_id]
         obj_id = self.session.mesh_block_count
-        matrix = command.matrix4x4
-        name = command.name
+        matrix = part.cmd.matrix4x4
+        name = part.cmd.name
         color = [
-            command.fill_color[0] * command.diffuse,
-            command.fill_color[1] * command.diffuse,
-            command.fill_color[2] * command.diffuse,
-            command.fill_color[3],
+            part.cmd.fill_color[0] * part.cmd.diffuse,
+            part.cmd.fill_color[1] * part.cmd.diffuse,
+            part.cmd.fill_color[2] * part.cmd.diffuse,
+            part.cmd.fill_color[3],
         ]
-        # Generate the mesh block
-        _ = self._omni.create_dsg_mesh_block(
-            name,
-            obj_id,
-            parent_prim,
-            verts,
-            conn,
-            normals,
-            tcoords,
-            matrix=matrix,
-            diffuse=color,
-            variable=var_cmd,
-            timeline=self.session.cur_timeline,
-            first_timestep=(self.session.cur_timeline[0] == self.session.time_limits[0]),
-        )
+
+        if part.cmd.render == part.cmd.CONNECTIVITY:
+            command, verts, conn, normals, tcoords, var_cmd = part.nodal_surface_rep()
+            if command is not None:
+                # Generate the mesh block
+                _ = self._omni.create_dsg_mesh_block(
+                    name,
+                    obj_id,
+                    part.hash,
+                    parent_prim,
+                    verts,
+                    conn,
+                    normals,
+                    tcoords,
+                    matrix=matrix,
+                    diffuse=color,
+                    variable=var_cmd,
+                    timeline=self.session.cur_timeline,
+                    first_timestep=(self.session.cur_timeline[0] == self.session.time_limits[0]),
+                )
+
+        elif part.cmd.render == part.cmd.NODES:
+            command, verts, sizes, colors, var_cmd = part.point_rep()
+            if command is not None:
+                _ = self._omni.create_dsg_points(
+                    name,
+                    obj_id,
+                    part.hash,
+                    parent_prim,
+                    verts,
+                    sizes,
+                    colors,
+                    matrix=matrix,
+                    default_size=part.cmd.node_size_default,
+                    default_color=color,
+                    timeline=self.session.cur_timeline,
+                    first_timestep=(self.session.cur_timeline[0] == self.session.time_limits[0]),
+                )
         super().finalize_part(part)
 
     def start_connection(self) -> None:
@@ -740,141 +688,3 @@ class OmniverseUpdateHandler(UpdateHandler):
         super().end_update()
         # Stage update complete
         self._omni.save_stage()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Python Omniverse EnSight Dynamic Scene Graph Client",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    )
-    parser.add_argument(
-        "--path",
-        action="store",
-        default="omniverse://localhost/Users/test",
-        help="Omniverse pathname. Default=omniverse://localhost/Users/test",
-    )
-    parser.add_argument(
-        "--port",
-        metavar="ensight_grpc_port",
-        nargs="?",
-        default=12345,
-        type=int,
-        help="EnSight gRPC port number",
-    )
-    parser.add_argument(
-        "--host",
-        metavar="ensight_grpc_host",
-        nargs="?",
-        default="127.0.0.1",
-        type=str,
-        help="EnSight gRPC hostname",
-    )
-    parser.add_argument(
-        "--security",
-        metavar="ensight_grpc_security_code",
-        nargs="?",
-        default="",
-        type=str,
-        help="EnSight gRPC security code",
-    )
-    parser.add_argument(
-        "--verbose",
-        metavar="verbose_level",
-        default=0,
-        type=int,
-        help="Enable debugging information",
-    )
-    parser.add_argument(
-        "--animation", dest="animation", action="store_true", help="Save all timesteps (default)"
-    )
-    parser.add_argument(
-        "--no-animation",
-        dest="animation",
-        action="store_false",
-        help="Save only the current timestep",
-    )
-    parser.set_defaults(animation=False)
-    parser.add_argument(
-        "--log_file",
-        metavar="log_filename",
-        default="",
-        type=str,
-        help="Save program output to the named log file instead of stdout",
-    )
-    parser.add_argument(
-        "--live",
-        dest="live",
-        action="store_true",
-        default=False,
-        help="Enable continuous operation",
-    )
-    parser.add_argument(
-        "--normalize_geometry",
-        dest="normalize",
-        action="store_true",
-        default=False,
-        help="Spatially normalize incoming geometry",
-    )
-    parser.add_argument(
-        "--vrmode",
-        dest="vrmode",
-        action="store_true",
-        default=False,
-        help="In this mode do not include a camera or the case level matrix.  Geometry only.",
-    )
-    args = parser.parse_args()
-
-    log_args = dict(format="DSG/Omniverse: %(message)s", level=logging.INFO)
-    if args.log_file:
-        log_args["filename"] = args.log_file
-    logging.basicConfig(**log_args)  # type: ignore
-
-    destinationPath = args.path
-    loggingEnabled = args.verbose
-
-    # Build the OmniVerse connection
-    target = OmniverseWrapper(path=destinationPath, verbose=loggingEnabled, live_edit=args.live)
-    # Print the username for the server
-    target.username()
-
-    if loggingEnabled:
-        logging.info("Omniverse connection established.")
-
-    # link it to a DSG session
-    update_handler = OmniverseUpdateHandler(target)
-    dsg_link = DSGSession(
-        port=args.port,
-        host=args.host,
-        vrmode=args.vrmode,
-        security_code=args.security,
-        verbose=loggingEnabled,
-        normalize_geometry=args.normalize,
-        handler=update_handler,
-    )
-
-    if loggingEnabled:
-        dsg_link.log(f"Making DSG connection to: {args.host}:{args.port}")
-
-    # Start the DSG link
-    err = dsg_link.start()
-    if err < 0:
-        sys.exit(err)
-
-    # Simple pull request
-    dsg_link.request_an_update(animation=args.animation)
-    # Handle the update block
-    dsg_link.handle_one_update()
-
-    # Live operation
-    if args.live:
-        if loggingEnabled:
-            dsg_link.log("Waiting for remote push operations")
-        while not dsg_link.is_shutdown():
-            dsg_link.handle_one_update()
-
-    # Done...
-    if loggingEnabled:
-        dsg_link.log("Shutting down DSG connection")
-    dsg_link.end()
-
-    target.shutdown()