Unwrap bounding box augmentation

changelogs/master/added/20190927_unwrapped_bb_aug.md

@@ -0,0 +1,36 @@
+# Unwrapped Bounding Box Augmentation #446
+
+* Added property `coords` to `BoundingBox`. The property returns an `(N,2)`
+  numpy array containing the coordinates of the top-left and bottom-right
+  bounding box corners.
+* Added method `BoundingBox.coords_almost_equals(other)`.
+* Added method `BoundingBox.almost_equals(other)`.
+* Changed method `Polygon.almost_equals(other)` to no longer verify the
+  datatype. It is assumed now that the input is a Polygon.
+* Added property `items` to `KeypointsOnImage`, `BoundingBoxesOnImage`,
+  `PolygonsOnImage`, `LineStringsOnImage`. The property returns the
+  keypoints/BBs/polygons/LineStrings contained by that instance.
+* Added method `Polygon.coords_almost_equals(other)`. Alias for
+  `Polygon.exterior_almost_equals(other)`.
+* Added property `Polygon.coords`. Alias for `Polygon.exterior`.
+* Added property `Keypoint.coords`.
+* Added method `Keypoint.coords_almost_equals(other)`.
+* Added method `Keypoint.almost_equals(other)`.
+* Added method `imgaug.testutils.assert_cbaois_equal()`.
+* Added method `imgaug.testutils.shift_cbaoi()`.
+* Added internal `_augment_bounding_boxes()` methods to various augmenters.
+  This allows to individually control how bounding boxes are supposed to
+  be augmented. Previously, the bounding box augmentation was a wrapper around
+  keypoint augmentation that did not allow such control.
+* [breaking] Added parameter `parents` to `Augmenter.augment_bounding_boxes()`.
+  This breaks if `hooks` was used as a *positional* argument in connection with
+  that method.
+* [breaking] Added parameter `func_bounding_boxes` to `Lambda`. This
+  breaks if one relied on the order of the augmenter's parameters instead of
+  their names.
+* [breaking] Added parameter `func_bounding_boxes` to `AssertLambda`. This
+  breaks if one relied on the order of the augmenter's parameters instead of
+  their names.
+* [breaking] Added parameter `check_bounding_boxes` to `AssertShape`. This
+  breaks if one relied on the order of the augmenter's parameters instead of
+  their names.

changelogs/master/fixed/20190928_fixed_affine_coords_aug.md

@@ -0,0 +1,3 @@
+* Fixed `Affine` coordinate-based augmentation applying wrong offset
+  when shifting images to/from top-left corner. This would lead to an error
+  of around 0.5 to 1.0 pixels. #446

changelogs/master/fixed/20190928_fixed_pwa_empty_kps_unaligned.md

@@ -0,0 +1,2 @@
+* Fixed keypoint augmentation in `PiecewiseAffine` potentially being
+  unaligned if a `KeypointsOnImage` instance contained no keypoints. #446

changelogs/master/fixed/20190928_fixed_type_val.md

@@ -0,0 +1,2 @@
+* Fixed `imgaug.validation.convert_iterable_to_string_of_types()` crashing due
+  to not converting types to strings before joining them. #446

changelogs/master/fixed/20190929_fixed_assert_is_iterable_of.md

@@ -0,0 +1,2 @@
+* Fixed `imgaug.validation.assert_is_iterable_of()` producing a not
+  well-designed error if the input was not an iterable. #446

imgaug/augmentables/bbs.py

@@ -53,6 +53,22 @@ def __init__(self, x1, y1, x2, y2, label=None):
         self.y2 = y2
         self.label = label
 
