Changing how non-existant masks are handled, starting to integrate bspline code

Author: cindygr

Image_based/BaseStatsImage.py

@@ -55,9 +55,9 @@ def __init__(self, fname_mask_image, fname_calculated=None, fname_debug=None, b_
         if exists(fname_mask_image):
             mask_image_rgb = cv2.imread(fname_mask_image)
         else:
-            self.mask_image = np.zeros((8, 8), dtype=np.uint8)
-            return
-        
+            mask_image_rgb = np.zeros((640, 480), dtype=np.uint8)
+            mask_image_rgb[200:230, 10:260] = 1
+
         if len(mask_image_rgb.shape) == 3:
             self.mask_image = cv2.cvtColor(mask_image_rgb, cv2.COLOR_BGR2GRAY)
         else:

Image_based/HandleFileNames.py

@@ -321,15 +321,15 @@ def get_mask_name(self, path, index, b_add_tag=True):
         return im_name
 
     def loop_images(self):
-        """ A generator that loops over all of the images and generates an index for each
+        """ a generator that loops over all of the images and generates an index for each
         The index can be passed to get_image_name to get the actual image name
         @return a tuple that can be used to get the image name"""
         for i, _ in enumerate(self.sub_dirs):
             for j, _ in enumerate(self.image_names[i]):
                 yield i, j
 
     def loop_masks(self, mask_type=""):
-        """ A generator that loops over all of the masks and generates an index for each
+        """ a generator that loops over all of the masks and generates an index for each
         The index can be passed to get_mask_name to get the actual mask name
         @param mask_type: Optional parameter; if set, return only masks of the given name (eg trunk)
         @return a tuple that can be used to get the mask name"""

Image_based/bezier_cyl_2d.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 
-# A 2D quadratic Bezier with additional radius information
+# a 2D quadratic Bezier with additional radius information
 #  - also keeps primary orientation (left, right or up, down)
 #  - Assumes this is a curve in the image; all coordinates are in image coordinates
 #
 # Primary code:
-#   A bezier curve is defined by f(t)->[x,y] for t going from 0 to 1
+#   a bezier curve is defined by f(t)->[x,y] for t going from 0 to 1
 #   Currently a fixed radius along the cylinder/tube
 #   Using the tangent and the normal (orthogonal to tangent) we can define rectangles
 #     1) Rectangles that follow the axis of the curve and cover the interior of the curve

Image_based/extract_curves.py

@@ -39,10 +39,6 @@ def __init__(self, fname_rgb_image, fname_edge_image, fname_mask_image, params=N
                                               fname_debug=fname_debug,
                                               b_recalc=b_recalc)
 
-        if not exists(fname_mask_image):
-            self.params = None
-            return
-
         # List o pairs (t, plus/minus)
         self.left_curve = []
         self.right_curve = []

Image_based/fit_bezier_cyl_2d.py

@@ -33,7 +33,7 @@ def setup_least_squares(self, ts):
         """Setup the least squares approximation - ts is the number of constraints to add, also
            puts in a copule constraints to keep end points where they are
         @param ts - t values to use
-        @returns A, B for Ax = b """
+        @returns a, b for Ax = b """
         # Set up the matrix - include the 3 current points plus the centers of the mask
         a_constraints = np.zeros((len(ts) + 3, 3))
         ts_constraints = np.zeros((len(ts) + 3))
@@ -51,7 +51,7 @@ def setup_least_squares(self, ts):
 
     def extract_least_squares(self, a_constraints, b_rhs):
         """ Do the actual Ax = b and keep horizontal/vertical end points
-        @param a_constraints the A of Ax = b
+        @param a_constraints the a of Ax = b
         @param b_rhs the b of Ax = b
         @returns fit error L0 norm"""
         if a_constraints.shape[0] < 3:

Image_based/fit_bezier_cyl_2d_edge.py

@@ -84,10 +84,6 @@ def __init__(self, fname_rgb_image, fname_edge_image, fname_mask_image, fname_ca
         #   This is the curve that will be fit to the edge
         self.bezier_crv_fit_to_edge = None
 
-        if not exists(fname_mask_image):
-            self.params = None
-            return
-
         # Copy params used in fit mask and add the new ones
         self.params = {}
         for k in self.mask_crv.params.keys():

Image_based/fit_bezier_cyl_2d_mask.py

@@ -34,10 +34,6 @@ def __init__(self, fname_mask_image, fname_calculated=None, fname_debug=None, pa
         # First do the stats - this also reads the image in
         self.stats_dict = BaseStatsImage(fname_mask_image, fname_calculated, fname_debug, b_recalc)
 
-        if not exists(fname_mask_image):
-            self.params = None
-            return
-        
         # Now initialize bezier curve with info from stats - no need to cache this because it's so light-weight
         p0 = self.stats_dict.stats_dict["lower_left"]
         p2 = self.stats_dict.stats_dict["upper_right"]
@@ -186,7 +182,7 @@ def fit_bezier_crv_to_mask(bezier_crv, im_mask, params):
         return fit_bezier_crv.get_copy_of_2d_bezier_curve()
 
     def score_mask_fit(self, im_mask):
-        """ A modified intersection over union that discounts pixels along the bezier cylinder mask
+        """ a modified intersection over union that discounts pixels along the bezier cylinder mask
         @param im_mask - the mask image
         """
 

Image_based/line_seg_2d.py

@@ -8,7 +8,7 @@
 
 class LineSeg2D:
     def __init__(self, p1, p2):
-        """ Line segment with Ax + By + C form for closest point
+        """ Line segment with Ax + By + c form for closest point
         @param p1: Pt 1
         @param p2: Pt 2"""
 
@@ -22,10 +22,10 @@ def __init__(self, p1, p2):
 
     @staticmethod
     def line(p1, p2):
-        """ A line in implicit coordinates
+        """ a line in implicit coordinates
         @param p1 end point one
         @param p2 end point two
-        @return A x + B y + C"""
+        @return a x + b y + c"""
         A = (p1[1] - p2[1])
         B = (p2[0] - p1[0])
         C = (p1[0] * p2[1] - p2[0] * p1[1])
@@ -37,14 +37,14 @@ def intersection(L1, L2):
         @param L1 - line one in implicit coords
         @param L2 - line two in implicit coords
         @return x, y if intersection point, None otherwise"""
-        D  = L1.A * L2.B - L1.B * L2.A
-        Dx = L1.C * L2.B - L1.B * L2.C
-        Dy = L1.A * L2.C - L1.C * L2.A
+        D  = L1.a * L2.b - L1.b * L2.a
+        Dx = L1.c * L2.b - L1.b * L2.c
+        Dy = L1.a * L2.c - L1.c * L2.a
         if abs(D) > 1e-10:
             x = -Dx / D
             y = -Dy / D
-            check1 = L1.A * x + L1.B * y + L1.C
-            check2 = L2.A * x + L2.B * y + L2.C
+            check1 = L1.a * x + L1.b * y + L1.c
+            check2 = L2.a * x + L2.b * y + L2.c
             if not np.isclose(check1, 0.0) or not np.isclose(check2, 0.0):
                 raise ValueError("LineSeg2D: Making line, pts not on line")
             return x, y
@@ -53,8 +53,8 @@ def intersection(L1, L2):
 
     def projection(self, pt):
         """Project the point onto the line and return the t value
-        A ((1-t)p1x + t p2x) + B ((1-t)p1y + t p2y) + C = 0
-        t (A(p2x-p1x) + B(p2y-p1y)) = -C - A (p1x + p2x) - B(p1y + p2y)
+        a ((1-t)p1x + t p2x) + b ((1-t)p1y + t p2y) + c = 0
+        t (a(p2x-p1x) + b(p2y-p1y)) = -c - a (p1x + p2x) - b(p1y + p2y)
         @param pt - pt to project
         @return t of projection point"""
 

MySliders.py

@@ -4,7 +4,7 @@
 from PyQt5.QtWidgets import QHBoxLayout, QSlider, QWidget, QLabel, QPushButton
 
 
-# A helper class that implements a slider with given start and end float value; displays values
+# a helper class that implements a slider with given start and end float value; displays values
 class SliderFloatDisplay(QWidget):
     gui = None
 

fit_routines/b_spline_curve_fit.py

@@ -7,7 +7,7 @@
 from matplotlib import pyplot as plt
 
 from tree_geometry.b_spline_curve import BSplineCurve
-from .params import fit_params
+from params import fit_params
 
 logger = logging.getLogger("b_spline_fit")
 logger.setLevel(level=logging.DEBUG)

sketch_curves_gui/Draw_spline_3D.py

@@ -179,29 +179,34 @@ def draw_crv_3d(self, crv_3d):
                     GL.glNormal3d(n[0], n[1], n[2])
                 GL.glEnd()
 
-    def bind_texture(self, rgb_image, mask_image, edge_image, flow_image, depth_image):
-        print(f"Binding texture {rgb_image.shape} {edge_image.shape}")
+    def bind_texture(self, images):
+        rgb_image = images["rgb"]
         self.aspect_ratio = rgb_image.shape[0] / rgb_image.shape[1]
         self.im_size = (rgb_image.shape[1], rgb_image.shape[0])
 
-        #im_check = np.ones((im_size, im_size, 3), dtype=np.uint8)
-        #im_check[:,:] *= 64
-        #im_check[:,:,0] *= 128
-        #im_check[:,:,0] *= 192
-
         im_size = 512
         if rgb_image.shape[0] > 1024:
             im_size = 1024
         im_sq = cv2.resize(rgb_image, (im_size, im_size))
 
-        im_sq_mask = cv2.cvtColor(cv2.resize(mask_image, (im_size, im_size)), cv2.COLOR_GRAY2RGB)
-        im_sq_edge = cv2.cvtColor(cv2.resize(edge_image, (im_size, im_size)), cv2.COLOR_GRAY2RGB)
-        if flow_image is not None:
-            im_sq_flow = cv2.resize(flow_image, (im_size, im_size))
+        if "mask" in images:
+            im_sq_mask = cv2.cvtColor(cv2.resize(images["mask"], (im_size, im_size)), cv2.COLOR_GRAY2RGB)
+        else:
+            im_sq_mask = im_sq
+        if "edge" in images:
+            if len(images["edge"].shape) == 3:
+                images["edge"] = cv2.cvtColor(images["edge"], cv2.COLOR_BGR2GRAY)
+            im_sq_edge = cv2.cvtColor(cv2.resize(images["edge"], (im_size, im_size)), cv2.COLOR_GRAY2RGB)
+        else:
+            im_sq_edge = im_sq
+
+        if "flow" in images:
+            im_sq_flow = cv2.resize(images["flow"], (im_size, im_size))
         else:
             im_sq_flow = None
-        if depth_image is not None:
-            im_sq_depth = cv2.resize(depth_image, (im_size, im_size))
+
+        if "depth" in images:
+            im_sq_depth = cv2.resize(images["depth"], (im_size, im_size))
         else:
             im_sq_depth = None
 

sketch_curves_gui/Sketch_curves_main_window.py

@@ -6,10 +6,12 @@
 sys.path.insert(0, os.path.abspath('./Image_based'))
 sys.path.insert(0, os.path.abspath('./Utilities'))
 sys.path.insert(0, os.path.abspath('./sketch_curves_gui'))
+sys.path.insert(0, os.path.abspath('./fit_routines'))
 sys.path.insert(0, os.path.abspath('../'))
 sys.path.insert(0, os.path.abspath('../Image_based'))
 sys.path.insert(0, os.path.abspath('../Utilities'))
 sys.path.insert(0, os.path.abspath('../sketch_curves_gui'))
+sys.path.insert(0, os.path.abspath('../fit_routines'))
 from os.path import exists
 
 # Get OpenGL
@@ -29,6 +31,7 @@
 
 from sketch_curves_gui.Sketches_for_curves import SketchesForCurves
 
+from b_spline_curve_fit import BSplineCurveFit
 
 class SketchCurvesMainWindow(QMainWindow):
     def __init__(self):
@@ -77,8 +80,10 @@ def _init_left_layout_(self):
         path_names_layout = QGridLayout()
         path_names_layout.setColumnMinimumWidth(0, 40)
         path_names_layout.setColumnMinimumWidth(1, 200)
-        self.path_name = QLineEdit("/Users/cindygrimm/PycharmProjects/treefitting/Image_based/data/EnvyTree/")
-        self.file_name = QLineEdit("envy_fnames.json")
+        # self.path_name = QLineEdit("/Users/cindygrimm/PycharmProjects/treefitting/Image_based/data/EnvyTree/")
+        # self.file_name = QLineEdit("envy_fnames.json")
+        self.path_name = QLineEdit("/Users/cindygrimm/PycharmProjects/treefitting/Image_based/data/")
+        self.file_name = QLineEdit("forcindy_bspline.json")
         self.sub_dir_number = SliderIntDisplay("Sub dir", 0, 10, 0)
         self.image_number = SliderIntDisplay("Image", 0, 10, 0)
         self.mask_number = SliderIntDisplay("Mask", 0, 3, 0)
@@ -500,7 +505,7 @@ def set_crv(self, params):
 
         depth_fname = self.handle_filenames.get_depth_image_name(index=self.last_index, b_add_tag=True)
         if exists(depth_fname):
-            depth_fname_calculate = self.handle_filenames.get_mask_name(index=self.last_index, b_add_tag=False)
+            depth_fname_calculate = self.handle_filenames.get_mask_name(index=self.last_index, b_calculate_path=True, b_add_tag=False)
             depth_fname_debug = self.handle_filenames.get_mask_name(index=self.last_index, b_debug_path=True, b_add_tag=False)
             params = {"camera_width_angle": self.horizontal_angle.value()}
             self.fit_crv_3d = FitBezierCyl3dDepth(depth_fname, self.crv.bezier_crv_fit_to_edge,
@@ -517,31 +522,21 @@ def read_images(self):
             b_get_image, self.last_index = self.reset_file_menus()
             print(f" masks {self.handle_filenames.mask_ids[self.last_index[0]][self.last_index[1]][self.last_index[2]]}")
             if b_get_image:
-                image_flow_name = self.handle_filenames.get_flow_image_name(index=self.last_index, b_add_tag=True)
-                image_depth_name = self.handle_filenames.get_depth_image_name(index=self.last_index, b_add_tag=True)
-
-                if exists(image_flow_name):
-                    image_flow = cv2.imread(image_flow_name)
-                else:
-                    image_flow = None
-
-                if exists(image_depth_name):
-                    image_depth = cv2.imread(image_depth_name)
-                else:
-                    image_depth = None
+                self.image_names = {}
+                self.image_names["rgb"] = self.handle_filenames.get_image_name(index=self.last_index, b_add_tag=True)
+                self.image_names["mask"] = self.handle_filenames.get_mask_name(index=self.last_index, b_add_tag=True)
+                self.image_names["edge"] = self.handle_filenames.get_edge_name(index=self.last_index, b_add_tag=True)
+                self.image_names["flow"] = self.handle_filenames.get_flow_image_name(index=self.last_index, b_add_tag=True)
+                self.image_names["depth"] = self.handle_filenames.get_depth_image_name(index=self.last_index, b_add_tag=True)
+
+                self.images = {}
+                for k, v in self.image_names.items():
+                    if exists(v):
+                        self.images[k] = cv2.imread(v)
 
                 self.set_crv(params=None)
-                if self.crv.mask_crv.stats_dict.mask_image.size < 256:
-                    img_mask = np.zeros((self.crv.image_rgb.shape[0],
-                                         self.crv.image_rgb.shape[1]), np.uint8)
-                else:
-                    img_mask = self.crv.mask_crv.stats_dict.mask_image
-
-                self.glWidget.bind_texture(self.crv.image_rgb,
-                                           img_mask,
-                                           self.crv.image_edge,
-                                           image_flow,
-                                           image_depth)
+
+                self.glWidget.bind_texture(self.images)
                 self.set_corners()
                 self.redraw_self()
         self.in_read_images = False

tree_geometry/b_spline_curve.py

@@ -27,7 +27,7 @@ class BSplineCurve(object):
         cubic=3,
     )
     # uniform knot vector only
-    # General Matrix Representations for B-Splines, Kaihuai Qin
+    # General Matrix Representations for b-Splines, Kaihuai Qin
     # each matrix column represents a series of coeffs of increasing degree for a basis function
     basis_matrix_dict = {
     0: np.array([1]),
@@ -95,7 +95,7 @@ def from_existing(existing):
         :param existing: existing spline
         """
         return BSplineCurve(
-            ctrl_pts = deepcopy(existing.ctrl_pts),
+            ctrl_pts = existing.ctrl_pts,  # Deep copy in init function
             dim = existing.dim,
             degree = existing.degree,
             figax = (existing.fig, existing.ax))