dtlpy 1.115.44__py3-none-any.whl → 1.117.6__py3-none-any.whl

dtlpy/entities/annotation_definitions/cube_3d.py

@@ -1,149 +1,149 @@
-import numpy as np
-# import open3d as o3d
-from . import BaseAnnotationDefinition
-# from scipy.spatial.transform import Rotation as R
-import logging
-
-logger = logging.getLogger(name='dtlpy')
-
-
-class Cube3d(BaseAnnotationDefinition):
-    """
-        Cube annotation object
-    """
-    type = "cube_3d"
-
-    def __init__(self, label, position, scale, rotation,
-                 attributes=None, description=None):
-        """
-        :param label:
-        :param position: the XYZ position of the ‘center’ of the annotation.
-        :param scale: the scale of the object by each axis (XYZ).
-        :param rotation: an euler representation of the object rotation on each axis (with rotation order ‘XYZ’). (rotation in radians)
-        :param attributes:
-        :param description:
-        """
-        super().__init__(description=description, attributes=attributes)
-
-        self.position = position
-        self.scale = scale
-        self.rotation = rotation
-        self.label = label
-
-    def _translate(self, points, translate_x, translate_y, translate_z):
-        translation_matrix = np.array([[1, 0, 0, 0],
-                                       [0, 1, 0, 0],
-                                       [0, 0, 1, 0],
-                                       [translate_x, translate_y, translate_z, 1]])
-
-        matrix = [(list(i) + [1]) for i in points]
-        pts2 = np.dot(matrix, translation_matrix)
-        return [pt[:3] for pt in pts2]
-
-    # def make_points(self):
-    #     simple = [
-    #         [self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2],
-    #         [-self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2],
-    #         [self.scale[0] / 2, -self.scale[1] / 2, self.scale[2] / 2],
-    #         [self.scale[0] / 2, self.scale[1] / 2, -self.scale[2] / 2],
-    #         [-self.scale[0] / 2, -self.scale[1] / 2, self.scale[2] / 2],
-    #         [self.scale[0] / 2, -self.scale[1] / 2, -self.scale[2] / 2],
-    #         [-self.scale[0] / 2, self.scale[1] / 2, -self.scale[2] / 2],
-    #         [-self.scale[0] / 2, -self.scale[1] / 2, -self.scale[2] / 2],
-    #     ]
-    #
-    #     # matrix = R.from_euler('xyz', self.rotation, degrees=False)
-    #
-    #     vecs = [np.array(p) for p in simple]
-    #     rotated = matrix.apply(vecs)
-    #     translation = np.array(self.position)
-    #     dX = translation[0]
-    #     dY = translation[1]
-    #     dZ = translation[2]
-    #     points = self._translate(rotated, dX, dY, dZ)
-    #     return points
-
-    @property
-    def geo(self):
-        return np.asarray([
-            list(self.position),
-            list(self.scale),
-            list(self.rotation)
-        ])
-
-    def show(self, image, thickness, with_text, height, width, annotation_format, color, alpha=1):
-        """
-        Show annotation as ndarray
-        :param image: empty or image to draw on
-        :param thickness:
-        :param with_text: not required
-        :param height: item height
-        :param width: item width
-        :param annotation_format: options: list(dl.ViewAnnotationOptions)
-        :param color: color
-        :param alpha: opacity value [0 1], default 1
-        :return: ndarray
-        """
-        try:
-            import cv2
-        except (ImportError, ModuleNotFoundError):
-            self.logger.error(
-                'Import Error! Cant import cv2. Annotations operations will be limited. import manually and fix errors')
-            raise
-        points = self.make_points()
-        front_bl = points[0]
-        front_br = points[1]
-        front_tr = points[2]
-        front_tl = points[3]
-        back_bl = points[4]
-        back_br = points[5]
-        back_tr = points[6]
-        back_tl = points[7]
-        logger.warning('the show for 3d_cube is not supported.')
-        return image
-
-        # image = np.zeros((100, 100, 100), dtype=np.uint8)
-        # pcd = o3d.io.read_point_cloud(r"C:\Users\97250\PycharmProjects\tt\qw\3D\D34049418_0000635.las.pcd")
-        # # o3d.visualization.draw_geometries([pcd])
-        # # points = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1],
-        # #           [0, 1, 1], [1, 1, 1]]
-        # lines = [[0, 1], [0, 2], [1, 3], [2, 3], [4, 5], [4, 6], [5, 7], [6, 7],
-        #          [0, 4], [1, 5], [2, 6], [3, 7]]
-        # colors = [[1, 0, 0] for i in range(len(lines))]
-        # points = [back_bl, back_br, back_tl, back_tr, front_bl, front_br, front_tl, front_tr]
-        # line_set = o3d.geometry.LineSet()
-        # line_set.points = o3d.utility.Vector3dVector(points)
-        # line_set.lines = o3d.utility.Vector2iVector(lines)
-        # line_set.colors = o3d.utility.Vector3dVector(colors)
-        # o3d.visualization.draw_geometries([line_set])
-        # return image
-
-    def to_coordinates(self, color=None):
-        keys = ["position", "scale", "rotation"]
-        coordinates = {keys[idx]: {"x": float(x), "y": float(y), "z": float(z)}
-                       for idx, [x, y, z] in enumerate(self.geo)}
-        return coordinates
-
-    @staticmethod
-    def from_coordinates(coordinates):
-        geo = list()
-        for key, pt in coordinates.items():
-            geo.append([pt["x"], pt["y"], pt["z"]])
-        return np.asarray(geo)
-
-    @classmethod
-    def from_json(cls, _json):
-        if "coordinates" in _json:
-            key = "coordinates"
-        elif "data" in _json:
-            key = "data"
-        else:
-            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
-
-        return cls(
-            position=list(_json[key]['position'].values()),
-            scale=list(_json[key]['scale'].values()),
-            rotation=list(_json[key]['rotation'].values()),
-            label=_json["label"],
-            attributes=_json.get("attributes", None)
-        )
+import numpy as np
+# import open3d as o3d
+from . import BaseAnnotationDefinition
+# from scipy.spatial.transform import Rotation as R
+import logging
+
+logger = logging.getLogger(name='dtlpy')
+
+
+class Cube3d(BaseAnnotationDefinition):
+    """
+        Cube annotation object
+    """
+    type = "cube_3d"
+
+    def __init__(self, label, position, scale, rotation,
+                 attributes=None, description=None):
+        """
+        :param label:
+        :param position: the XYZ position of the ‘center’ of the annotation.
+        :param scale: the scale of the object by each axis (XYZ).
+        :param rotation: an euler representation of the object rotation on each axis (with rotation order ‘XYZ’). (rotation in radians)
+        :param attributes:
+        :param description:
+        """
+        super().__init__(description=description, attributes=attributes)
+
+        self.position = position
+        self.scale = scale
+        self.rotation = rotation
+        self.label = label
+
+    def _translate(self, points, translate_x, translate_y, translate_z):
+        translation_matrix = np.array([[1, 0, 0, 0],
+                                       [0, 1, 0, 0],
+                                       [0, 0, 1, 0],
+                                       [translate_x, translate_y, translate_z, 1]])
+
+        matrix = [(list(i) + [1]) for i in points]
+        pts2 = np.dot(matrix, translation_matrix)
+        return [pt[:3] for pt in pts2]
+
+    # def make_points(self):
+    #     simple = [
+    #         [self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2],
+    #         [-self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2],
+    #         [self.scale[0] / 2, -self.scale[1] / 2, self.scale[2] / 2],
+    #         [self.scale[0] / 2, self.scale[1] / 2, -self.scale[2] / 2],
+    #         [-self.scale[0] / 2, -self.scale[1] / 2, self.scale[2] / 2],
+    #         [self.scale[0] / 2, -self.scale[1] / 2, -self.scale[2] / 2],
+    #         [-self.scale[0] / 2, self.scale[1] / 2, -self.scale[2] / 2],
+    #         [-self.scale[0] / 2, -self.scale[1] / 2, -self.scale[2] / 2],
+    #     ]
+    #
+    #     # matrix = R.from_euler('xyz', self.rotation, degrees=False)
+    #
+    #     vecs = [np.array(p) for p in simple]
+    #     rotated = matrix.apply(vecs)
+    #     translation = np.array(self.position)
+    #     dX = translation[0]
+    #     dY = translation[1]
+    #     dZ = translation[2]
+    #     points = self._translate(rotated, dX, dY, dZ)
+    #     return points
+
+    @property
+    def geo(self):
+        return np.asarray([
+            list(self.position),
+            list(self.scale),
+            list(self.rotation)
+        ])
+
+    def show(self, image, thickness, with_text, height, width, annotation_format, color, alpha=1):
+        """
+        Show annotation as ndarray
+        :param image: empty or image to draw on
+        :param thickness:
+        :param with_text: not required
+        :param height: item height
+        :param width: item width
+        :param annotation_format: options: list(dl.ViewAnnotationOptions)
+        :param color: color
+        :param alpha: opacity value [0 1], default 1
+        :return: ndarray
+        """
+        try:
+            import cv2
+        except (ImportError, ModuleNotFoundError):
+            self.logger.error(
+                'Import Error! Cant import cv2. Annotations operations will be limited. import manually and fix errors')
+            raise
+        points = self.make_points()
+        front_bl = points[0]
+        front_br = points[1]
+        front_tr = points[2]
+        front_tl = points[3]
+        back_bl = points[4]
+        back_br = points[5]
+        back_tr = points[6]
+        back_tl = points[7]
+        logger.warning('the show for 3d_cube is not supported.')
+        return image
+
+        # image = np.zeros((100, 100, 100), dtype=np.uint8)
+        # pcd = o3d.io.read_point_cloud(r"C:\Users\97250\PycharmProjects\tt\qw\3D\D34049418_0000635.las.pcd")
+        # # o3d.visualization.draw_geometries([pcd])
+        # # points = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1],
+        # #           [0, 1, 1], [1, 1, 1]]
+        # lines = [[0, 1], [0, 2], [1, 3], [2, 3], [4, 5], [4, 6], [5, 7], [6, 7],
+        #          [0, 4], [1, 5], [2, 6], [3, 7]]
+        # colors = [[1, 0, 0] for i in range(len(lines))]
+        # points = [back_bl, back_br, back_tl, back_tr, front_bl, front_br, front_tl, front_tr]
+        # line_set = o3d.geometry.LineSet()
+        # line_set.points = o3d.utility.Vector3dVector(points)
+        # line_set.lines = o3d.utility.Vector2iVector(lines)
+        # line_set.colors = o3d.utility.Vector3dVector(colors)
+        # o3d.visualization.draw_geometries([line_set])
+        # return image
+
+    def to_coordinates(self, color=None):
+        keys = ["position", "scale", "rotation"]
+        coordinates = {keys[idx]: {"x": float(x), "y": float(y), "z": float(z)}
+                       for idx, [x, y, z] in enumerate(self.geo)}
+        return coordinates
+
+    @staticmethod
+    def from_coordinates(coordinates):
+        geo = list()
+        for key, pt in coordinates.items():
+            geo.append([pt["x"], pt["y"], pt["z"]])
+        return np.asarray(geo)
+
+    @classmethod
+    def from_json(cls, _json):
+        if "coordinates" in _json:
+            key = "coordinates"
+        elif "data" in _json:
+            key = "data"
+        else:
+            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
+
+        return cls(
+            position=list(_json[key]['position'].values()),
+            scale=list(_json[key]['scale'].values()),
+            rotation=list(_json[key]['rotation'].values()),
+            label=_json["label"],
+            attributes=_json.get("attributes", None)
+        )

