dtlpy 1.113.10__py3-none-any.whl → 1.114.13__py3-none-any.whl

dtlpy/entities/annotation_definitions/polyline.py

@@ -1,111 +1,111 @@
-import numpy as np
-
-from . import BaseAnnotationDefinition
-
-
-class Polyline(BaseAnnotationDefinition):
-    """
-    Polyline annotation object
-    """
-
-    def __init__(self, geo, label, attributes=None, description=None):
-        super().__init__(description=description, attributes=attributes)
-        self.type = "polyline"
-        self.geo = geo
-        self.label = label
-
-    @property
-    def x(self):
-        return self.geo[:, 0]
-
-    @property
-    def y(self):
-        return self.geo[:, 1]
-
-    @property
-    def left(self):
-        return np.min(self.x)
-
-    @property
-    def top(self):
-        return np.min(self.y)
-
-    @property
-    def right(self):
-        return np.max(self.x)
-
-    @property
-    def bottom(self):
-        return np.max(self.y)
-
-    def to_coordinates(self, color):
-        return [[{"x": float(x), "y": float(y)} for x, y in self.geo]]
-
-    @staticmethod
-    def from_coordinates(coordinates):
-        return np.asarray([[pt["x"], pt["y"]] for pt in coordinates])
-
-    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
-
-        # polyline cant have thickness -1
-        if thickness is None or thickness == -1:
-            thickness = 2
-
-        if alpha != 1:
-            overlay = image.copy()
-        else:
-            overlay = image
-
-        overlay = cv2.polylines(
-            img=overlay,
-            pts=[np.round(self.geo).astype(int)],
-            color=color,
-            isClosed=False,
-            thickness=thickness,
-        )
-
-        if not isinstance(color, int) and len(color) == 4 and color[3] != 255:
-            # add with opacity
-            image = cv2.addWeighted(src1=overlay,
-                                    alpha=alpha,
-                                    src2=image,
-                                    beta=1 - alpha,
-                                    gamma=0)
-        else:
-            image = overlay
-
-        if with_text:
-            image = self.add_text_to_image(image=image, annotation=self)
-        return image
-
-    @classmethod
-    def from_json(cls, _json):
-        if "coordinates" in _json:
-            geo = cls.from_coordinates(coordinates=_json["coordinates"][0])
-        elif "data" in _json:
-            geo = cls.from_coordinates(coordinates=_json["data"][0])
-        else:
-            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
-        return cls(
-            geo=geo,
-            label=_json["label"],
-            attributes=_json.get("attributes", None),
-        )
+import numpy as np
+
+from . import BaseAnnotationDefinition
+
+
+class Polyline(BaseAnnotationDefinition):
+    """
+    Polyline annotation object
+    """
+
+    def __init__(self, geo, label, attributes=None, description=None):
+        super().__init__(description=description, attributes=attributes)
+        self.type = "polyline"
+        self.geo = geo
+        self.label = label
+
+    @property
+    def x(self):
+        return self.geo[:, 0]
+
+    @property
+    def y(self):
+        return self.geo[:, 1]
+
+    @property
+    def left(self):
+        return np.min(self.x)
+
+    @property
+    def top(self):
+        return np.min(self.y)
+
+    @property
+    def right(self):
+        return np.max(self.x)
+
+    @property
+    def bottom(self):
+        return np.max(self.y)
+
+    def to_coordinates(self, color):
+        return [[{"x": float(x), "y": float(y)} for x, y in self.geo]]
+
+    @staticmethod
+    def from_coordinates(coordinates):
+        return np.asarray([[pt["x"], pt["y"]] for pt in coordinates])
+
+    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
+
+        # polyline cant have thickness -1
+        if thickness is None or thickness == -1:
+            thickness = 2
+
+        if alpha != 1:
+            overlay = image.copy()
+        else:
+            overlay = image
+
+        overlay = cv2.polylines(
+            img=overlay,
+            pts=[np.round(self.geo).astype(int)],
+            color=color,
+            isClosed=False,
+            thickness=thickness,
+        )
+
+        if not isinstance(color, int) and len(color) == 4 and color[3] != 255:
+            # add with opacity
+            image = cv2.addWeighted(src1=overlay,
+                                    alpha=alpha,
+                                    src2=image,
+                                    beta=1 - alpha,
+                                    gamma=0)
+        else:
+            image = overlay
+
+        if with_text:
+            image = self.add_text_to_image(image=image, annotation=self)
+        return image
+
+    @classmethod
+    def from_json(cls, _json):
+        if "coordinates" in _json:
+            geo = cls.from_coordinates(coordinates=_json["coordinates"][0])
+        elif "data" in _json:
+            geo = cls.from_coordinates(coordinates=_json["data"][0])
+        else:
+            raise ValueError('can not find "coordinates" or "data" in annotation. id: {}'.format(_json["id"]))
+        return cls(
+            geo=geo,
+            label=_json["label"],
+            attributes=_json.get("attributes", None),
+        )

