Tweaks 'overlap' (more testing needed)

Author: brgix

src/osut/osut.py

@@ -4049,8 +4049,6 @@ def overlap(p1=None, p2=None, flat=False) -> bool:
     delta = area1 + area2 - area
 
     if area > CN.TOL:
-        if round(area,  2) == round(area1, 2): return face
-        if round(area,  2) == round(area2, 2): return face
         if round(delta, 2) == 0: return face
 
     res = openstudio.intersect(a1, a2, CN.TOL)
@@ -4582,6 +4580,7 @@ def medialBox(pts=None) -> openstudio.Point3dVector:
         if not pts: return bkp
 
     if isClockwise(pts):
+        pts = list(pts)
         pts.reverse()
         pts = p3Dv(pts)
 
@@ -4614,8 +4613,9 @@ def medialBox(pts=None) -> openstudio.Point3dVector:
     box.append(mpoints[0])
     box.append(mpoints[1])
     box.append(plane.project(mpoints[1]))
+
     box = list(nonCollinears(box))
-    if box.size != 4: return bkp
+    if len(box) != 4: return bkp
 
     if isClockwise(box): box.reverse()
 
@@ -4677,7 +4677,7 @@ def boundedBox(pts=None) -> openstudio.Point3dVector:
     for sg in segments(pts):
         m0 = midpoint(sg[0], sg[1])
 
-        for seg in getSegments(pts):
+        for seg in segments(pts):
             p1 = seg[0]
             p2 = seg[1]
             if areSame(p1, sg[0]): continue
@@ -4781,9 +4781,9 @@ def boundedBox(pts=None) -> openstudio.Point3dVector:
         aire = area
         box  = out
 
-        if aire > CN.TOL:
-            if t: box = p3Dv(t * box)
-            return box
+    if aire > CN.TOL:
+        if t: box = p3Dv(t * box)
+        return box
 
     # PATH G : Medial box, triangulated approach.
     aire  = 0

tests/test_osut.py

@@ -2624,10 +2624,86 @@ def test23_fits_overlaps(self):
         pts   = osut.nonCollinears(ceiling.vertices(), 3)
         box01 = osut.triadBox(pts)
         box11 = osut.boundedBox(ceiling)
-        print(o.logs())
         self.assertTrue(osut.areSame(box01, box11))
         self.assertTrue(osut.fits(box01, ceiling))
 
+        pts   = osut.nonCollinears(roof.vertices(), 3)
+        box02 = osut.medialBox(pts)
+        box12 = osut.boundedBox(roof)
+        self.assertTrue(osut.areSame(box02, box12))
+        self.assertTrue(osut.fits(box02, roof))
+
+        box03 = osut.triadBox(pts)
+        self.assertFalse(osut.areSame(box03, box12))
+        self.assertEqual(o.status(), 0)
+
+        # For parallel surfaces, OSut's 'overlap' output is consistent
+        # regardless of the sequence of arguments. Here, floor and ceiling are
+        # mirrored - the former counterclockwise, the latter clockwise. The
+        # returned overlap conserves the vertex winding of the first surface.
+        self.assertTrue(osut.areParallel(floor, ceiling))
+        olap1 = osut.overlap(floor, ceiling)
+        olap2 = osut.overlap(ceiling, floor)
+        self.assertTrue(osut.areSame(floor.vertices(), olap1))
+        self.assertTrue(osut.areSame(ceiling.vertices(), olap2))
+
+        # When surfaces aren't parallel, 'overlap' remains somewhat consistent
+        # if both share a common edge. Here, the flat soffit shares an edge
+        # with the sloped roof. The projection of the soffit neatly fits onto
+        # the roof, yet the generated overlap will obviously be distorted with
+        # respect to the original soffit vertices. Nonetheless, the shared
+        # vertices/edge(s) would be preserved.
+        olap1 = osut.overlap(soffit, roof, True)
+        olap2 = osut.overlap(roof, soffit, True)
+        self.assertTrue(osut.areParallel(olap1, soffit))
+        self.assertFalse(osut.areParallel(olap1, roof))
+        self.assertTrue(osut.areParallel(olap2, roof))
+        self.assertFalse(osut.areParallel(olap2, soffit))
+        self.assertEqual(len(olap1), 4)
+        self.assertEqual(len(olap2), 4)
+        area1 = openstudio.getArea(olap1)
+        area2 = openstudio.getArea(olap2)
+        self.assertTrue(area1)
+        self.assertTrue(area2)
+        area1 = area1.get()
+        area2 = area2.get()
+        self.assertGreater(abs(area1 - area2), TOL)
+        pl1 = openstudio.Plane(olap1)
+        pl2 = openstudio.Plane(olap2)
+        n1  = pl1.outwardNormal()
+        n2  = pl2.outwardNormal()
+        dt1 = soffit.plane().outwardNormal().dot(n1)
+        dt2 = roof.plane().outwardNormal().dot(n2)
+        self.assertAlmostEqual(dt1, 1, places=2)
+        self.assertAlmostEqual(dt2, 1, places=2)
+
+        # When surfaces are neither parallel nor share any edges (e.g. sloped roof
+        # vs horizontal floor), the generated overlap is more likely to hold extra
+        # vertices, depending on which surface it is cast onto.
+        olap1 = osut.overlap(floor, roof, True)
+        olap2 = osut.overlap(roof, floor, True)
+        self.assertTrue(osut.areParallel(olap1, floor))
+        self.assertFalse(osut.areParallel(olap1, roof))
+        self.assertTrue(osut.areParallel(olap2, roof))
+        self.assertFalse(osut.areParallel(olap2, floor))
+        self.assertEqual(len(olap1), 3)
+        self.assertEqual(len(olap2), 5)
+        area1 = openstudio.getArea(olap1)
+        area2 = openstudio.getArea(olap2)
+        self.assertTrue(area1)
+        self.assertTrue(area2)
+        area1 = area1.get()
+        area2 = area2.get()
+        self.assertGreater(area2 - area1, TOL)
+        pl1 = openstudio.Plane(olap1)
+        pl2 = openstudio.Plane(olap2)
+        n1  = pl1.outwardNormal()
+        n2  = pl2.outwardNormal()
+        dt1 = floor.plane().outwardNormal().dot(n1)
+        dt2 = roof.plane().outwardNormal().dot(n2)
+        self.assertAlmostEqual(dt1, 1, places=2)
+        self.assertAlmostEqual(dt2, 1, places=2)
+
         del(model)
         self.assertEqual(o.clean(), DBG)