It's finally possible to plot PolySlab objects when transpose=True, finally. I tested the plot capability with the slice plane aligned with the polyslab plane, and perpendicular to it (which invokes and , respectively).

Author: jewettaijfc

tidy3d/components/geometry/base.py

@@ -267,6 +267,7 @@ def intersections_plane(
         if axis != 2:
             last, indices = self.pop_axis((0, 1, 2), axis, transpose=transpose)
             to_2D = to_2D[[*list(indices), last, 3]]
+        print(f"Geometry.intersections_plane({transpose=}), {to_2D=}")  # DEBUG
         return self.intersections_tilted_plane(normal, origin, to_2D)
 
     def intersections_2dbox(self, plane: Box, transpose: bool = False) -> list[Shapely]:
@@ -533,10 +534,10 @@ def plot(
         matplotlib.axes._subplots.Axes
             The supplied or created matplotlib axes.
         """
-
         # find shapes that intersect self at plane
         axis, position = self.parse_xyz_kwargs(x=x, y=y, z=z)
         shapes_intersect = self.intersections_plane(x=x, y=y, z=z, transpose=transpose)
+        print(f"Geometry.plot({transpose=}), {shapes_intersect=}")  # DEBUG
 
         plot_params = self.plot_params
         if viz_spec is not None:
@@ -1720,11 +1721,14 @@ def intersections_plane(
             For more details refer to
         `Shapely's Documentation <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"Planar.intersections_plane({transpose=})")  # DEBUG
         axis, position = self.parse_xyz_kwargs(x=x, y=y, z=z)
         if not self.intersects_axis_position(axis, position):
             return []
         if axis == self.axis:
-            return self._intersections_normal(position)
+            # print(f"{self._intersections_normal=}")  # DEBUG
+            return self._intersections_normal(position, transpose=transpose)
+        # print(f"{self._intersections_side=}")  # DEBUG
         return self._intersections_side(position, axis, transpose=transpose)
 
     @abstractmethod
@@ -2105,6 +2109,7 @@ def intersections_plane(
             For more details refer to
             `Shapely's Documentation <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"Box.intersections_plane({transpose=})")  # DEBUG
         axis, position = self.parse_xyz_kwargs(x=x, y=y, z=z)
         if not self.intersects_axis_position(axis, position):
             return []
@@ -2181,6 +2186,7 @@ def intersections_with(self, other, transpose: bool = False):
         dim = "xyz"[normal_ind]
         pos = self.center[normal_ind]
         xyz_kwargs = {dim: pos}
+        print(f"Box.intersects_with({transpose=}), {xyz_kwargs=}")  # DEBUG
         shapes_plane = other.intersections_plane(**xyz_kwargs, transpose=transpose)
 
         # intersect all shapes with the input self
@@ -3009,6 +3015,7 @@ def intersections_plane(
             For more details refer to
             `Shapely's Documentaton <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"ClipOperation.intersections_plane({transpose=})")  # DEBUG
         a = self.geometry_a.intersections_plane(x, y, z, transpose=transpose)
         b = self.geometry_b.intersections_plane(x, y, z, transpose=transpose)
         geom_a = shapely.unary_union([Geometry.evaluate_inf_shape(g) for g in a])
@@ -3221,6 +3228,7 @@ def intersections_plane(
             For more details refer to
             `Shapely's Documentation <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"GeometryGroup.intersections_plane({transpose=})")  # DEBUG
         if not self.intersects_plane(x, y, z):
             return []
         return [

tidy3d/components/geometry/polyslab.py

@@ -87,9 +87,8 @@ class PolySlab(base.Planar):
     )
 
     @staticmethod
-    def make_shapely_polygon(vertices: ArrayLike) -> shapely.Polygon:
+    def make_shapely_polygon(vertices: ArrayLike, transpose: bool = False) -> shapely.Polygon:
         """Make a shapely polygon from some vertices, first ensures they are untraced."""
-        vertices = get_static(vertices)
         return shapely.Polygon(vertices)
 
     @pydantic.validator("slab_bounds", always=True)
@@ -629,13 +628,15 @@ def _do_intersections_tilted_plane(
         path, _ = section.to_planar(to_2D=to_2D)
         return path.polygons_full
 
-    def _intersections_normal(self, z: float):
+    def _intersections_normal(self, z: float, transpose: bool = False):
         """Find shapely geometries intersecting planar geometry with axis normal to slab.
 
         Parameters
         ----------
         z : float
             Position along the axis normal to slab.
+        transpose : bool = False
+            Optional: Swap the planar (XY) coordinates?
 
         Returns
         -------
@@ -644,16 +645,22 @@ def _intersections_normal(self, z: float):
             For more details refer to
             `Shapely's Documentation <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"PolySlab._intersections_normal({transpose=})")  # DEBUG
         if math.isclose(self.sidewall_angle, 0):
-            return [self.make_shapely_polygon(self.reference_polygon)]
-
+            vertices = self.reference_polygon
+            if transpose:
+                vertices = vertices[:, (1, 0)]  # swap column 0 (x coords) with column 1 (y coords)
+            return [self.make_shapely_polygon(vertices, transpose=transpose)]
         z0 = self.center_axis
         z_local = z - z0  # distance to the middle
         dist = -z_local * self._tanq
         vertices_z = self._shift_vertices(self.middle_polygon, dist)[0]
-        return [self.make_shapely_polygon(vertices_z)]
+        vertices = vertices_z
+        if transpose:
+            vertices = vertices[:, (1, 0)]  # swap column 0 (x coords) with column 1 (y coords)
+        return [self.make_shapely_polygon(vertices, transpose=transpose)]
 
-    def _intersections_side(self, position, axis) -> list:
+    def _intersections_side(self, position, axis, transpose: bool = False) -> list:
         """Find shapely geometries intersecting planar geometry with axis orthogonal to slab.
 
         For slanted polyslab, the procedure is as follows,
@@ -678,6 +685,8 @@ def _intersections_side(self, position, axis) -> list:
             Position along ``axis``.
         axis : int
             Integer index into 'xyz' (0,1,2).
+        transpose : bool = False
+            Optional: Swap the coordinates in the plane orthogonal to the axis?
 
         Returns
         -------
@@ -686,12 +695,14 @@ def _intersections_side(self, position, axis) -> list:
             For more details refer to
             `Shapely's Documentation <https://shapely.readthedocs.io/en/stable/project.html>`_.
         """
+        print(f"PolySlab._intersections_side({transpose=})")  # DEBUG
 
         # find out all z_i where the plane will intersect the vertex
         z0 = self.center_axis
         z_base = z0 - self.finite_length_axis / 2
 
         axis_ordered = self._order_axis(axis)
+
         height_list = self._find_intersecting_height(position, axis_ordered)
         polys = []
 
@@ -723,8 +734,8 @@ def _intersections_side(self, position, axis) -> list:
             for y_index in range(len(ints_y) // 2):
                 y_min = ints_y[2 * y_index]
                 y_max = ints_y[2 * y_index + 1]
-                minx, miny = self._order_by_axis(plane_val=y_min, axis_val=z_min, axis=axis)
-                maxx, maxy = self._order_by_axis(plane_val=y_max, axis_val=z_max, axis=axis)
+                minx, miny = self._order_by_axis(plane_val=y_min, axis_val=z_min, axis=axis, transpose=transpose)
+                maxx, maxy = self._order_by_axis(plane_val=y_max, axis_val=z_max, axis=axis, transpose=transpose)
 
                 if math.isclose(self.sidewall_angle, 0):
                     polys.append(self.make_shapely_box(minx, miny, maxx, maxy))
@@ -738,13 +749,13 @@ def _intersections_side(self, position, axis) -> list:
                     dy_min = h_length * np.tan(angle_min)
                     dy_max = h_length * np.tan(angle_max)
 
-                    x1, y1 = self._order_by_axis(plane_val=y_min, axis_val=z_min, axis=axis)
-                    x2, y2 = self._order_by_axis(plane_val=y_max, axis_val=z_min, axis=axis)
+                    x1, y1 = self._order_by_axis(plane_val=y_min, axis_val=z_min, axis=axis, transpose=transpose)
+                    x2, y2 = self._order_by_axis(plane_val=y_max, axis_val=z_min, axis=axis, transpose=transpose)
                     x3, y3 = self._order_by_axis(
-                        plane_val=y_max - dy_max, axis_val=z_max, axis=axis
+                        plane_val=y_max - dy_max, axis_val=z_max, axis=axis, transpose=transpose
                     )
                     x4, y4 = self._order_by_axis(
-                        plane_val=y_min + dy_min, axis_val=z_max, axis=axis
+                        plane_val=y_min + dy_min, axis_val=z_max, axis=axis, transpose=transpose
                     )
                     vertices = ((x1, y1), (x2, y2), (x3, y3), (x4, y4))
                     polys.append(self.make_shapely_polygon(vertices).buffer(0))
@@ -984,11 +995,16 @@ def _find_intersecting_ys_angle_slant(
         return ints_y_sort, ints_angle_sort
 
     @cached_property
-    def bounds(self) -> Bound:
+    def bounds(self, transpose: bool = False) -> Bound:
         """Returns bounding box min and max coordinates. The dilation and slant angle are not
         taken into account exactly for speed. Instead, the polygon may be slightly smaller than
         the returned bounds, but it should always be fully contained.
 
+        Parameters
+        -------
+        transpose : bool = False
+            Optional: Swap the planar axes? (the axes perpendicular to self.axis)
+
         Returns
         -------
         Tuple[float, float, float], Tuple[float, float float]
@@ -1021,8 +1037,8 @@ def bounds(self) -> Bound:
         zmin, zmax = self.slab_bounds
 
         # rearrange axes
-        coords_min = self.unpop_axis(zmin, (xmin, ymin), axis=self.axis)
-        coords_max = self.unpop_axis(zmax, (xmax, ymax), axis=self.axis)
+        coords_min = self.unpop_axis(zmin, (xmin, ymin), axis=self.axis, transpose=transpose)
+        coords_max = self.unpop_axis(zmax, (xmax, ymax), axis=self.axis, transpose=transpose)
         return (tuple(coords_min), tuple(coords_max))
 
     def _extrusion_length_to_offset_distance(self, extrusion: float) -> float:

tidy3d/components/scene.py

@@ -470,7 +470,7 @@ def plot_structures(
         matplotlib.axes._subplots.Axes
             The supplied or created matplotlib axes.
         """
-
+        print(f"Scene.plot_structures({transpose=})")  # DEBUG
         medium_shapes = self._get_structures_2dbox(
             structures=self.to_static().sorted_structures, x=x, y=y, z=z, hlim=hlim, vlim=vlim, transpose=transpose
         )

tidy3d/components/structure.py

@@ -149,6 +149,7 @@ def plot(
         y: Optional[float] = None,
         z: Optional[float] = None,
         ax: Ax = None,
+        transpose: bool = False,
         **patch_kwargs,
     ) -> Ax:
         """Plot structure's geometric cross section at single (x,y,z) coordinate.
@@ -173,7 +174,8 @@ def plot(
         matplotlib.axes._subplots.Axes
             The supplied or created matplotlib axes.
         """
-        return self.geometry.plot(x=x, y=y, z=z, ax=ax, viz_spec=self.viz_spec, **patch_kwargs)
+        print(f"AbstractStructure.plot({transpose=})")  # DEBUG
+        return self.geometry.plot(x=x, y=y, z=z, ax=ax, viz_spec=self.viz_spec, transpose=transpose, **patch_kwargs)
 
 
 class Structure(AbstractStructure):