fix(polygon): Have Polygon2D display similar to Polyline2D

I realized that we have been displaying Polygon2Ds as lines all over the Grasshopper plugin and so it makes sense that ladybug-display should follow this convention.

This commit also simplifies the number of line types to just a few that are clearly understandable.

ladybug_display/_base.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 """Base class for all geometry objects."""
-LINE_TYPES = ('Continuous', 'Dashed', 'Dotted', 'DashDot', 'Center', 'Border', 'Hidden')
+LINE_TYPES = ('Continuous', 'Dashed', 'Dotted', 'DashDot')
 DISPLAY_MODES = ('Surface', 'SurfaceWithEdges', 'Wireframe', 'Points')
 
 

ladybug_display/geometry2d/_base.py

@@ -120,9 +120,6 @@ class _LineCurveBase2D(_SingleColorBase2D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry2d/arc.py

@@ -23,9 +23,6 @@ class DisplayArc2D(_LineCurveBase2D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry2d/line.py

@@ -23,9 +23,6 @@ class DisplayLineSegment2D(_LineCurveBase2D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry2d/polygon.py

@@ -2,29 +2,33 @@
 from ladybug_geometry.geometry2d.polygon import Polygon2D
 from ladybug.color import Color
 
-from .._base import DISPLAY_MODES
-from ._base import _SingleColorBase2D
+from ladybug_display.altnumber import default
+from ._base import _LineCurveBase2D
 
 
-class DisplayPolygon2D(_SingleColorBase2D):
+class DisplayPolygon2D(_LineCurveBase2D):
     """A polygon in 2D space with display properties.
 
     Args:
         geometry: A ladybug-geometry Polygon2D object.
         color: A ladybug Color object. If None, a default black color will be
             used. (Default: None).
-        display_mode: Text to indicate the display mode (surface, wireframe, etc.).
-            Choose from the following. (Default: Surface).
+        line_width: Number for line width in pixels (for the screen) or  millimeters
+            (in print). This can also be the Default object to indicate that the
+            default settings of the interface should be used.
+        line_type: Get or set text to indicate the type of line to display. 
+            Choose from the following. (Default: "Continuous")
 
-            * Surface
-            * SurfaceWithEdges
-            * Wireframe
-            * Points
+            * Continuous
+            * Dashed
+            * Dotted
+            * DashDot
 
     Properties:
         * geometry
         * color
-        * display_mode
+        * line_width
+        * line_type
         * vertices
         * segments
         * min
@@ -37,14 +41,13 @@ class DisplayPolygon2D(_SingleColorBase2D):
         * is_self_intersecting
         * user_data
     """
-    __slots__ = ('_display_mode',)
+    __slots__ = ()
 
-    def __init__(self, geometry, color=None, display_mode='Surface'):
+    def __init__(self, geometry, color=None, line_width=default, line_type='Continuous'):
         """Initialize base with shade object."""
         assert isinstance(geometry, Polygon2D), '\
             Expected ladybug_geometry Polygon2D. Got {}'.format(type(geometry))
-        _SingleColorBase2D.__init__(self, geometry, color)
-        self.display_mode = display_mode
+        _LineCurveBase2D.__init__(self, geometry, color)
 
     @classmethod
     def from_dict(cls, data):
@@ -57,31 +60,15 @@ def from_dict(cls, data):
             'Expected DisplayPolygon2D dictionary. Got {}.'.format(data['type'])
         color = Color.from_dict(data['color']) if 'color' in data and data['color'] \
             is not None else None
-        d_mode = data['display_mode'] if 'display_mode' in data and \
-            data['display_mode'] is not None else 'Surface'
-        geo = cls(Polygon2D.from_dict(data['geometry']), color, d_mode)
+        lw = default if 'line_width' not in data or \
+            data['line_width'] == default.to_dict() else data['line_width']
+        lt = data['line_type'] if 'line_type' in data and data['line_type'] \
+            is not None else 'Continuous'
+        geo = cls(Polygon2D.from_dict(data['geometry']), color, lw, lt)
         if 'user_data' in data and data['user_data'] is not None:
             geo.user_data = data['user_data']
         return geo
 
-    @property
-    def display_mode(self):
-        """Get or set text to indicate the display mode."""
-        return self._display_mode
-
-    @display_mode.setter
-    def display_mode(self, value):
-        clean_input = value.lower()
-        for key in DISPLAY_MODES:
-            if key.lower() == clean_input:
-                value = key
-                break
-        else:
-            raise ValueError(
-                'display_mode {} is not recognized.\nChoose from the '
-                'following:\n{}'.format(value, DISPLAY_MODES))
-        self._display_mode = value
-
     @property
     def vertices(self):
         """Get a tuple of Point2Ds that make up the polygon."""
@@ -137,13 +124,16 @@ def to_dict(self):
         base = {'type': 'DisplayPolygon2D'}
         base['geometry'] = self._geometry.to_dict()
         base['color'] = self.color.to_dict()
-        base['display_mode'] = self.display_mode
+        base['line_width'] = default.to_dict() if \
+            self.line_width == default else self.line_width
+        base['line_type'] = self.line_type
         if self.user_data is not None:
             base['user_data'] = self.user_data
         return base
 
     def __copy__(self):
-        new_g = DisplayPolygon2D(self.geometry, self.color, self.display_mode)
+        new_g = DisplayPolygon2D(
+            self.geometry, self.color, self.line_width, self.line_type)
         new_g._user_data = None if self.user_data is None else self.user_data.copy()
         return new_g
 

ladybug_display/geometry2d/polyline.py

@@ -23,9 +23,6 @@ class DisplayPolyline2D(_LineCurveBase2D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry
@@ -79,7 +76,7 @@ def vertices(self):
     def segments(self):
         """Get a tuple of LineSegment2D for the segments of the polyline."""
         return self._geometry.segments
-    
+
     @property
     def interpolated(self):
         """Get a boolean for whether the polyline should be interpreted as interpolated.

ladybug_display/geometry3d/_base.py

@@ -172,9 +172,6 @@ class _LineCurveBase3D(_SingleColorBase3D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry3d/arc.py

@@ -25,9 +25,6 @@ class DisplayArc3D(_LineCurveBase3D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry3d/line.py

@@ -23,9 +23,6 @@ class DisplayLineSegment3D(_LineCurveBase3D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/geometry3d/polyline.py

@@ -23,9 +23,6 @@ class DisplayPolyline3D(_LineCurveBase3D):
             * Dashed
             * Dotted
             * DashDot
-            * Center
-            * Border
-            * Hidden
 
     Properties:
         * geometry

ladybug_display/visualization.py

@@ -265,6 +265,8 @@ def add_geometry(self, geometry, insert_index=None):
             geos_list = list(self._geometry)
             geos_list.insert(insert_index, geometry)
             self._geometry = tuple(geos_list)
+        self._min_point = None
+        self._max_point = None
 
     def remove_geometry(self, geo_index):
         """Remove a geometry object from this VisualizationSet.
@@ -278,6 +280,8 @@ def remove_geometry(self, geo_index):
         geos_list = list(self._geometry)
         geos_list.pop(geo_index)
         self._geometry = tuple(geos_list)
+        self._min_point = None
+        self._max_point = None
 
     def check_duplicate_identifiers(self, raise_exception=True, detailed=False):
         """Check that there are no duplicate geometry object identifiers in the set.

tests/polygon2d_test.py

@@ -3,6 +3,7 @@
 from ladybug_geometry.geometry2d.polygon import Polygon2D
 from ladybug.color import Color
 from ladybug_display.geometry2d.polygon import DisplayPolygon2D
+from ladybug_display.altnumber import default
 
 
 def test_display_p_gon2d_init():
@@ -13,7 +14,8 @@ def test_display_p_gon2d_init():
     str(p_gon)  # test the string representation of the p_gon
 
     assert p_gon.color == grey
-    assert p_gon.display_mode == 'Surface'
+    assert p_gon.line_width == default
+    assert p_gon.line_type == 'Continuous'
     assert isinstance(p_gon.vertices, tuple)
     assert len(p_gon.vertices) == 4
     for point in p_gon.vertices:
@@ -23,17 +25,20 @@ def test_display_p_gon2d_init():
 
     blue = Color(0, 0, 100)
     p_gon.color = blue
-    p_gon.display_mode = 'Wireframe'
+    p_gon.line_width = 2
+    p_gon.line_type = 'Dashed'
     assert p_gon.color == blue
-    assert p_gon.display_mode == 'Wireframe'
+    assert p_gon.line_width == 2
+    assert p_gon.line_type == 'Dashed'
 
 
 def test_p_gon2d_to_from_dict():
     """Test the to/from dict of Face2D objects."""
     grey = Color(100, 100, 100)
     pts = (Point2D(0, 0), Point2D(0, 2), Point2D(2, 2), Point2D(2, 0))
     p_gon = DisplayPolygon2D(Polygon2D(pts), grey)
-    p_gon.display_mode = 'Wireframe'
+    p_gon.line_width = 2
+    p_gon.line_type = 'Dashed'
     p_gon_dict = p_gon.to_dict()
     new_p_gon = DisplayPolygon2D.from_dict(p_gon_dict)
     assert isinstance(new_p_gon, DisplayPolygon2D)