Implemented basic builders

Author: cmpute

.pylintrc

@@ -0,0 +1,2 @@
+[TYPECHECK]
+ignored-classes=EasyDict

setup.py

@@ -1,11 +1,16 @@
 from setuptools import setup
 
+with open("README.md", "r") as fh:
+   descr = fh.read()
+
 setup(
    name='xviz',
    version='0.0.1',
    description='Python implementation of XVIZ protocol',
    author='Yuanxin Zhong',
    author_email='[email protected]',
+   url="https://github.com/cmpute/xviz.py",
+   long_description=descr,
    packages=['xviz'],
-   install_requires=['numpy'],
+   install_requires=['numpy', 'easydict'],
 )

xviz/builder/__init__.py

@@ -0,0 +1,6 @@
+"""
+This module contains classes to build messages for the XVIZ protocol.
+
+# Reference
+[@xviz/builder](https://github.com/uber/xviz/blob/master/modules/builder/README.md)
+"""

xviz/builder/base_builder.py

@@ -0,0 +1,44 @@
+
+class XVIZBaseBuilder:
+    """
+    # Reference
+    [@xviz/builder/xviz-base-builder]/(https://github.com/uber/xviz/blob/master/modules/builder/src/builders/xviz-base-builder.js)
+    """
+    def __init__(self, category, metadata, validator):
+        self._streamId = None
+        self._category = category
+        self._metadata = metadata
+        self._validator = validator
+
+    def stream(self, streamId):
+        if self._streamId:
+            self._flush()
+        self._streamId = streamId
+        return self
+
+    @property
+    def StreamId(self):
+        return self._streamId
+    @property
+    def Category(self):
+        return self._category
+    @property
+    def Metadata(self):
+        return self._metadata
+
+    def _flush(self):
+        raise NotImplementedError("Derived class should implement this method")
+    def reset(self):
+        self._category = None
+
+    def _validate(self):
+        self._validator.hasProp(self, '_streamId')
+        self._validator.hasProp(self, '_category')
+        self._validator.matchMetadata(self)
+
+    def validateWarn(self, msg):
+        self._validator.warn(msg)
+    def validateError(self, msg):
+        self._validator.error(msg)
+    def validatePropSetOnce(self, prop):
+        self._validator.propSetOnce(self, prop)

xviz/builder/pose_builder.py

@@ -0,0 +1,62 @@
+
+from easydict import EasyDict as edict
+
+from xviz.builder.base_builder import XVIZBaseBuilder
+from xviz.builder.validator import CATEGORY
+
+class XVIZPoseBuilder(XVIZBaseBuilder):
+    """
+    # Reference
+    [@xviz/builder/xviz-pose-builder]/(https://github.com/uber/xviz/blob/master/modules/builder/src/builders/xviz-pose-builder.js)
+    """
+    def __init__(self, metadata, validator):
+        super().__init__(CATEGORY.POSE, metadata, validator)
+
+        self._poses = None
+        self.reset()
+
+    def mapOrigin(self, longitude, latitude, altitude):
+        self._map_origin = dict(longitude=longitude, latitude=latitude, altitude=altitude)
+        return self
+
+    def position(self, x, y, z):
+        self._position = [x, y, z]
+        return self
+
+    def orientation(self, roll, pitch, yaw):
+        self._orientation = [roll, pitch, yaw]
+        return self
+
+    def timestamp(self, timestamp):
+        self._timestamp = timestamp
+        return self
+
+    def _flush(self):
+        if not self._poses:
+            self._poses = {}
+
+        data = edict()
+        if not self._timestamp:
+            data.timestamp = self._timestamp
+        if not self._map_origin:
+            data.map_origin = self._map_origin
+        if not self._position:
+            data.position = self._position
+        if not self._orientation:
+            data.orientation = self._orientation
+        self._poses[self._streamId] = data
+
+    def reset(self):
+        super().reset()
+
+        self._category = CATEGORY.POSE
+        self._timestamp = None
+        self._map_origin = None
+        self._position = None
+        self._orientation = None
+
+    def getData(self):
+        if self._streamId:
+            self._flush()
+
+        return edict(poses=self._poses)

xviz/builder/primitive_builder.py

