fix(plane): Ensure that Plane does not mess up bounding calculations

Author: chriswmackey

ladybug_geometry/geometry3d/arc.py

@@ -90,6 +90,17 @@ def from_start_mid_end(cls, p1, m, p2, circle=False):
         return cls(Plane(plane.n, plane.xy_to_xyz(arc_2d.c), plane.x),
                    arc_2d.r, arc_2d.a1, arc_2d.a2)
 
+    @classmethod
+    def from_arc2d(cls, arc2d, z=0):
+        """Initialize a new Arc3D from an Arc2D and a z value.
+
+        Args:
+            arc2d: An Arc2D to be used to generate the Arc3D.
+            z: A number for the Z coordinate value of the arc.
+        """
+        plane = Plane(o=Point3D(arc2d.c.x, arc2d.c.y, z))
+        return cls(plane, arc2d.r, arc2d.a1, arc2d.a2)
+
     @property
     def plane(self):
         """A Plane in which the arc lies with an origin for the center of the arc."""
@@ -375,14 +386,18 @@ def _calculate_min_max(self):
         https://stackoverflow.com/questions/2592011/\
         bounding-boxes-for-circle-and-arcs-in-3d
         """
-        # TODO: get this method to respect the start and end points of the arc
-        o, r = self._plane.o, self.radius
-        ax = self._plane.n.angle(Vector3D(1, 0, 0))
-        ay = self._plane.n.angle(Vector3D(0, 1, 0))
-        az = self._plane.n.angle(Vector3D(0, 0, 1))
-        r_vec = (math.sin(ax) * r, math.sin(ay) * r, math.sin(az) * r)
-        self._min = Point3D(o.x - r_vec[0], o.y - r_vec[1], o.z - r_vec[2])
-        self._max = Point3D(o.x + r_vec[0], o.y + r_vec[1], o.z + r_vec[2])
+        if self.is_circle:
+            o, r = self._plane.o, self.radius
+            ax = self._plane.n.angle(Vector3D(1, 0, 0))
+            ay = self._plane.n.angle(Vector3D(0, 1, 0))
+            az = self._plane.n.angle(Vector3D(0, 0, 1))
+            r_vec = (math.sin(ax) * r, math.sin(ay) * r, math.sin(az) * r)
+            self._min = Point3D(o.x - r_vec[0], o.y - r_vec[1], o.z - r_vec[2])
+            self._max = Point3D(o.x + r_vec[0], o.y + r_vec[1], o.z + r_vec[2])
+        else:  # get the min and max of the Arc2D
+            min_pt2d, max_pt2d = self._arc2d.min, self._arc2d.max
+            self._min = self.plane.xy_to_xyz(min_pt2d)
+            self._max = self.plane.xy_to_xyz(max_pt2d)
 
     @staticmethod
     def _plane_from_vertices(pt1, pt2, pt3):

ladybug_geometry/geometry3d/line.py

@@ -2,7 +2,7 @@
 """3D Line Segment"""
 from __future__ import division
 
-from .pointvector import Point3D
+from .pointvector import Point3D, Vector3D
 from ._1d import Base1DIn3D
 
 
@@ -62,6 +62,18 @@ def from_array(cls, line_array):
         """
         return LineSegment3D.from_end_points(*tuple(Point3D(*pt) for pt in line_array))
 
+    @classmethod
+    def from_line_segment2d(cls, line2d, z=0):
+        """Initialize a new LineSegment3D from an LineSegment2D and a z value.
+
+        Args:
+            line2d: A LineSegment2D to be used to generate the LineSegment3D.
+            z: A number for the Z coordinate value of the line.
+        """
+        base_p = Point3D(line2d.p.x, line2d.p.y, z)
+        base_v = Vector3D(line2d.v.x, line2d.v.y, 0)
+        return cls(base_p, base_v)
+
     @property
     def p1(self):
         """First point (same as p)."""

ladybug_geometry/geometry3d/plane.py

@@ -30,6 +30,8 @@ class Plane(object):
         * y
         * altitude
         * azimuth
+        * min
+        * max
     """
     __slots__ = ('_n', '_o', '_k', '_x', '_y', '_altitude', '_azimuth')
 
@@ -155,6 +157,16 @@ def altitude(self):
             self._altitude = self.n.angle(Vector3D(0, 0, -1)) - math.pi / 2
         return self._altitude
 
+    @property
+    def min(self):
+        """Returns the Plane origin."""
+        return self._o
+
+    @property
+    def max(self):
+        """Returns the Plane origin."""
+        return self._o
+
     def flip(self):
         """Get a flipped version of this plane (facing the opposite direction)."""
         return Plane(self.n.reverse(), self.o, self.x)

ladybug_geometry/geometry3d/pointvector.py

@@ -59,6 +59,16 @@ def from_array(cls, array):
         """
         return cls(array[0], array[1], array[2])
 