dtlpy/entities/annotation_definitions/pose.py

@@ -1,92 +1,92 @@
-import numpy as np
-import uuid
-
-from . import BaseAnnotationDefinition
-
-
-class Pose(BaseAnnotationDefinition):
-    """
-        Classification annotation object
-    """
-
-    def __init__(self, label, template_id, instance_id=None, attributes=None, points=None, description=None):
-        super().__init__(description=description, attributes=attributes)
-        self.type = "pose"
-        self.label = label
-        self.template_id = template_id
-        if instance_id is None:
-            instance_id = str(uuid.uuid1())
-        self.instance_id = instance_id
-        if points is None:
-            points = list()
-        self.points = points
-
-    @property
-    def x(self):
-        return [point.x for point in self.points]
-
-    @property
-    def y(self):
-        return [point.y for point in self.points]
-
-    @property
-    def geo(self):
-        return list()
-
-    @property
-    def left(self):
-        if not len(self.points):
-            return 0
-        return np.min(self.x)
-
-    @property
-    def top(self):
-        if not len(self.points):
-            return 0
-        return np.min(self.y)
-
-    @property
-    def right(self):
-        if not len(self.points):
-            return 0
-        return np.max(self.x)
-
-    @property
-    def bottom(self):
-        if not len(self.points):
-            return 0
-        return np.max(self.y)
-
-    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
-        """
-        if with_text:
-            image = self.add_text_to_image(image=image, annotation=self)
-        return image
-
-    def to_coordinates(self, color):
-        return {'templateId': self.template_id,
-                'instanceId': self.instance_id}
-
-    @staticmethod
-    def from_coordinates(coordinates):
-        return coordinates
-
-    @classmethod
-    def from_json(cls, _json):
-        return cls(
-            label=_json["label"],
-            attributes=_json.get("attributes", None),
-            template_id=cls.from_coordinates(_json["coordinates"])['templateId'],
-            instance_id=cls.from_coordinates(_json["coordinates"])['instanceId']
-        )
+import numpy as np
+import uuid
+
+from . import BaseAnnotationDefinition
+
+
+class Pose(BaseAnnotationDefinition):
+    """
+        Classification annotation object
+    """
+
+    def __init__(self, label, template_id, instance_id=None, attributes=None, points=None, description=None):
+        super().__init__(description=description, attributes=attributes)
+        self.type = "pose"
+        self.label = label
+        self.template_id = template_id
+        if instance_id is None:
+            instance_id = str(uuid.uuid1())
+        self.instance_id = instance_id
+        if points is None:
+            points = list()
+        self.points = points
+
+    @property
+    def x(self):
+        return [point.x for point in self.points]
+
+    @property
+    def y(self):
+        return [point.y for point in self.points]
+
+    @property
+    def geo(self):
+        return list()
+
+    @property
+    def left(self):
+        if not len(self.points):
+            return 0
+        return np.min(self.x)
+
+    @property
+    def top(self):
+        if not len(self.points):
+            return 0
+        return np.min(self.y)
+
+    @property
+    def right(self):
+        if not len(self.points):
+            return 0
+        return np.max(self.x)
+
+    @property
+    def bottom(self):
+        if not len(self.points):
+            return 0
+        return np.max(self.y)
+
+    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
+        """
+        if with_text:
+            image = self.add_text_to_image(image=image, annotation=self)
+        return image
+
+    def to_coordinates(self, color):
+        return {'templateId': self.template_id,
+                'instanceId': self.instance_id}
+
+    @staticmethod
+    def from_coordinates(coordinates):
+        return coordinates
+
+    @classmethod
+    def from_json(cls, _json):
+        return cls(
+            label=_json["label"],
+            attributes=_json.get("attributes", None),
+            template_id=cls.from_coordinates(_json["coordinates"])['templateId'],
+            instance_id=cls.from_coordinates(_json["coordinates"])['instanceId']
+        )

