style(dict): Changing the dict schema of all geometry objects

Author: chriswmackey

ladybug_geometry/geometry2d/_1d.py

@@ -33,10 +33,11 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "p": {"x": 10, "y": 0},
-            "v": {"x": 10, "y": 10}}
+            "p": [10, 0],
+            "v": [10, 10]}
         """
-        return cls(Point2D.from_dict(data['p']), Vector2D.from_dict(data['v']))
+        return cls(Point2D(data['p'][0], data['p'][1]),
+                   Vector2D(data['v'][0], data['v'][1]))
 
     @property
     def p(self):
@@ -89,8 +90,8 @@ def duplicate(self):
 
     def to_dict(self):
         """Get LineSegment2D/Ray2D as a dictionary."""
-        return {'p': self.p.to_dict(),
-                'v': self.v.to_dict()}
+        return {'p': (self.p.x, self.p.y),
+                'v': (self.v.x, self.v.y)}
 
     def __copy__(self):
         return self.__class__(self.p, self.v)

ladybug_geometry/geometry2d/arc.py

@@ -56,12 +56,14 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "c": {"x": 10, "y": 0},
+            "type": "Arc2D"
+            "c": [10, 0],
             "r": 5,
             "a1": 0,
             "a2": 3.14159}
         """
-        return cls(Point2D.from_dict(data['c']), data['r'], data['a1'], data['a2'])
+        return cls(Point2D(data['c'][0], data['c'][1]),
+                   data['r'], data['a1'], data['a2'])
 
     @classmethod
     def from_start_mid_end(cls, p1, m, p2, circle=False):
@@ -367,7 +369,7 @@ def duplicate(self):
 
     def to_dict(self):
         """Get Arc2D as a dictionary."""
-        return {'c': self.c.to_dict(),
+        return {'type': 'Arc2D', 'c': (self.c.x, self.c.y),
                 'r': self.r, 'a1': self.a1, 'a2': self.a2}
 
     def _pt_in(self, point):

ladybug_geometry/geometry2d/line.py

@@ -200,6 +200,12 @@ def distance_to_line(self, line):
         dist, pts = closest_point2d_between_line2d(self, line)
         return dist
 
+    def to_dict(self):
+        """Get LineSegment2D as a dictionary."""
+        base = Base1DIn2D.to_dict(self)
+        base['type'] = 'LineSegment2D'
+        return base
+
     def _u_in(self, u):
         return u >= 0.0 and u <= 1.0
 

ladybug_geometry/geometry2d/mesh.py

@@ -63,7 +63,8 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "vertices": [{"x": 0, "y": 0}, {"x": 10, "y": 0}, {"x": 0, "y": 10}],
+            "type": "Mesh2D",
+            "vertices": [[0, 0], [10, 0], [0, 10]],
             "faces": [(0, 1, 2)],
             "colors": [{"r": 255, "g": 0, "b": 0}]
             }
@@ -76,7 +77,7 @@ def from_dict(cls, data):
                 raise ImportError('Colors are specified in input Mesh2D dictionary '
                                   'but failed to import ladybug.color')
             colors = tuple(Color.from_dict(col) for col in data['colors'])