+    @classmethod
+    def from_vector2d(cls, vector2d, z=0):
+        """Initialize a new Vector3D from an Vector2D and a z value.
+
+        Args:
+            line2d: A Vector2D to be used to generate the Vector3D.
+            z: A number for the Z coordinate value of the line.
+        """
+        return cls(vector2d.x, vector2d.y, z)
+
     @property
     def x(self):
         """Get the X coordinate."""
@@ -395,6 +405,16 @@ class Point3D(Vector3D):
     """
     __slots__ = ()
 
+    @classmethod
+    def from_point2d(cls, point2d, z=0):
+        """Initialize a new Point3D from an Point2D and a z value.
+
+        Args:
+            line2d: A Point2D to be used to generate the Point3D.
+            z: A number for the Z coordinate value of the line.
+        """
+        return cls(point2d.x, point2d.y, z)
+
     @property
     def min(self):
         """Always equal to the point itself.

ladybug_geometry/geometry3d/polyline.py

@@ -71,13 +71,15 @@ def from_array(cls, point_array):
         return Polyline3D(Point3D(*point) for point in point_array)
 
     @classmethod
-    def from_polyline2d(cls, polyline2d, plane=Plane()):
+    def from_polyline2d(cls, polyline2d, plane=None):
         """Create a closed Polyline3D from a Polyline2D and a plane.
 
         Args:
             polyline2d: A Polyline2D object to be converted to a Polyline3D.
-            plane: A Plane in which the Polyline2D sits.
+            plane: A Plane in which the Polyline2D sits. If None, the WorldXY
+                plane will be used.
         """
+        plane = Plane() if plane is None else plane
         return Polyline3D((plane.xy_to_xyz(pt) for pt in polyline2d.vertices),
                           polyline2d.interpolated)
 

ladybug_geometry/geometry3d/ray.py

@@ -34,6 +34,18 @@ def from_array(cls, ray_array):
         """
         return Ray3D(Point3D(*ray_array[0]), Vector3D(*ray_array[1]))
 
+    @classmethod
+    def from_ray2d(cls, ray2d, z=0):
+        """Initialize a new Ray3D from an Ray2D and a z value.
+
+        Args:
+            line2d: A Ray2D to be used to generate the Ray3D.
+            z: A number for the Z coordinate value of the line.
+        """
+        base_p = Point3D(ray2d.p.x, ray2d.p.y, z)
+        base_v = Vector3D(ray2d.v.x, ray2d.v.y, 0)
+        return cls(base_p, base_v)
+
     def reverse(self):
         """Get a copy of this ray that is reversed."""
         return Ray3D(self.p, self.v.reverse())

tests/arc3d_test.py

@@ -27,7 +27,8 @@ def test_arc3_init():
     assert arc.p2.y == pytest.approx(0, rel=1e-3)
     assert arc.p2.z == pytest.approx(2, rel=1e-3)
     assert arc.midpoint == Point3D(2, 1, 2)
-    assert arc.min == Point3D(1, -1, 2)
+    assert arc.min.x == pytest.approx(1, rel=1e-3)
+    assert arc.min.z == pytest.approx(2, rel=1e-3)
     assert arc.max == Point3D(3, 1, 2)
     assert arc.length == pytest.approx(math.pi, rel=1e-3)
     assert arc.angle == pytest.approx(math.pi, rel=1e-3)
@@ -63,7 +64,7 @@ def test_arc3_init_radius():
     assert arc.is_inverted is True
 
 
-def test_arc3_init_reveresed():
+def test_arc3_init_reversed():
     """Test the initialization of Arc3D objects with reversed direction."""
     pt = Point3D(2, 0, 2)
     arc = Arc3D(Plane(o=pt), 1, 1.5 * math.pi, 0.5 * math.pi)
@@ -80,8 +81,7 @@ def test_arc3_init_reveresed():
     assert arc.p2.z == pytest.approx(2, rel=1e-3)
     assert arc.midpoint.x == pytest.approx(3, rel=1e-3)
     assert arc.midpoint.y == pytest.approx(0, rel=1e-3)
-    assert arc.min.x == pytest.approx(1, rel=1e-3)
-    assert arc.min.y == pytest.approx(-1, rel=1e-3)
+    assert arc.min.x == pytest.approx(2, rel=1e-3)
     assert arc.max.x == pytest.approx(3, rel=1e-3)
     assert arc.max.y == pytest.approx(1, rel=1e-3)
     assert arc.length == pytest.approx(math.pi, rel=1e-3)