+    @property
+    def coords(self):
+        """Get the top-left and bottom-right coordinates as one array.
+
+        Returns
+        -------
+        ndarray
+            A ``(N, 2)`` numpy array with ``N=2`` containing the top-left
+            and bottom-right coordinates.
+
+        """
+        arr = np.empty((2, 2), dtype=np.float32)
+        arr[0, :] = (self.x1, self.y1)
+        arr[1, :] = (self.x2, self.y2)
+        return arr
+
     @property
     def x1_int(self):
         """Get the x-coordinate of the top left corner as an integer.
@@ -762,6 +778,74 @@ def to_keypoints(self):
             Keypoint(x=self.x1, y=self.y2)
         ]
 
+    def coords_almost_equals(self, other, max_distance=1e-4):
+        """Estimate if this and another BB have almost identical coordinates.
+
+        Parameters
+        ----------
+        other : imgaug.augmentables.bbs.BoundingBox or iterable
+            The other bounding box with which to compare this one.
+            If this is an ``iterable``, it is assumed to represent the top-left
+            and bottom-right coordinates of that bounding box, given as e.g.
+            an ``(2,2)`` ndarray or an ``(4,)`` ndarray or as a similar list.
+
+        max_distance : number, optional
+            The maximum euclidean distance between a corner on one bounding
+            box and the closest corner on the other bounding box. If the
+            distance is exceeded for any such pair, the two BBs are not
+            viewed as equal.
+
+        Returns
+        -------
+        bool
+            Whether the two bounding boxes have almost identical corner
+            coordinates.
+
+        """
+        if ia.is_np_array(other):
+            # we use flat here in case other is (N,2) instead of (4,)
+            coords_b = other.flat
+        elif ia.is_iterable(other):
+            coords_b = list(ia.flatten(other))
+        else:
+            assert isinstance(other, BoundingBox), (
+                "Expected 'other' to be an iterable containing two "
+                "(x,y)-coordinate pairs or a BoundingBox. "
+                "Got type %s." % (type(other),))
+            coords_b = other.coords.flat
+
+        coords_a = self.coords
+
+        return np.allclose(coords_a.flat, coords_b, atol=max_distance, rtol=0)
+
+    def almost_equals(self, other, max_distance=1e-4):
+        """Compare this and another BB's label and coordinates.
+
+        This is the same as
+        :func:`imgaug.augmentables.bbs.BoundingBox.coords_almost_equals` but
+        additionally compares the labels.
+
+        Parameters
+        ----------
+        other : imgaug.augmentables.bbs.BoundingBox or iterable
+            The other object to compare against. Expected to be a
+            ``BoundingBox``.
+
+        max_distance : number, optional
+            See
+            :func:`imgaug.augmentables.bbs.BoundingBox.coords_almost_equals`.
+
+        Returns
+        -------
+        bool
+            ``True`` if the coordinates are almost equal and additionally
+            the labels are equal. Otherwise ``False``.
+
+        """
+        if self.label != other.label:
+            return False
+        return self.coords_almost_equals(other, max_distance=max_distance)
+
     def copy(self, x1=None, y1=None, x2=None, y2=None, label=None):
         """Create a shallow copy of this BoundingBox instance.
 
@@ -873,6 +957,18 @@ def __init__(self, bounding_boxes, shape):
         self.bounding_boxes = bounding_boxes
         self.shape = normalize_shape(shape)
 
+    @property
+    def items(self):
+        """Get the bounding boxes in this container.
+
+        Returns
+        -------
+        list of BoundingBox
+            Bounding boxes within this container.
+
+        """
+        return self.bounding_boxes
+
     # TODO remove this? here it is image height, but in BoundingBox it is
     #      bounding box height
     @property

imgaug/augmentables/kps.py

@@ -82,6 +82,21 @@ def __init__(self, x, y):
         self.x = x
         self.y = y
 