-        return cls(tuple(Point2D.from_dict(pt) for pt in data['vertices']),
+        return cls(tuple(Point2D(pt[0], pt[1]) for pt in data['vertices']),
                    data['faces'], colors)
 
     @classmethod
@@ -382,7 +383,8 @@ def to_dict(self):
         colors = None
         if self.colors is not None:
             colors = [col.to_dict() for col in self.colors]
-        return {'vertices': [pt.to_dict() for pt in self.vertices],
+        return {'type': 'Mesh2D',
+                'vertices': [(pt.x, pt.y) for pt in self.vertices],
                 'faces': self.faces, 'colors': colors}
 
     def _calculate_min_max(self):

ladybug_geometry/geometry2d/pointvector.py

@@ -126,8 +126,9 @@ def duplicate(self):
         return self.__copy__()
 
     def to_dict(self):
-        """Get Vector2D/Point2D as a dictionary."""
-        return {'x': self.x,
+        """Get Vector2D as a dictionary."""
+        return {'type': 'Vector2D',
+                'x': self.x,
                 'y': self.y}
 
     def _cast_to_float(self, value):
@@ -340,6 +341,12 @@ def is_equivalent(self, point, tolerance):
         return abs(self.x - point.x) <= tolerance and \
             abs(self.y - point.y) <= tolerance
 
+    def to_dict(self):
+        """Get Point2D as a dictionary."""
+        return {'type': 'Point2D',
+                'x': self.x,
+                'y': self.y}
+
     def __add__(self, other):
         # Point + Vector -> Point
         # Point + Point -> Vector

ladybug_geometry/geometry2d/polygon.py

@@ -56,10 +56,11 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "vertices": [{"x": 0, "y": 0}, {"x": 10, "y": 0}, {"x": 0, "y": 10}]
+            "type": "Polygon2D",
+            "vertices": [[0, 0], [10, 0], [0, 10]]
             }
         """
-        return cls(tuple(Point2D.from_dict(pt) for pt in data['vertices']))
+        return cls(tuple(Point2D(pt[0], pt[1]) for pt in data['vertices']))
 
     @classmethod
     def from_rectangle(cls, base_point, height_vector, base, height):
@@ -627,7 +628,8 @@ def is_polygon_outside(self, polygon):
 
     def to_dict(self):
         """Get Polygon2D as a dictionary."""
-        return {'vertices': [pt.to_dict() for pt in self.vertices]}
+        return {'type': 'Polygon2D',
+                'vertices': [(pt.x, pt.y) for pt in self.vertices]}
 
     def _transfer_properties(self, new_polygon):
         """Transfer properties from this polygon to a new polygon.

ladybug_geometry/geometry2d/ray.py

@@ -68,6 +68,12 @@ def scale(self, factor, origin=None):
         """
         return Ray2D(self.p.scale(factor, origin), self.v * factor)
 
+    def to_dict(self):
+        """Get Ray2D as a dictionary."""
+        base = Base1DIn2D.to_dict(self)
+        base['type'] = 'Ray2D'
+        return base
+
     def _u_in(self, u):
         return u >= 0.0
 

ladybug_geometry/geometry3d/_1d.py

@@ -34,10 +34,11 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "p": {"x": 10, "y": 0, "z": 0},
-            "v": {"x": 10, "y": 10, "z": 0}}
+            "p": [10, 0, 0],
+            "v": [10, 10, 0]}
         """
-        return cls(Point3D.from_dict(data['p']), Vector3D.from_dict(data['v']))
+        return cls(Point3D(data['p'][0], data['p'][1], data['p'][2]),
+                   Vector3D(data['v'][0], data['v'][1], data['v'][2]))
 
     @property
     def p(self):
@@ -114,8 +115,8 @@ def duplicate(self):
 
     def to_dict(self):
         """Get LineSegment3D/Ray3D as a dictionary."""
-        return {'p': self.p.to_dict(),
-                'v': self.v.to_dict()}
+        return {'p': (self.p.x, self.p.y, self.p.z),
+                'v': (self.v.x, self.v.y, self.v.z)}
 
     def __copy__(self):
         return self.__class__(self.p, self.v)

ladybug_geometry/geometry3d/arc.py

@@ -51,8 +51,8 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "plane": {"n": {"x": 0, "y": 0, "z": 1}, "o": {"x": 0, "y": 10, "z": 0},
-                      "x": {"x": 1, "y": 0, "z": 0}},
+            "type": "Arc3D"
+            "plane": {"n": [0, 0, 1], "o": [0, 10, 0], "x": [1, 0, 0]},
             "radius": 5,
             "a1": 0,
             "a2": 3.14159}
@@ -305,7 +305,7 @@ def duplicate(self):
 
     def to_dict(self):
         """Get Arc3D as a dictionary."""
-        return {'plane': self.plane.to_dict(),
+        return {'type': 'Arc3D', 'plane': self.plane.to_dict(),
                 'radius': self.radius, 'a1': self.a1, 'a2': self.a2}
 
     @staticmethod

ladybug_geometry/geometry3d/face.py

@@ -141,20 +141,21 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "boundary": [{"x": 0, "y": 0, "z": 0}, {"x": 10, "y": 0, "z": 0},
-                         {"x": 0, "y": 10, "z": 0}],
-            "plane": {"n": {"x": 0, "y": 0, "z": 1}, "o": {"x": 0, "y": 0, "z": 0},
-                      "x": {"x": 1, "y": 0, "z": 0}}
-            "holes": [[{"x": 2, "y": 2, "z": 0}, {"x": 5, "y": 2, "z": 0},
-                       {"x": 2, "y": 5, "z": 0}]],
+            "type": "Face3D",
+            "boundary": [[0, 0, 0], [10, 0, 0], [0, 10, 0]],
+            "plane": {"n": [0, 0, 1], "o": [0, 0, 0], "x": [1, 0, 0]},
+            "holes": [[[2, 2, 0], [5, 2, 0], [2, 5, 0]]]
             }
         """
         holes = None
         if 'holes' in data and data['holes'] is not None:
-            holes = tuple(
-                tuple(Point3D.from_dict(pt) for pt in hole) for hole in data['holes'])
-        return cls(tuple(Point3D.from_dict(pt) for pt in data['boundary']),
-                   Plane.from_dict(data['plane']), holes)
+            holes = tuple(tuple(
+                Point3D(pt[0], pt[1], pt[2]) for pt in hole) for hole in data['holes'])
+        plane = None
+        if 'plane' in data and data['plane'] is not None:
+            plane = Plane.from_dict(data['plane'])
+        return cls(tuple(Point3D(pt[0], pt[1], pt[2]) for pt in data['boundary']),
+                   plane, holes)
 
     @classmethod
     def from_extrusion(cls, line_segment, extrusion_vector):
@@ -1359,15 +1360,22 @@ def sub_rectangles_from_rectangle(base_plane, parent_base, parent_height, ratio,
                                       base_plane)]
         return final_faces
 
-    def to_dict(self):
-        """Get Face3D as a dictionary."""
-        if not self.has_holes:
-            return {'boundary': [pt.to_dict() for pt in self.boundary],
-                    'plane': self.plane.to_dict()}
-        else:
-            return {'boundary': [pt.to_dict() for pt in self.boundary],
-                    'plane': self.plane.to_dict(),
-                    'holes': [[pt.to_dict() for pt in hole] for hole in self.holes]}
+    def to_dict(self, include_plane=True):
+        """Get Face3D as a dictionary.
+
+        Args:
+            include_plane: Set to True to include the Face3D plane in the
+                dictionary, which will preserve the underlying orientation
+                of the face plane. Default True.
+        """
+        base = {'type': 'Face3D',
+                'boundary': [(pt.x, pt.y, pt.z) for pt in self.boundary]}
+        if include_plane:
+            base['plane'] = self.plane.to_dict()
+        if self.has_holes:
+            base['holes'] = [[(pt.x, pt.y, pt.z) for pt in hole]
+                             for hole in self.holes]
+        return base
 
     def _check_vertices_input(self, vertices, loop_name='boundary'):
         if not isinstance(vertices, tuple):

ladybug_geometry/geometry3d/line.py

@@ -201,6 +201,12 @@ def point_at_length(self, length):
         """
         return self.p + self.v * (length / self.length)
 
+    def to_dict(self):
+        """Get LineSegment3D as a dictionary."""
+        base = Base1DIn3D.to_dict(self)
+        base['type'] = 'LineSegment3D'
+        return base
+
     def _u_in(self, u):
         return u >= 0.0 and u <= 1.0
 

ladybug_geometry/geometry3d/mesh.py

@@ -65,9 +65,9 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "vertices": [{"x": 0, "y": 0, "z": 0}, {"x": 10, "y": 0, "z": 0},
-                         {"x": 0, "y": 10, "z": 0}],
-            "faces": [(0, 1, 2)],
+            "type": "Mesh3D",
+            "vertices": [[0, 0, 0], [10, 0, 0], [0, 10, 0]],
+            "faces": [[0, 1, 2]],
             "colors": [{"r": 255, "g": 0, "b": 0}]
             }
         """
@@ -79,7 +79,7 @@ def from_dict(cls, data):
                 raise ImportError('Colors are specified in input Mesh2D dictionary '
                                   'but failed to import ladybug.color')
             colors = tuple(Color.from_dict(col) for col in data['colors'])
-        return cls(tuple(Point3D.from_dict(pt) for pt in data['vertices']),
+        return cls(tuple(Point3D(pt[0], pt[1], pt[2]) for pt in data['vertices']),
                    data['faces'], colors)
 
     @classmethod
@@ -332,11 +332,12 @@ def height_field_mesh(self, values, domain):
 
     def to_dict(self):
         """Get Mesh3D as a dictionary."""
-        colors = None
+        base = {'type': 'Mesh3D',
+                'vertices': [(pt.x, pt.y, pt.z) for pt in self.vertices],
+                'faces': self.faces}
         if self.colors is not None:
-            colors = [col.to_dict() for col in self.colors]
-        return {'vertices': [pt.to_dict() for pt in self.vertices],
-                'faces': self.faces, 'colors': colors}
+            base['colors'] = [col.to_dict() for col in self.colors]
+        return base
 
     def _calculate_min_max(self):
         """Calculate maximum and minimum Point3D for this object."""

ladybug_geometry/geometry3d/plane.py

@@ -65,14 +65,16 @@ def from_dict(cls, data):
 
         Args:
             data: {
-            "n": {"x": 0, "y": 0, "z": 1},
-            "o": {"x": 0, "y": 10, "z": 0},
-            "x": {"x": 1, "y": 0, "z": 0}}
+            "type": "Plane"
+            "n": [0, 0, 1],
+            "o": [0, 10, 0],
+            "x": [1, 0, 0]}
         """
         x = None
         if 'x' in data and data['x'] is not None:
-            x = Vector3D.from_dict(data['x'])
-        return cls(Vector3D.from_dict(data['n']), Point3D.from_dict(data['o']), x)
+            x = Vector3D(data['x'][0], data['x'][1], data['x'][2])
+        return cls(Vector3D(data['n'][0], data['n'][1], data['n'][2]),
+                   Point3D(data['o'][0], data['o'][1], data['o'][2]), x)
 
     @classmethod
     def from_three_points(cls, o, p2, p3):
@@ -349,9 +351,10 @@ def duplicate(self):
 
     def to_dict(self):
         """Get Plane as a dictionary."""
-        return {'n': self.n.to_dict(),
-                'o': self.o.to_dict(),
-                'x': self.x.to_dict()}
+        return {'type': 'Plane',
+                'n': (self.n.x, self.n.y, self.n.z),
+                'o': (self.o.x, self.o.y, self.o.z),
+                'x': (self.x.x, self.x.y, self.x.z)}
 
     def __copy__(self):
         return self.__class__(self.n, self.o)

ladybug_geometry/geometry3d/pointvector.py

@@ -130,8 +130,9 @@ def duplicate(self):
         return self.__copy__()
 
     def to_dict(self):
-        """Get Vector3D/Point3D as a dictionary."""
-        return {'x': self.x,
+        """Get Vector3D as a dictionary."""
+        return {'type': 'Vector3D',
+                'x': self.x,
                 'y': self.y,
                 'z': self.z}
 
@@ -401,6 +402,13 @@ def is_equivalent(self, point, tolerance):
             abs(self.y - point.y) <= tolerance and \
             abs(self.z - point.z) <= tolerance
 
+    def to_dict(self):
+        """Get Point3D as a dictionary."""
+        return {'type': 'Point3D',
+                'x': self.x,
+                'y': self.y,
+                'z': self.z}
+
     def __add__(self, other):
         # Point + Vector -> Point
         # Point + Point -> Vector