Add support for DSG lines in OV export (#467)

src/ansys/pyensight/core/utils/dsg_server.py

@@ -142,7 +142,7 @@ def nodal_surface_rep(self):
             self.session.log(f"Note: part '{self.cmd.name}' contains no triangles.")
             return None, None, None, None, None, None
         verts = self.coords
-        self.normalize_verts(verts)
+        _ = self._normalize_verts(verts)
 
         conn = self.conn_tris
         normals = self.normals
@@ -151,7 +151,7 @@ def nodal_surface_rep(self):
             tcoords = self.tcoords
         if self.tcoords_elem or self.normals_elem:
             verts_per_prim = 3
-            num_prims = int(conn.size / verts_per_prim)
+            num_prims = conn.size // verts_per_prim
             # "flatten" the triangles to move values from elements to nodes
             new_verts = numpy.ndarray((num_prims * verts_per_prim * 3,), dtype="float32")
             new_conn = numpy.ndarray((num_prims * verts_per_prim,), dtype="int32")
@@ -205,47 +205,16 @@ def nodal_surface_rep(self):
         var_cmd = None
         # texture coords need transformation from variable value to [ST]
         if tcoords is not None:
-            var_dsg_id = self.cmd.color_variableid
-            var_cmd = self.session.variables[var_dsg_id]
-            v_min = None
-            v_max = None
-            for lvl in var_cmd.levels:
-                if (v_min is None) or (v_min > lvl.value):
-                    v_min = lvl.value
-                if (v_max is None) or (v_max < lvl.value):
-                    v_max = lvl.value
-            var_minmax = [v_min, v_max]
-            # build a power of two x 1 texture
-            num_texels = int(len(var_cmd.texture) / 4)
-            half_texel = 1 / (num_texels * 2.0)
-            num_verts = int(verts.size / 3)
-            tmp = numpy.ndarray((num_verts * 2,), dtype="float32")
-            tmp.fill(0.5)  # fill in the T coordinate...
-            tex_width = half_texel * 2 * (num_texels - 1)  # center to center of num_texels
-            # if the range is 0, adjust the min by -1.   The result is that the texture
-            # coords will get mapped to S=1.0 which is what EnSight does in this situation
-            if (var_minmax[1] - var_minmax[0]) == 0.0:
-                var_minmax[0] = var_minmax[0] - 1.0
-            var_width = var_minmax[1] - var_minmax[0]
-            for idx in range(num_verts):
-                # normalized S coord value (clamp)
-                s = (tcoords[idx] - var_minmax[0]) / var_width
-                if s < 0.0:
-                    s = 0.0
-                if s > 1.0:
-                    s = 1.0
-                # map to the texture range and set the S value
-                tmp[idx * 2] = s * tex_width + half_texel
-            tcoords = tmp
+            tcoords, var_cmd = self._build_st_coords(tcoords, verts.size // 3)
 
         self.session.log(
-            f"Part '{self.cmd.name}' defined: {self.coords.size/3} verts, {self.conn_tris.size/3} tris."
+            f"Part '{self.cmd.name}' defined: {self.coords.size // 3} verts, {self.conn_tris.size // 3} tris."
         )
         command = self.cmd
 
         return command, verts, conn, normals, tcoords, var_cmd
 
-    def normalize_verts(self, verts: numpy.ndarray):
+    def _normalize_verts(self, verts: numpy.ndarray):
         """
         This function scales and translates vertices, so the longest axis in the scene is of
         length 1.0, and data is centered at the origin
@@ -254,7 +223,7 @@ def normalize_verts(self, verts: numpy.ndarray):
         """
         s = 1.0
         if self.session.normalize_geometry and self.session.scene_bounds is not None:
-            num_verts = int(verts.size / 3)
+            num_verts = verts.size // 3
             midx = (self.session.scene_bounds[3] + self.session.scene_bounds[0]) * 0.5
             midy = (self.session.scene_bounds[4] + self.session.scene_bounds[1]) * 0.5
             midz = (self.session.scene_bounds[5] + self.session.scene_bounds[2]) * 0.5
@@ -275,6 +244,118 @@ def normalize_verts(self, verts: numpy.ndarray):
                 verts[j + 2] = (verts[j + 2] - midz) / s
         return 1.0 / s
 
+    def _build_st_coords(self, tcoords: numpy.ndarray, num_verts: int):
+        """
+        The Omniverse interface uses 2D texturing (s,t) to reference the texture map.
+        This method converts DSG texture coordinates (1D and in "variable" units) into
+        2D OpenGL style [0.,1.] normalized coordinate space.  the "t" coordinate will
+        always be 0.5.
+
+        Parameters
+        ----------
+        tcoords: numpy.ndarray
+            The DSG 1D texture coordinates, which are actually variable values.
+
+        num_verts: int
+            The number of vertices in the mesh.
+
+        Returns
+        -------
+        numpy.ndarray, Any
+            The ST OpenGL GL texture coordinate array and the variable definition DSG command.
+        """
+        var_dsg_id = self.cmd.color_variableid  # type: ignore
+        var_cmd = self.session.variables[var_dsg_id]
+        v_min = None
+        v_max = None
+        for lvl in var_cmd.levels:
+            if (v_min is None) or (v_min > lvl.value):
+                v_min = lvl.value
+            if (v_max is None) or (v_max < lvl.value):
+                v_max = lvl.value
+        var_minmax: List[float] = [v_min, v_max]  # type: ignore
+        # build a power of two x 1 texture
+        num_texels = len(var_cmd.texture) // 4
+        half_texel = 1 / (num_texels * 2.0)
+        tmp = numpy.ndarray((num_verts * 2,), dtype="float32")
+        tmp.fill(0.5)  # fill in the T coordinate...
+        tex_width = half_texel * 2 * (num_texels - 1)  # center to center of num_texels
+        # if the range is 0, adjust the min by -1.   The result is that the texture
+        # coords will get mapped to S=1.0 which is what EnSight does in this situation
+        if (var_minmax[1] - var_minmax[0]) == 0.0:
+            var_minmax[0] = var_minmax[0] - 1.0
+        var_width = var_minmax[1] - var_minmax[0]
+        for idx in range(num_verts):
+            # normalized S coord value (clamp)
+            s = (tcoords[idx] - var_minmax[0]) / var_width
+            if s < 0.0:
+                s = 0.0
+            if s > 1.0:
+                s = 1.0
+            # map to the texture range and set the S value
+            tmp[idx * 2] = s * tex_width + half_texel
+        return tmp, var_cmd
+
+    def line_rep(self):
+        """
+        This function processes the geometry arrays and returns values to represent line data.
+        The vertex array embeds the connectivity, so every two points represent a line segment.
+        The tcoords similarly follow the vertex array notion.
+
+        Returns
+        -------
+        On failure, the method returns None for the first return value.  The returned tuple is:
+
+        (part_command, vertices, connectivity, tex_coords, var_command)
+
+        part_command: UPDATE_PART command object
+        vertices: numpy array of per-node coordinates (two per line segment)
+        tcoords: numpy array of per vertex texture coordinates (optional)
+        var_command: UPDATE_VARIABLE command object for the variable the colors correspond to, if any
+        """
+        if self.cmd is None:
+            return None, None, None, None
+        if self.cmd.render != self.cmd.CONNECTIVITY:
+            # Early out.  Rendering type for this object is a surface rep, not a point rep
+            return None, None, None, None
+
+        num_lines = self.conn_lines.size // 2
+        if num_lines == 0:
+            return None, None, None, None
+        verts = numpy.ndarray((num_lines * 2 * 3,), dtype="float32")
+        tcoords = None
+        if self.tcoords.size:
+            tcoords = numpy.ndarray((num_lines * 2,), dtype="float32")
+        # TODO: handle elemental line values (self.tcoords_elem) by converting to nodal...
+        # if self.tcoords_elem:
+        for i in range(num_lines):
+            i0 = self.conn_lines[i * 2]
+            i1 = self.conn_lines[i * 2 + 1]
+            offset = i * 6
+            verts[offset + 0] = self.coords[i0 * 3 + 0]
+            verts[offset + 1] = self.coords[i0 * 3 + 1]
+            verts[offset + 2] = self.coords[i0 * 3 + 2]
+            verts[offset + 3] = self.coords[i1 * 3 + 0]
+            verts[offset + 4] = self.coords[i1 * 3 + 1]
+            verts[offset + 5] = self.coords[i1 * 3 + 2]
+            if tcoords is not None:
+                # tcoords are 1D at this point
+                offset = i * 2
+                tcoords[offset + 0] = self.tcoords[i0]
+                tcoords[offset + 1] = self.tcoords[i1]
+
+        _ = self._normalize_verts(verts)
+
+        var_cmd = None
+        # texture coords need transformation from variable value to [ST]
+        if tcoords is not None:
+            tcoords, var_cmd = self._build_st_coords(tcoords, verts.size // 3)
+
+        self.session.log(f"Part '{self.cmd.name}' defined: {num_lines} lines.")
+        command = self.cmd
+
+        return command, verts, tcoords, var_cmd
+
     def point_rep(self):
         """
         This function processes the geometry arrays and returns values to represent point data
@@ -297,8 +378,8 @@ def point_rep(self):
             # Early out.  Rendering type for this object is a surface rep, not a point rep
             return None, None, None, None, None
         verts = self.coords
-        num_verts = int(verts.size / 3)
-        norm_scale = self.normalize_verts(verts)
+        num_verts = verts.size // 3
+        norm_scale = self._normalize_verts(verts)
 
         # Convert var values in self.tcoords to RGB colors
         # For now, look up RGB colors.  Planned USD enhancements should allow tex coords instead.
@@ -359,7 +440,7 @@ def point_rep(self):
                                 colors[idx * 3 + ii] = (
                                     col0[ii] * pal_sub + col1[ii] * (1.0 - pal_sub)
                                 ) / 255.0
-            self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size/3} points.")
+            self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size // 3} points.")
 
         node_sizes = None
         if self.node_sizes.size and self.node_sizes.size == num_verts:
@@ -375,7 +456,7 @@ def point_rep(self):
             for ii in range(0, num_verts):
                 node_sizes[ii] = node_size_default
 
-        self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size/3} points.")
+        self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size // 3} points.")
         command = self.cmd
 
         return command, verts, node_sizes, colors, var_cmd

src/ansys/pyensight/core/utils/omniverse_cli.py

@@ -78,6 +78,8 @@ def __init__(
         normalize_geometry: bool = False,
         dsg_uri: str = "",
         monitor_directory: str = "",
+        line_width: float = -0.0001,
+        use_lines: bool = False,
     ) -> None:
         self._dsg_uri = dsg_uri
         self._destination = destination
@@ -93,6 +95,8 @@ def __init__(
         self._server_process = None
         self._status_filename: str = ""
         self._monitor_directory: str = monitor_directory
+        self._line_width = line_width
+        self._use_lines = use_lines
 
     @property
     def monitor_directory(self) -> Optional[str]:
@@ -184,7 +188,9 @@ def run_server(self, one_shot: bool = False) -> None:
         """
 
         # Build the Omniverse connection
-        omni_link = ov_dsg_server.OmniverseWrapper(destination=self._destination)
+        omni_link = ov_dsg_server.OmniverseWrapper(
+            destination=self._destination, line_width=self._line_width, use_lines=self._use_lines
+        )
         logging.info("Omniverse connection established.")
 
         # parse the DSG USI
@@ -269,7 +275,9 @@ def run_monitor(self):
                 return
 
         # Build the Omniverse connection
-        omni_link = ov_dsg_server.OmniverseWrapper(destination=self._destination)
+        omni_link = ov_dsg_server.OmniverseWrapper(
+            destination=self._destination, line_width=self._line_width, use_lines=self._use_lines
+        )
         logging.info("Omniverse connection established.")
 
         # use an OmniverseUpdateHandler
@@ -449,6 +457,20 @@ def run_monitor(self):
         type=str2bool_type,
         help="Convert a single geometry into USD and exit.  Default: false",
     )
+    line_default: Any = os.environ.get("ANSYS_OV_LINE_WIDTH", None)
+    if line_default is not None:
+        try:
+            line_default = float(line_default)
+        except ValueError:
+            line_default = None
+    # Potential future default: -0.0001
+    parser.add_argument(
+        "--line_width",
+        metavar="line_width",
+        default=line_default,
+        type=float,
+        help=f"Width of lines: >0=absolute size. <0=fraction of diagonal. 0=wireframe. Default: {line_default}",
+    )
 
     # parse the command line
     args = parser.parse_args()
@@ -469,6 +491,12 @@ def run_monitor(self):
         logging.root.removeHandler(logging.root.handlers[0])
     logging.basicConfig(**log_args)  # type: ignore
 
+    # size of lines in data units or fraction of bounding box diagonal
+    use_lines = args.line_width is not None
+    line_width = -0.0001
+    if args.line_width is not None:
+        line_width = args.line_width
+
     # Build the server object
     server = OmniverseGeometryServer(
         destination=args.destination,
@@ -479,6 +507,8 @@ def run_monitor(self):
         normalize_geometry=args.normalize_geometry,
         vrmode=not args.include_camera,
         temporal=args.temporal,
+        line_width=line_width,
+        use_lines=use_lines,
     )
 
     # run the server