dtlpy/entities/annotation_definitions/ref_image.py

@@ -1,86 +1,86 @@
-from . import BaseAnnotationDefinition
-
-
-class RefImage(BaseAnnotationDefinition):
-    """
-    Create an image annotation. Reference the url or item id in this annotation type
-    """
-    type = "ref_image"
-
-    def __init__(self, ref, ref_type=None, mimetype=None, label='ref-image', attributes=None, description=None):
-
-        """
-        Create an image annotation. Used for generative model and any other algorithm where and image is the output
-
-        For type 'id', need to upload the image as item in the platform and reference the item id in the annotation.
-        For type 'url', mimetype must be provided to load the ref correctly in the platform
-
-        :param str ref: the reference to the image annotation, represented by an ‘itemId’ or ‘url’
-        :param str ref_type: one of ‘id’ | ‘url’
-        :param str mimetype: optional. in case the refType is URL, e.g. image/jpeg, video/mpeg
-        :param label: annotation label
-        :param attributes: annotation attributes
-        :param description:
-
-        :return:
-        """
-        super().__init__(description=description, attributes=attributes)
-        if ref_type is None:
-            if ref.startswith('http'):
-                ref_type = 'url'
-            else:
-                ref_type = 'id'
-        self.ref = ref
-        self.ref_type = ref_type
-        self.mimetype = mimetype
-        self.label = label
-
-    @property
-    def x(self):
-        return 0
-
-    @property
-    def y(self):
-        return 0
-
-    @property
-    def geo(self):
-        return list()
-
-    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
-        """
-        # TODO over or show the image annotations
-        return self.add_text_to_image(image=image, annotation=self)
-
-    def to_coordinates(self, color):
-        coordinates = {
-            "ref": self.ref,
-            "refType": self.ref_type,
-            "mimetype": self.mimetype,
-        }
-        return coordinates
-
-    @classmethod
-    def from_json(cls, _json):
-        coordinates = _json["coordinates"]
-        ref = coordinates.get('ref')
-        ref_type = coordinates.get('refType')
-        mimetype = coordinates.get('mimetype')
-        return cls(
-            ref=ref,
-            ref_type=ref_type,
-            mimetype=mimetype,
-            label=_json["label"],
-            attributes=_json.get("attributes", None),
-        )
+from . import BaseAnnotationDefinition
+
+
+class RefImage(BaseAnnotationDefinition):
+    """
+    Create an image annotation. Reference the url or item id in this annotation type
+    """
+    type = "ref_image"
+
+    def __init__(self, ref, ref_type=None, mimetype=None, label='ref-image', attributes=None, description=None):
+
+        """
+        Create an image annotation. Used for generative model and any other algorithm where and image is the output
+
+        For type 'id', need to upload the image as item in the platform and reference the item id in the annotation.
+        For type 'url', mimetype must be provided to load the ref correctly in the platform
+
+        :param str ref: the reference to the image annotation, represented by an ‘itemId’ or ‘url’
+        :param str ref_type: one of ‘id’ | ‘url’
+        :param str mimetype: optional. in case the refType is URL, e.g. image/jpeg, video/mpeg
+        :param label: annotation label
+        :param attributes: annotation attributes
+        :param description:
+
+        :return:
+        """
+        super().__init__(description=description, attributes=attributes)
+        if ref_type is None:
+            if ref.startswith('http'):
+                ref_type = 'url'
+            else:
+                ref_type = 'id'
+        self.ref = ref
+        self.ref_type = ref_type
+        self.mimetype = mimetype
+        self.label = label
+
+    @property
+    def x(self):
+        return 0
+
+    @property
+    def y(self):
+        return 0
+
+    @property
+    def geo(self):
+        return list()
+
+    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
+        """
+        # TODO over or show the image annotations
+        return self.add_text_to_image(image=image, annotation=self)
+
+    def to_coordinates(self, color):
+        coordinates = {
+            "ref": self.ref,
+            "refType": self.ref_type,
+            "mimetype": self.mimetype,
+        }
+        return coordinates
+
+    @classmethod
+    def from_json(cls, _json):
+        coordinates = _json["coordinates"]
+        ref = coordinates.get('ref')
+        ref_type = coordinates.get('refType')
+        mimetype = coordinates.get('mimetype')
+        return cls(
+            ref=ref,
+            ref_type=ref_type,
+            mimetype=mimetype,
+            label=_json["label"],
+            attributes=_json.get("attributes", None),
+        )