@@ -0,0 +1,252 @@
+
+import numpy as np
+from easydict import EasyDict as edict
+
+from xviz.builder.base_builder import XVIZBaseBuilder
+from xviz.builder.validator import CATEGORY, PRIMITIVE_TYPES
+
+class PrimitiveBuilder(XVIZBaseBuilder):
+    """
+    # Reference
+    [@xviz/builder/xviz-primitive-builder]/(https://github.com/uber/xviz/blob/master/modules/builder/src/builders/xviz-primitive-builder.js)
+    """
+    def __init__(self, metadata, validator):
+        super().__init__(CATEGORY.PRIMITIVE, metadata, validator)
+
+        self._primitives = edict()
+        self.reset()
+
+    def image(self, data):
+        if self._type:
+            self._flush()
+
+        if not isinstance(data, np.ndarray) or not isinstance(data, str):
+            # TODO: support PILLOW and other image types
+            self.validateError("An image data must be a string or numpy array")
+        self.validatePropSetOnce("_image")
+        self._type = PRIMITIVE_TYPES.image
+        self._image = edict(data=data)
+        
+        return self
+
+    def dimensions(self, widthPixel=None, heightPixel=None):
+        if not self._image:
+            self.validateError("An image needs to be set first")
+
+        self._image.width_px = widthPixel
+        self._image.height_px = heightPixel
+
+        return self
+
+    def polygon(self, vertices):
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce("_vertices")
+        self._vertices = vertices
+        self._type = PRIMITIVE_TYPES.polygon
+
+        return self
+
+    def polyline(self, vertices):
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce("_vertices")
+        self._vertices = vertices
+        self._type = PRIMITIVE_TYPES.polyline
+
+        return self
+        
+    def points(self, vertices):
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce("_vertices")
+        self._vertices = vertices
+        self._type = PRIMITIVE_TYPES.point
+
+        return self
+
+    def circle(self, position, radius):
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce("_radius")
+        self.position(position)
+
+        self._radius = radius
+        self._type = PRIMITIVE_TYPES.circle
+
+        return self
+
+    def stadium(self, start, end, radius):
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce("_radius")
+
+        if len(start) != 3:
+            self.validateError("The start position must be of the form [x, y, z] where {} was provided".format(start))
+        if len(end) != 3:
+            self.validateError("The end position must be of the form [x, y, z] where {} was provided".format(end))
+        
+        
+        self._vertices = [start, end]
+        self._radius = radius
+        self._type = PRIMITIVE_TYPES.stadium
+
+        return self
+
+    def text(self, message):
+        # XXX: is not actually defined yet
+        if not self._type:
+            self._flush()
+
+        self.validatePropSetOnce('_text')
+
+        self._text = message
+        self._type = PRIMITIVE_TYPES.text
+
+        return self
+    
+    def position(self, point):
+        sel.validatePropSetOnce("_vertices")
+
+        if len(point) != 3:
+            self.validateError("A position must be of the form [x, y, z] where {} was provided".format(point))
+        
+        self._vertices = [point]
+        return self
+
+    def colors(self, colorArray):
+        self.validatePropSetOnce('_colors')
+        self._colors = colorArray
+
+        return self
+
+    def style(self, style):
+        self._validatePrerequisite()
+        self.validatePropSetOnce('_style')
+        self._stype = style
+
+        return self
+
+    def id(self, identifier):
+        self._validatePrerequisite()
+        self.validatePropSetOnce('_id')
+        self._id = identifier
+
+        return self
+
+    def classes(self, classList):
+        self._validatePrerequisite()
+        self.validatePropSetOnce('_classes')
+
+        self._classes = classList
+        return self
+        
+    def _validate(self):
+        super()._validate()
+
+        if self._type == PRIMITIVE_TYPES.image:
+            if self._image == None or self._image.data == None:
+                self.validateWarn("Stream {} image data are not provided.".format(self._streamId))
+        else:
+            if self._vertices == None:
+                self.validateWarn("Stream {} primitives vertices are not provided.".format(self._streamId))
+
+    def _flush(self):
+        self._validate()
+        self._flushPrimitives()
+
+    def getData(self):
+        if self._type:
+            self._flush()
+
+        if len(self._primitives) == 0:
+            return None
+
+        return self._primitives
+
+    def _validatePrerequisite(self):
+        if self._type == None:
+            self.validateError("Start from a primitive first, e.g polygon(), image(), etc.")
+
+    def _flushPrimitives(self):
+        if self._streamId not in self._primitives.keys():
+            self._primitives[self._streamId] = edict()
+        stream = self._primitives[self._streamId]
+
+        primitive = self._formatPrimitive()
+
+        arrayFieldName = self._type + 's'
+
+        if arrayFieldName not in stream:
+            stream[arrayFieldName] = []
+        array = stream[arrayFieldName]
+
+        array.push(primitive)
+        
+        self.reset()
+
+    def _formatPrimitive(self):
+        obj = edict()
+
+        # Embed primitive data
+        if self._type == PRIMITIVE_TYPES.polygon or self._type == PRIMITIVE_TYPES.polyline:
+            obj.vertices = self._vertices
+        elif self._type == PRIMITIVE_TYPES.point:
+            if self._colors != None:
+                obj.colors = self._colors
+            self.points = self._vertices
+        elif self._type == PRIMITIVE_TYPES.text:
+            obj.position = self._vertices[0]
+            obj.text = self._text
+        elif self._type == PRIMITIVE_TYPES.circle:
+            obj.center = self._vertices[0]
+            obj.radius = self._radius
+        elif self._type == PRIMITIVE_TYPES.stadium:
+            obj.start = self._vertices[0]
+            obj.end = self._vertices[1]
+            obj.radius = self._radius
+        elif self._type == PRIMITIVE_TYPES.image:
+            if self._vertices != None:
+                self._image.position = self._vertices[0]
+
+            obj.update(self._image)
+
+        # Embed base data
+        haveBase = False
+        base = edict()
+
+        if self._id != None:
+            haveBase = True
+            base.object_id = self._id
+        if self._style != None:
+            haveBase = True
+            base.style = self._style
+        if self._classes != None:
+            haveBase = True
+            base.classes = self._classes
+
+        if haveBase:
+            obj.base = base
+
+        return obj
+
+    def _validateStyle(self):
+        self._validator.validateStyle(self)
+
+    def reset(self):
+        self._type = None
+
+        self._image = None
+        self._vertices = None
+        self._radius = None
+        self._text = None
+        self._colors = None
+
+        self._id = None
+        self._style = None
+        self._classes = None