Trying to do good enough measurement

Author: cindygr

Image_based/LeaderDetector.py

@@ -147,6 +147,11 @@ def __init__(self, path, image_name, b_output_debug=True, b_recalc=False):
 
                 quad.draw_quad(self.images["RGB_Stats"])
 
+        for quad in self.vertical_leader_quads:
+            score = self.score_quad(quad)
+            print(f"Score {score}")
+
+
     def read_images(self, path, image_name):
         """ Read in all of the mask, rgb, flow images
         If Edge image does not exist, create it
@@ -441,6 +446,26 @@ def flow_mask(self, quad):
         im_mask[pixel_labels[0] == label_count[-1][1]] = 255
         return im_mask.reshape((im_flow.shape[0], im_flow.shape[1])), im_mask_labels.reshape((im_flow.shape[0], im_flow.shape[1]))
 
+    def score_quad(self, quad):
+        """ See if the quad makes sense over the optical flow image
+        @quad - the quad
+        """
+
+        # Two checks: one, are the depth/optical fow values largely consistent under the quad center
+        #  Are there boundaries in the optical flow image where the edge of the quad is?
+        im_flow_mask = cv2.cvtColor(self.images["Flow"], cv2.COLOR_BGR2GRAY)
+        perc_consistant, stats_slice = quad.check_interior_depth(im_flow_mask)
+
+        diff = 0
+        for i in range(1, len(stats_slice)):
+            diff_slices = np.abs(stats_slice[i]["Median"] - stats_slice[i-1]["Median"])
+            if diff_slices > 20:
+                print(f"Warning: Depth values not consistant from slice {self.name} {i} {stats_slice}")
+            diff += diff_slices
+        if perc_consistant < 0.9:
+            print(f"Warning: not consistant {self.name} {stats_slice}")
+        return perc_consistant, diff / (len(stats_slice) - 1)
+
 
 if __name__ == '__main__':
     path = "./data/predictions/"

Image_based/cyl_fit_2d.py

@@ -70,6 +70,21 @@ def edge_pts(self, t):
         right_pt = [pt[0] + vec_step[1], pt[1] - vec_step[0]]
         return left_pt, right_pt
 
+    @staticmethod
+    def _rect_in_image(im, r, pad=2):
+        """ See if the rectangle is within the image boundaries
+        @im - image (for width and height)
+        @r - the rectangle
+        @pad - how much to allow for overlap
+        @return True or False"""
+        if np.min(r) < pad:
+            return False
+        if np.max(r[:, 0]) > im.shape[1] + pad:
+            return False
+        if np.max(r[:, 1]) > im.shape[0] + pad:
+           return False
+        return True
+
     def _rect_corners(self, t1, t2, perc_width=0.3):
         """ Get two rectangles covering the expected edges of the cylinder
         @param t1 starting t value
@@ -172,33 +187,30 @@ def _image_cutout(self, im, rect, step_size, height):
         tform3_back = np.linalg.pinv(tform3)
         return cv2.warpPerspective(im, tform3, (step_size, height)), tform3_back
 
-    def depth_mask(self, im_depth, step_size=40, perc_width=0.3):
+    def check_interior_depth(self, im_depth, step_size=40, perc_width=0.3):
         """ Find which pixels are valid depth and fit average depth
         @param im_depth - depth image
         @param step_size how many pixels to move along the boundary
         @param perc_width How much of the radius to move in/out of the edge
         """
         height = int(self.radius_2d)
-        rect_destination = np.array([[0, 0], [step_size, 0], [step_size, height], [0, height]], dtype="float32")
-        ts, rects = self.interior_rects(self, step_size=step_size, perc_width=perc_width)
-        l_col = height // 4
-        r_col = 3 * height // 4
-        for r in rects:
-            tform3 = cv2.getPerspectiveTransform(r, rect_destination)
-            tform3_back = np.linalg.pinv(tform3)
-            im_warp = cv2.warpPerspective(im_depth, tform3, (step_size, height))
-            for r in range(0, step_size):
-                row = []
-                row_mean = []
-                for c in range(0, height):
-                    if im_warp[r, c, 0] > 100 and im_warp[r, c, 1] < 50:
-                        row.append(c, im_warp[r, c, 0] / 255.0)
-                        if l_col < c < r_col:
-                            row_mean.append(im_warp[r, c, 0] / 255.0)
-
-
-            im_debug = cv2.cvtColor(im_warp, cv2.COLOR_GRAY2RGB)
-        return rects, ts
+        rects, ts = self.interior_rects(step_size=step_size, perc_width=perc_width)
+
+        stats = []
+        perc_consistant = 0.0
+        for i, r in enumerate(rects):
+            b_rect_inside = Quad._rect_in_image(im_depth, r, pad=2)
+
+            im_warp, tform_inv = self._image_cutout(im_depth, r, step_size=step_size, height=height)
+
+            stats_slice = {"Min": np.min(im_warp),
+                           "Max": np.max(im_warp),
+                           "Median": np.median(im_warp)}
+            stats_slice["Perc_in_range"] = np.count_nonzero(np.abs(im_warp - stats_slice["Median"]) < 10) / (im_warp.size)
+            perc_consistant += stats_slice["Perc_in_range"]
+            stats.append(stats_slice)
+        perc_consistant /= len(rects)
+        return perc_consistant, stats
 
     def find_edges_hough_transform(self, im_edge, step_size=40, perc_width=0.3, axs=None):
         """Find the hough transform of the images in the boxes; save the line orientations
@@ -222,13 +234,7 @@ def find_edges_hough_transform(self, im_edge, step_size=40, perc_width=0.3, axs=
         line_b = np.zeros((3, 1))
         line_b[2, 0] = 1.0
         for i_rect, r in enumerate(rects):
-            b_rect_inside = True
-            if np.min(r) < -2:
-                b_rect_inside = False
-            if np.max(r[:, 0]) > im_edge.shape[1]:
-                b_rect_inside = False
-            if np.max(r[:, 1]) > im_edge.shape[0]:
-                b_rect_inside = False
+            b_rect_inside = Quad._rect_in_image(im_edge, r, pad=2)
 
             im_warp, tform3_back = self._image_cutout(im_edge, r, step_size=step_size, height=height)
             i_seg = i_rect // 2
@@ -391,13 +397,7 @@ def adjust_quad_by_mask(self, im_mask, step_size=40, perc_width=1.2, axs=None):
         if axs is not None:
             axs.imshow(im_mask, origin='lower')
         for i, r in enumerate(rects):
-            b_rect_inside = True
-            if np.min(r) < -2:
-                b_rect_inside = False
-            if np.max(r[:, 0]) > im_mask.shape[1]:
-                b_rect_inside = False
-            if np.max(r[:, 1]) > im_mask.shape[0]:
-                b_rect_inside = False
+            b_rect_inside = Quad._rect_in_image(im_mask, r, pad=2)
 
             im_warp, tform_inv = self._image_cutout(im_mask, r, step_size=step_size, height=height)
             if b_rect_inside and np.sum(im_warp > 0) > 0: