first commit of app

README.md

@@ -1,12 +1,12 @@
 ---
 title: Measure Fiber Diameter
-emoji: 📈
-colorFrom: red
-colorTo: gray
+emoji: 📏
+colorFrom: yellow
+colorTo: blue
 sdk: gradio
 sdk_version: 3.0.26
 app_file: app.py
-pinned: false
+pinned: true
 license: apache-2.0
 ---
 

app.py

@@ -0,0 +1,96 @@
+import gradio as gr
+import tensorflow as tf
+import cv2
+import numpy as np
+from itertools import islice
+from PIL import Image, ImageDraw, ImageColor
+from line_fit import LineFit
+import random
+
+MAX_SELECTIONS = 8
+input_shape = (MAX_SELECTIONS,256,256,2)
+def load_model():
+    model = tf.keras.models.load_model('vivid-sweep-model-best.hdf5')
+    return model
+
+model = load_model()
+colors = list(ImageColor.colormap.keys())
+linefit = LineFit(30, 0.3)
+
+def get_blob_centroids(mask):
+    centers = []
+    print(mask.dtype)
+    print(mask.shape)
+    contours, hierarchies = cv2.findContours(
+        mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    for i in contours:
+        M = cv2.moments(i)
+        if M['m00'] != 0:
+            cx = int(M['m10']/M['m00'])
+            cy = int(M['m01']/M['m00'])
+            centers.append([cx,cy])
+            print(cx,cy)
+    return centers
+    
+def predict_mask(input_img, threshold):
+    # unpack and reshape input
+    im, mask = input_img["image"], input_img["mask"]
+    mask = mask[:,:,0].astype(np.uint8)
+    im = im.astype(np.float32)/256
+
+    # get centroids to measure the fibers
+    centers = get_blob_centroids(mask)
+
+    # create a batch of input for the model
+    batch = np.zeros([MAX_SELECTIONS,256,256,2], dtype=np.float32)
+
+    for i, (cx, cy) in enumerate(islice(centers, MAX_SELECTIONS)):
+        batch[i,:,:,0] = im
+        batch[i,cy,cx,1] = 1.0
+    
+    pred = model.predict(batch, verbose=0).squeeze()
+    # create a single image with the background and the foreground
+    im = Image.fromarray(im*255).convert("RGBA")
+    # m = Image.fromarray(pred[0]>threshold).convert("RGBA")
+    # im = Image.blend(im, m, 0.5)
+    imgd = ImageDraw.Draw(im)
+    ds = []
+    for p in islice(pred, len(centers)):
+        d, lines = linefit.predict((p>threshold).astype(np.uint8)*255)
+        ds.append(d)
+        m = Image.fromarray(p>threshold)
+        imgd.bitmap([0,0], m, fill=random.choice(colors))
+        for line in lines:
+            imgd.line(line, fill ="blue", width = 1)
+        
+    return im, ds
+
+demo = gr.Blocks()
+
+with demo:
+    with gr.Row():
+        with gr.Column():
+            img = gr.Image(
+                tool="sketch", 
+                source="upload",
+                label="Mask",
+                image_mode='L',
+                shape=[256,256],
+                value='test0000.png'
+            )
+            threshold = gr.Slider(
+                label='Segmentation threshold', minimum=0, maximum=1, value=0.5)
+
+            with gr.Row():
+                btn = gr.Button("Run")
+        with gr.Column():
+            img2 = gr.Image()
+            text = gr.Text()
+
+    btn.click(fn=predict_mask, inputs=[img, threshold], outputs=[img2,text], )
+    examples = gr.Examples(examples=['test0001.png',
+                                     'test0002.png',
+                                     'test0003.png'],
+                           inputs=img)
+
+demo.launch()

line_fit.py

@@ -0,0 +1,168 @@
+
+import numpy as np
+from scipy.optimize import curve_fit
+from typing import Tuple, List
+import cv2
+
+point = Tuple[float,float]
+line = Tuple[point, point]
+measurements = List[line]
+
+class LineFit:
+    def __init__(self, n: int, step_size:float) -> None:
+        """Model that fits a line in a binary image and measures diameter of fibers
+
+        :param n: number of measurements to do along the fitted line.
+        :param step_size: step size of diameter measurement (in pixels). Can be fraction.
+        """
+        self.n = n
+        self.step_size = step_size
+
+    def get_coordinates(self, im, value_for_mask):
+        #I = rgb2gray(I_orig) #we can delete this if we get binary images
+        mask = im > value_for_mask
+        fiber_coor = np.argwhere(mask)
+        x = fiber_coor[:, 1]
+        y = fiber_coor[:, 0]
+        return x, y
+
+    def func_line(self, x, a, b):
+        return a * x + b
+
+    def func_line_inv(self, y, a, b):
+        return (y - b)/a
+
+    def get_fited_line_x_y(self, im):
+        value_for_mask = (int(np.max(im))+int(np.min(im)))/2 # Pixels to mask in get_coordinate
+        x, y = self.get_coordinates(im, value_for_mask)
+        popt, pcov = curve_fit(self.func_line, x, y)
+        return x, y, popt, pcov
+
+    def get_fited_line_y_x(self, im):
+        value_for_mask = (int(np.max(im))+int(np.min(im)))/2 # Pixels to mask in get_coordinate
+        x, y = self.get_coordinates(im, value_for_mask)
+        popt, pcov = curve_fit(self.func_line, y, x)
+        return x, y, popt, pcov
+
+    def get_better_fit(self, x, y, popt, popt_inv, pcov, pcov_inv):
+        diagonal = np.diagonal(pcov)
+        diagonal_inv = np.diagonal(pcov_inv)
+        if np.less(diagonal, diagonal_inv).all() == True:
+            popt_fit = popt
+            x_line = np.arange(0, max(x), 1)
+            y_line = []
+            for i in x_line:
+                a = self.func_line(x_line[i], *popt)
+                y_line.append(a)
+            y_fit = y_line
+            x_fit = x_line
+            p1 = [x_fit[0],y_fit[0]]
+            p2 = [x_fit[-1],y_fit[-1]]
+        elif np.less(diagonal, diagonal_inv).all() == False:
+            popt_fit = [1/popt_inv[0], (-popt_inv[1])/popt_inv[0]]
+            y_line = np.arange(0, max(y), 1)
+            x_line = []
+            for i in y_line:
+                a = self.func_line(y_line[i], *popt_inv)
+                x_line.append(a)
+            y_fit = y_line
+            x_fit = x_line
+            p1 = [x_fit[0],y_fit[0]]
+            p2 = [x_fit[-1],y_fit[-1]]
+        else:
+            print("One of the pcov values is True and the rest are False")
+        return popt_fit, x_fit, y_fit, p1, p2
+
+    def get_point(self, t, p1, p2):
+        dx = p2[0]-p1[0]
+        dy = p2[1]-p1[1]
+        p = [(dx * t + p1[0]), (dy * t + p1[1])]
+        return p, dx, dy
+
+    def get_normal_vector(self, t, dx, dy, p3):
+        n_pos = [-dy, dx]
+        mag_pos = np.linalg.norm(n_pos)
+        nu_pos = n_pos/mag_pos
+        u_pos = [(nu_pos[0] * t + p3[0]), (nu_pos[1] * t + p3[1])]
+        return u_pos
+
+    def is_inside(self, im, pos):
+        if not (0 <= pos[0] < im.shape[0]):
+            return False
+        if not (0 <= pos[1] < im.shape[1]):
+            return False
+        return True
+
+    def get_pixels_half (self, pos_or_neg, im, dx, dy, p3):
+        color_threshold = (int(np.max(im))+int(np.min(im)))/2
+        for ts in (range(len(im[0]))):
+            u = self.get_normal_vector((pos_or_neg*(ts+(self.step_size))), dx, dy, p3) 
+            test_point = round(u[1]),round(u[0])
+            if not self.is_inside(im, test_point):
+                return None, None
+            test = im[test_point[0], test_point[1]] > color_threshold
+            if test == False:
+                pixels = ts - 1
+                break
+        # plt.plot(u[0], u[1], 'c.', markersize=12)
+        return pixels, (u[0], u[1])
+
+
+    def get_calculated_diameter(self, im, p1, p2):
+        color_threshold = (int(np.max(im))+int(np.min(im)))/2
+        diameters = []
+        lines = []
+        #mask_meas_lines = np.zeros_like(im)
+        for n in range(1, self.n+1): 
+            t = 1/(self.n+1) 
+            p3, dx, dy = self.get_point((t * n), p1, p2)
+            test_point = round(p3[1]),round(p3[0])
+            if not self.is_inside(im, test_point):
+                continue
+            true_point = im[test_point[0], test_point[1]] > color_threshold
+            if true_point == False:
+                continue
+            if true_point == True:
+                radius_p, cp1 = self.get_pixels_half(1, im, dx, dy, p3)
+                radius_n, cp2 = self.get_pixels_half(-1, im, dx, dy, p3)
+                if (radius_p != None) and (radius_n != None):
+                    max_val = max(radius_p, radius_n)
+                    min_val = min(radius_p, radius_n)
+                    equal = abs((max_val - min_val)/(max_val + 1e-5))
+                    if equal < 0.1:
+                        lines.append((cp1,cp2))
+                        diameters.append(radius_p+radius_n)
+                        # mask_meas_lines = self.mask_measured_lines(im, lines)
+                        # plt.plot(p3[0], p3[1], 'r.', markersize=12)
+        calculated_diameter = np.array(diameters).mean()
+        return calculated_diameter, lines
+
+    def line_to_arrays(self, line):
+        return [line[0][0], line[1][0]], [line[0][1], line[1][1]]
+
+    def mask_measured_lines(self, im, lines):
+        mask = np.zeros_like(im)
+        for p1, p2 in lines:
+            if not (p1 == None or p2 == None):
+                cv2.line(mask, np.array(p1).astype(np.int32), np.array(p2).astype(np.int32), 1, 1)
+        return mask
+
+    def predict(self, im: np.ndarray):
+        x, y, popt, pcov = self.get_fited_line_x_y(im)
+        _, _, popt_inv, pcov_inv = self.get_fited_line_y_x(im)
+        popt_fit, x_fit, y_fit, p1, p2 = self.get_better_fit(x, y, popt, popt_inv, pcov, pcov_inv)
+        calculated_diameter, lines = self.get_calculated_diameter(im, p1, p2)
+        mask_meas_lines = self.mask_measured_lines(im, lines)
+        #for line in lines:
+        #    plt.plot(*self.line_to_arrays(line), 'c-')
+        return calculated_diameter, mask_meas_lines
+ 
+if __name__ == "__main__":
+    import os 
+
+    model = LineFit(10, 0.5)
+    dataset_path = "/Users/carmenlopez/dev/diameterY/scratch/dataset_files"
+    example_path = os.path.join(dataset_path, "test_0005.npz")
+    example = np.load(example_path)
+    diameter_pred, mask_meas_lines = model.predict(example["x"])
+    print(diameter_pred, example["d"])

packages.txt

@@ -0,0 +1 @@
+python3-opencv

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow
+opencv-python
+gradio
+scipy
+hugging_face_hub