dtlpy/entities/annotation_definitions/description.py

@@ -1,32 +1,32 @@
-from . import BaseAnnotationDefinition
-
-
-class Description(BaseAnnotationDefinition):
-    """
-        Subtitle annotation object
-    """
-
-    def __init__(self, text, description=None):
-        super().__init__(description=description)
-        self.type = "item_description"
-        self.text = text
-        self.label = "item.description"
-
-    def to_coordinates(self, color):
-        return {"text": self.text}
-
-    @staticmethod
-    def from_coordinates(coordinates):
-        return coordinates["text"]
-
-    @classmethod
-    def from_json(cls, _json):
-        if "coordinates" in _json:
-            text = cls.from_coordinates(coordinates=_json["coordinates"])
-        elif "data" in _json:
-            text = cls.from_coordinates(coordinates=_json["data"])
-        else:
-            raise ValueError('Bad json, "coordinates", "data" or "description" not found')
-        return cls(
-            text=text,
-        )
+from . import BaseAnnotationDefinition
+
+
+class Description(BaseAnnotationDefinition):
+    """
+        Subtitle annotation object
+    """
+
+    def __init__(self, text, description=None):
+        super().__init__(description=description)
+        self.type = "item_description"
+        self.text = text
+        self.label = "item.description"
+
+    def to_coordinates(self, color):
+        return {"text": self.text}
+
+    @staticmethod
+    def from_coordinates(coordinates):
+        return coordinates["text"]
+
+    @classmethod
+    def from_json(cls, _json):
+        if "coordinates" in _json:
+            text = cls.from_coordinates(coordinates=_json["coordinates"])
+        elif "data" in _json:
+            text = cls.from_coordinates(coordinates=_json["data"])
+        else:
+            raise ValueError('Bad json, "coordinates", "data" or "description" not found')
+        return cls(
+            text=text,
+        )