+    @property
+    def coords(self):
+        """Get the xy-coordinates as an ``(N,2)`` ndarray.
+
+        Returns
+        -------
+        ndarray
+            An ``(N, 2)`` ``float32`` ndarray with ``N=1`` containing the
+            coordinates of this keypoints.
+
+        """
+        arr = np.empty((1, 2), dtype=np.float32)
+        arr[0, :] = [self.x, self.y]
+        return arr
+
     @property
     def x_int(self):
         """Get the keypoint's x-coordinate, rounded to the closest integer.
@@ -330,6 +345,69 @@ def generate_similar_points_manhattan(self, nb_steps, step_size,
             return points
         return [self.deepcopy(x=point[0], y=point[1]) for point in points]
 
+    def coords_almost_equals(self, other, max_distance=1e-4):
+        """Estimate if this and another KP have almost identical coordinates.
+
+        Parameters
+        ----------
+        other : imgaug.augmentables.kps.Keypoint or iterable
+            The other keypoint with which to compare this one.
+            If this is an ``iterable``, it is assumed to contain the
+            xy-coordinates of a keypoint.
+
+        max_distance : number, optional
+            The maximum euclidean distance between a this keypoint and the
+            other one. If the distance is exceeded, the two keypoints are not
+            viewed as equal.
+
+        Returns
+        -------
+        bool
+            Whether the two keypoints have almost identical coordinates.
+
+        """
+        if ia.is_np_array(other):
+            # we use flat here in case other is (N,2) instead of (4,)
+            coords_b = other.flat
+        elif ia.is_iterable(other):
+            coords_b = list(ia.flatten(other))
+        else:
+            assert isinstance(other, Keypoint), (
+                "Expected 'other' to be an iterable containing one "
+                "(x,y)-coordinate pair or a Keypoint. "
+                "Got type %s." % (type(other),))
+            coords_b = other.coords.flat
+
+        coords_a = self.coords
+
+        return np.allclose(coords_a.flat, coords_b, atol=max_distance, rtol=0)
+
+    def almost_equals(self, other, max_distance=1e-4):
+        """Compare this and another KP's coordinates.
+
+        .. note ::
+
+            This method is currently identical to ``coords_almost_equals``.
+            It exists for consistency with ``BoundingBox`` and ``Polygons``.
+
+        Parameters
+        ----------
+        other : imgaug.augmentables.kps.Keypoint or iterable
+            The other object to compare against. Expected to be a
+            ``Keypoint``.
+
+        max_distance : number, optional
+            See
+            :func:`imgaug.augmentables.kps.Keypoint.coords_almost_equals`.
+
+        Returns
+        -------
+        bool
+            ``True`` if the coordinates are almost equal. Otherwise ``False``.
+
+        """
+        return self.coords_almost_equals(other, max_distance=max_distance)
+
     def copy(self, x=None, y=None):
         """Create a shallow copy of the keypoint instance.
 
@@ -406,6 +484,18 @@ def __init__(self, keypoints, shape):
         self.keypoints = keypoints
         self.shape = normalize_shape(shape)
 
+    @property
+    def items(self):
+        """Get the keypoints in this container.
+
+        Returns
+        -------
+        list of Keypoint
+            Keypoints within this container.
+
+        """
+        return self.keypoints
+
     @property
     def height(self):
         return self.shape[0]

imgaug/augmentables/lines.py

@@ -1427,8 +1427,8 @@ def almost_equals(self, other, max_distance=1e-4, points_per_edge=8):
         Parameters
         ----------
         other: imgaug.augmentables.lines.LineString
-            The other line string. Must be a LineString instance, not just
-            its coordinates.
+            The other object to compare against. Expected to be a
+            ``LineString``.
 
         max_distance : float, optional
             See :func:`imgaug.augmentables.lines.LineString.coords_almost_equals`.
@@ -1439,9 +1439,8 @@ def almost_equals(self, other, max_distance=1e-4, points_per_edge=8):
         Returns
         -------
         bool
-            ``True`` if the coordinates are almost equal according to
-            :func:`imgaug.augmentables.lines.LineString.coords_almost_equals`
-            and additionally the labels are equal. Otherwise ``False``.
+            ``True`` if the coordinates are almost equal and additionally
+            the labels are equal. Otherwise ``False``.
 
         """
         if self.label != other.label:
@@ -1555,6 +1554,18 @@ def __init__(self, line_strings, shape):
         self.line_strings = line_strings
         self.shape = normalize_shape(shape)
 
+    @property
+    def items(self):
+        """Get the line strings in this container.
+
+        Returns
+        -------
+        list of LineString
+            Line strings within this container.
+
+        """
+        return self.line_strings
+
     @property
     def empty(self):
         """Estimate whether this object contains zero line strings.