dtlpy/entities/annotation_definitions/ellipse.py

@@ -1,124 +1,124 @@
-import numpy as np
-
-from . import BaseAnnotationDefinition
-
-
-class Ellipse(BaseAnnotationDefinition):
-    """
-        Ellipse annotation object
-    """
-    type = "ellipse"
-
-    def __init__(self, x, y, rx, ry, angle, label, attributes=None, description=None):
-        super().__init__(description=description, attributes=attributes)
-        self.label = label
-        self.angle = angle
-        self.x = x
-        self.y = y
-        self.rx = rx
-        self.ry = ry
-
-    @property
-    def geo(self):
-        return np.asarray([[self.x, self.y],
-                           [self.rx, self.ry],
-                           [self.angle, self.rad]])
-
-    @property
-    def rad(self):
-        return np.deg2rad(self.angle)
-
-    @property
-    def left(self):
-        return self.x - np.sqrt(np.power(self.rx, 2) * np.power(np.cos(-self.rad), 2)
-                                + np.power(self.ry, 2) * np.power(np.sin(-self.rad), 2))
-
-    @property
-    def top(self):
-        return self.y - np.sqrt(np.power(self.rx, 2) * np.power(np.sin(-self.rad), 2)
-                                + np.power(self.ry, 2) * np.power(np.cos(-self.rad), 2))
-
-    @property
-    def right(self):
-        return self.x + np.sqrt(np.power(self.rx, 2) * np.power(np.cos(-self.rad), 2)
-                                + np.power(self.ry, 2) * np.power(np.sin(-self.rad), 2))
-
-    @property
-    def bottom(self):
-        return self.y + np.sqrt(np.power(self.rx, 2) * np.power(np.sin(-self.rad), 2)
-                                + np.power(self.ry, 2) * np.power(np.cos(-self.rad), 2))
-
-    def show(self, image, thickness, with_text, height, width, annotation_format, color, alpha=1):
-        """
-        Show annotation as ndarray
-        :param image: empty or image to draw on
-        :param thickness:
-        :param with_text: not required
-        :param height: item height
-        :param width: item width
-        :param annotation_format: options: list(dl.ViewAnnotationOptions)
-        :param color: color
-        :param alpha: opacity value [0 1], default 1
-        :return: ndarray
-        """
-        try:
-            import cv2
-        except (ImportError, ModuleNotFoundError):
-            self.logger.error(
-                'Import Error! Cant import cv2. Annotations operations will be limited. import manually and fix errors')
-            raise
-
-        if thickness is None:
-            thickness = 2
-
-        # draw annotation
-        image = cv2.ellipse(
-            image,
-            center=(int(np.round(self.x)), int(np.round(self.y))),
-            axes=(int(np.round(self.rx)), int(np.round(self.ry))),
-            angle=self.angle,
-            startAngle=0,
-            endAngle=360,
-            color=color,
-            thickness=thickness,
-            lineType=-1,
-        )
-        if with_text:
-            image = self.add_text_to_image(image=image, annotation=self)
-        return image
-
-    def to_coordinates(self, color):
-        return {'angle': float(self.angle),
-                'center': {'x': float(self.x),
-                           'y': float(self.y),
-                           'z': 0},
-                'rx': float(self.rx),
-                'ry': float(self.ry)}
-
-    @staticmethod
-    def from_coordinates(coordinates):
-        angle = coordinates["angle"]
-        x = coordinates["center"]["x"]
-        y = coordinates["center"]["y"]
-        rx = coordinates["rx"]
-        ry = coordinates["ry"]
-        return x, y, rx, ry, angle
-
-    @classmethod
-    def from_json(cls, _json):
-        if "coordinates" in _json:
-            x, y, rx, ry, angle = cls.from_coordinates(_json["coordinates"])
-        elif "data" in _json:
-            x, y, rx, ry, angle = cls.from_coordinates(_json["data"])
-        else:
-            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
-
-        return cls(
-            angle=angle,
-            x=x,
-            y=y,
-            rx=rx,
-            ry=ry,
-            label=_json["label"],
-            attributes=_json.get("attributes", None),
-        )
+import numpy as np
+
+from . import BaseAnnotationDefinition
+
+
+class Ellipse(BaseAnnotationDefinition):
+    """
+        Ellipse annotation object
+    """
+    type = "ellipse"
+
+    def __init__(self, x, y, rx, ry, angle, label, attributes=None, description=None):
+        super().__init__(description=description, attributes=attributes)
+        self.label = label
+        self.angle = angle
+        self.x = x
+        self.y = y
+        self.rx = rx
+        self.ry = ry
+
+    @property
+    def geo(self):
+        return np.asarray([[self.x, self.y],
+                           [self.rx, self.ry],
+                           [self.angle, self.rad]])
+
+    @property
+    def rad(self):
+        return np.deg2rad(self.angle)
+
+    @property
+    def left(self):
+        return self.x - np.sqrt(np.power(self.rx, 2) * np.power(np.cos(-self.rad), 2)
+                                + np.power(self.ry, 2) * np.power(np.sin(-self.rad), 2))
+
+    @property
+    def top(self):
+        return self.y - np.sqrt(np.power(self.rx, 2) * np.power(np.sin(-self.rad), 2)
+                                + np.power(self.ry, 2) * np.power(np.cos(-self.rad), 2))
+
+    @property
+    def right(self):
+        return self.x + np.sqrt(np.power(self.rx, 2) * np.power(np.cos(-self.rad), 2)
+                                + np.power(self.ry, 2) * np.power(np.sin(-self.rad), 2))
+
+    @property
+    def bottom(self):
+        return self.y + np.sqrt(np.power(self.rx, 2) * np.power(np.sin(-self.rad), 2)
+                                + np.power(self.ry, 2) * np.power(np.cos(-self.rad), 2))
+
+    def show(self, image, thickness, with_text, height, width, annotation_format, color, alpha=1):
+        """
+        Show annotation as ndarray
+        :param image: empty or image to draw on
+        :param thickness:
+        :param with_text: not required
+        :param height: item height
+        :param width: item width
+        :param annotation_format: options: list(dl.ViewAnnotationOptions)
+        :param color: color
+        :param alpha: opacity value [0 1], default 1
+        :return: ndarray
+        """
+        try:
+            import cv2
+        except (ImportError, ModuleNotFoundError):
+            self.logger.error(
+                'Import Error! Cant import cv2. Annotations operations will be limited. import manually and fix errors')
+            raise
+
+        if thickness is None:
+            thickness = 2
+
+        # draw annotation
+        image = cv2.ellipse(
+            image,
+            center=(int(np.round(self.x)), int(np.round(self.y))),
+            axes=(int(np.round(self.rx)), int(np.round(self.ry))),
+            angle=self.angle,
+            startAngle=0,
+            endAngle=360,
+            color=color,
+            thickness=thickness,
+            lineType=-1,
+        )
+        if with_text:
+            image = self.add_text_to_image(image=image, annotation=self)
+        return image
+
+    def to_coordinates(self, color):
+        return {'angle': float(self.angle),
+                'center': {'x': float(self.x),
+                           'y': float(self.y),
+                           'z': 0},
+                'rx': float(self.rx),
+                'ry': float(self.ry)}
+
+    @staticmethod
+    def from_coordinates(coordinates):
+        angle = coordinates["angle"]
+        x = coordinates["center"]["x"]
+        y = coordinates["center"]["y"]
+        rx = coordinates["rx"]
+        ry = coordinates["ry"]
+        return x, y, rx, ry, angle
+
+    @classmethod
+    def from_json(cls, _json):
+        if "coordinates" in _json:
+            x, y, rx, ry, angle = cls.from_coordinates(_json["coordinates"])
+        elif "data" in _json:
+            x, y, rx, ry, angle = cls.from_coordinates(_json["data"])
+        else:
+            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
+
+        return cls(
+            angle=angle,
+            x=x,
+            y=y,
+            rx=rx,
+            ry=ry,
+            label=_json["label"],
+            attributes=_json.get("attributes", None),
+        )