batoolset 0.1.0__py3-none-any.whl

batoolset/ta/measurements/measurements3D/get_point_on_surface_if_centroid_is_bad.py

@@ -0,0 +1,175 @@
+# https://gis.stackexchange.com/questions/76498/how-is-st-pointonsurface-calculated # really great and what I'm looking for
+# https://geocompr.robinlovelace.net/geometric-operations.html#centroids
+
+# this sounds like a smart and nice method --> see how fast this is to implement that
+
+# can I do a fast version of it that relies on vertices to find this point
+# scan line by line the shape maybe using bounding box and take the center of the longest continuous line as the centroid --> maybe that is a really good idea
+
+# the following code is based on the idea described here https://gis.stackexchange.com/questions/76498/how-is-st-pointonsurface-calculated
+from math import ceil
+
+import numpy as np
+from skimage.measure._regionprops import RegionProperties
+
+from batoolset.img import Img
+import matplotlib.pyplot as plt
+from skimage.measure import regionprops
+from skimage import measure
+from skimage.draw import disk
+from timeit import default_timer as timer
+
+
+# that seems to work but do some cleaning and the only issue is that if cell is too close to border, such as a fake cell surrounding the image then it will be the first line --> and it would be easy
+
+# TODO also always use that for tracking as this should be much better than things I was using before and should prevent issues
+__DEBUG__ = False
+
+def point_on_surface2(region, labels, prefer_centroid_if_inside_the_cell=True):
+    # new version of  point_on_surface just coded to be more flexible, code is not the same and behaviour may differ --> compare thoroughly some day
+    if isinstance(region, RegionProperties):
+        region =region.coords
+    cell_id = labels[region[0][0], region[0][1]]
+    centroid = np.rint(np.average(region, axis=0)).astype(int)
+    if prefer_centroid_if_inside_the_cell and labels[centroid[0], centroid[1]] == cell_id:
+        return centroid
+    else:
+        # TODO FIX THAT SOME DAY lazy way of doing just return the first pixel of the shape maybe some centroid like would be better but ok for wings and for what I wanna do --> MAYBE TAKE CODE IN ORIGINAL FUNCTION AND HACK IT TO WORK WITH NDARRAYS
+        return region[0]
+
+
+
+# TODO clean code
+# this point will by definition always be inside the cell even in concave shapes
+
+# the other possibility is the ultimate erosion but this will be extremely slow and resource consuming; I guess
+# inspired by https://gis.stackexchange.com/questions/76498/how-is-st-pointonsurface-calculated but then I deviated from it
+def point_on_surface(region, labels, prefer_centroid_if_inside_the_cell=True):
+    # TODO --> maybe ceil the centroid to get a better centroid point (pb can be outside of the image although it is very unlikely (in fact it is not possible --> can ceil)
+
+    cell_id = labels[region.coords[0][0], region.coords[0][1]]
+
+    if prefer_centroid_if_inside_the_cell:
+        centroid = region.centroid
+
+        # TODO replace by rounding maybe some day but ok for now
+
+        # if labels[int(ceil(centroid[0])), int(ceil(centroid[1]))]==cell_id:
+        #     return (int(ceil(centroid[0])), int(ceil(centroid[1])))
+        if labels[int(round(centroid[0])), int(round(centroid[1]))]==cell_id:
+                return (int(round(centroid[0])), int(round(centroid[1])))
+
+    if __DEBUG__:
+        print(cell_id)
+
+    max_line_length = 0
+    # line_length_counter = 0
+    point_on_surface = (region.coords[0][0], region.coords[0][1])
+
+    # how do I get the
+    # get the centroid of the region
+    # --> ended ok
+    cell_encountered = False
+    first_encounter_x = None
+    line_length_counter = 0
+    # there is a bug
+
+    for iii in range(region.bbox[0], region.bbox[2]):
+        # start_coord_x = region.bbox[1]
+        # end_coord_x = region.bbox[3]
+    # if line_by_line:
+        cell_encountered = False
+        first_encounter_x = None
+        line_length_counter=0 # if I don't do set it to 0 here, I'll get some sort of center of mass effect which is maybe desired or not but if I do that this is very different from the idea above maybe ask for mode 1 or 2
+        for jjj in range(region.bbox[1], region.bbox[3]):
+
+            if labels[iii, jjj] == cell_id:
+                # print(cell_encountered, iii, jjj, line_length_counter)
+                if not cell_encountered:
+                    if __DEBUG__:
+                        print('first encounter', iii, jjj)
+                    first_encounter_x = jjj
+                    cell_encountered = True
+                line_length_counter += 1
+                # print('1',line_length_counter, first_encounter_x, jjj) # --> inded
+            else:
+                if __DEBUG__:
+                    if line_length_counter>0:
+                        print('last encounter', iii, jjj, line_length_counter)
+                if line_length_counter >= max_line_length and first_encounter_x is not None:
+                    max_line_length = line_length_counter
+                    point_on_surface = (
+                        iii, int(first_encounter_x + (jjj - first_encounter_x) / 2))  # get the centroid of the line
+                    if __DEBUG__:
+                        print('2',region.bbox, max_line_length, point_on_surface, first_encounter_x, cell_encountered, iii, jjj)
+
+                first_encounter_x = None  # reset first encounter
+                cell_encountered = False  # reset first encounter
+                line_length_counter = 0
+                # else:
+                #     line_length_counter = 0
+                #     cell_encountered = False  # reset first encounter
+                #     first_encounter_x = None  # reset first encounter
+
+        # if line_by_line:
+        # need reset also at the end of every loop if it has not found something
+        # nb replacing this by >= changes a bit the stuff --> that does make sense especially for cells at the border!!!
+        if line_length_counter > max_line_length and first_encounter_x is not None: # en fait c'est mieux comme ça
+            max_line_length = line_length_counter
+            point_on_surface = (
+                iii, int(first_encounter_x + (jjj - first_encounter_x) / 2))  # get the centroid of the line
+            if __DEBUG__:
+                print('2', region.bbox, max_line_length, point_on_surface, first_encounter_x, cell_encountered, iii, jjj)
+
+
+    # if line_length_counter > max_line_length and first_encounter_x is not None: # en fait c'est mieux comme ça
+    #     max_line_length = line_length_counter
+    #     point_on_surface = (
+    #         iii, int(first_encounter_x + (jjj - first_encounter_x) / 2))  # get the centroid of the line
+    #
+    #     if __DEBUG__:
+    #         print('2', region.bbox, max_line_length, point_on_surface, first_encounter_x, cell_encountered, iii, jjj)
+    if __DEBUG__:
+        print(region.bbox)
+    return point_on_surface
+
+if __name__ == '__main__':
+
+    start = timer()
+
+    # get a good test image here just to test the stuff
+    cells = \
+    Img('/E/Sample_images/sample_images_PA/trash_test_mem/full_wing_multi/early_stages/FocStich_RGB005/handCorrection.png')[
+        ..., 0]
+    labels = measure.label(cells, connectivity=1, background=255)  # FOUR_CONNECTED
+    # plt.imshow(labels)
+    # plt.show()
+
+
+    # c'est bon ça a l'air de bien marche en fait
+    for region in regionprops(labels):
+        if region.area > 60000:
+            # get its centroid
+            pt_on_surface = point_on_surface(region, labels)
+            print(pt_on_surface)
+
+            # compare computed position to the calculated position
+            centroid = region.centroid
+            x, y = disk(centroid, 30, shape=labels.shape)
+            # prefer centroid if inside
+            labels[x, y] = 30000
+
+            # labels[pt_on_surface[0], pt_on_surface[1]] = 6000
+            # for xx, yy in zip(x, y):
+            x, y = disk(pt_on_surface, 30, shape=labels.shape)
+            labels[x, y] = 25000
+
+            # ax.add_patch(circ)
+
+    # --> 5 secs --> not that bad I guess because the image is huge...
+
+    duration = timer() - start
+    print(duration)
+
+    plt.imshow(labels)
+    plt.show()

batoolset/ta/measurements/measurements3D/height_map_to_projection.py

@@ -0,0 +1,82 @@
+# the idea is to read the height map image and create a max proj out of it --> TODO
+from batoolset.img import Img
+import numpy as np
+import matplotlib.pyplot as plt
+
+def surface_projection_from_height_map(original_image, height_map , integer_mode = False, channel=None):
+    # to make it simple first just cast it
+    height_map_int = height_map.astype(np.uint8)
+
+    if channel is not None:
+        if len(original_image.shape)>2:
+            original_image = original_image[..., channel]
+
+    surface_projection = np.zeros_like(height_map)
+
+
+    # [os.path.join(path, f) for f in images_to_analyze if
+    #                          os.path.isfile(os.path.join(path, f))[]
+    # surface_projection = original_image[height_map,:,:]
+
+
+
+
+    min = height_map_int.min()
+    max = height_map_int.max()
+
+
+    for val in range(min, max):
+        surface_projection[height_map_int==val] = original_image[val, height_map_int==val]
+
+
+
+
+
+    # plt.imshow(difference_to_int)
+    # plt.show()
+    #
+    # plt.imshow(one_minus_difference)
+    # plt.show()
+
+    # plt.imshow(surface_projection)
+    # plt.show()
+
+    # Img(surface_projection,dimensions='hw').save('/E/Sample_images/sample_images_denoise_manue/trashme_test_robot/predict/surface_proj_int.tif')
+
+    if integer_mode:
+        return surface_projection
+
+    weights_for_layer_1 = height_map - height_map_int
+    weights_for_layer_0 = 1 - weights_for_layer_1
+    # NB try indexed_probs = np.take_along_axis(probs, np.expand_dims(indices, axis=-1), axis=-1)[..., 0]
+
+    for val in range(min, max-1):
+        layer_0 = original_image[val, height_map_int==val] * weights_for_layer_0[height_map_int == val]
+        layer_1 = original_image[val+1, height_map_int == val] * weights_for_layer_1[height_map_int == val]
+        # do weighted average of the layers --> TODO
+        # surface_projection[height_map_int == val] = (layer_0+layer_1)/2
+        # for each pixel I need to do the difference to the layer
+
+
+        # surface_projection[height_map_int == val] = (layer_0+layer_1)
+        surface_projection[height_map_int == val] = layer_0+layer_1
+
+    # pas mal mais voir comment gerer le fait que ce soit du float ???
+
+    # for floats get the rest and compute an average --> that is most likely not easy TODO --> that should be fairly easy todo in fact
+
+
+    # plt.imshow(surface_projection)
+    # plt.show()
+
+
+    # Img(surface_projection,dimensions='hw').save('/E/Sample_images/sample_images_denoise_manue/trashme_test_robot/predict/surface_proj_float.tif')
+    return surface_projection
+
+
+if __name__ == '__main__':
+    height_map = Img('/E/Sample_images/sample_images_denoise_manue/trashme_test_robot/predict/Image7.tif')
+    original_image = Img('/E/Sample_images/sample_images_denoise_manue/trashme_test_robot/Image7.tif')
+    surface_proj = surface_projection_from_height_map(original_image, height_map)
+    plt.imshow(surface_proj)
+    plt.show()

batoolset/ta/measurements/measurements3D/measures3D.py

@@ -0,0 +1,208 @@
+import numpy as np
+from batoolset.tools.logger import TA_logger # logging
+from batoolset.ta.utils.rps_tools import pavlidis, compute_distance_between_consecutive_points
+
+logger = TA_logger()
+
+# this would actually work for 2D and 3D area --> heightmap is optional but it makes no sense to run this with 2D coords and no heightmaps
+# if a heightmap is provided the z coords of every point will be replaced by height map height
+# nb if several triangles are provided, it is assumed they are all traingulation of the same object, hence their area is summed and the sum is returned
+def compute_3D_surfacearea(triangles, heightmap=None, stop_on_2D=False, disable_2D_warning=False):
+    """
+
+    :param triangles: cell/object triangulation as input (as list or ndarray)
+    :param heightmap: a heightmap for the cell
+    :param stop_on_2D: break if 2D data is provided
+    :return: the surface area of the triangulated object
+    """
+    if not isinstance(triangles, np.ndarray):
+        triangles = np.asarray(triangles)
+
+    if triangles.shape[-1] == 2 and heightmap is None:
+        if not disable_2D_warning:
+            logger.error(
+            'Error, triangle coords are purely 2D and no heightmap is provided, hence it is not possible to compute 3D area. To continue, the software will assume all heights are the same (= 0)  (i.e. the image is really a pure 2D image)')  # assuming 2D maybe --> just stack
+
+        if stop_on_2D:
+            return
+
+        flat_height = np.zeros((*triangles.shape[0:-1], (1)))
+        triangles = np.append(triangles, flat_height, -1)
+
+    # MEGA TODO NB SHOULD I MAKE Z THE FIRST DIMENSION ACTUALLY ????, probably does not change anything
+    if heightmap is not None:
+        if triangles.shape[-1] == 3:
+            b = triangles[:, :, :-1]  # get rid of z before adding it again
+        else:
+            b=triangles
+        search_coords = (b[..., 0].ravel(), b[..., 1].ravel())  # 'np.where' like coords
+        heights = heightmap[search_coords]
+
+        # print('heights', heights) # en fait c'est bon car des triangles sont out -> modifie l'aire
+
+        heights = np.reshape(heights, (*b.shape[0:-1], (1)))
+        triangles = np.append(b, heights, -1)  # add the height column to the coords
+
+    # compute a, b and c bond lengths for 3D triangles
+    a = ((triangles[:, 0, 0] - triangles[:, 1, 0]) ** 2 + (
+            triangles[:, 0, 1] - triangles[:, 1, 1]) ** 2 +
+         (triangles[:, 0, 2] - triangles[:, 1, 2]) ** 2) ** 0.5
+    b = ((triangles[:, 1, 0] - triangles[:, 2, 0]) ** 2 + (
+            triangles[:, 1, 1] - triangles[:, 2, 1]) ** 2 +
+         (triangles[:, 1, 2] - triangles[:, 2, 2]) ** 2) ** 0.5
+    c = ((triangles[:, 2, 0] - triangles[:, 0, 0]) ** 2 + (
+            triangles[:, 2, 1] - triangles[:, 0, 1]) ** 2 +
+         (triangles[:, 2, 2] - triangles[:, 0, 2]) ** 2) ** 0.5
+
+
+
+    # compute the triangle area using Heron's formula
+    # https://en.wikipedia.org/wiki/Triangle
+    s = (a + b + c) / 2.0  # semi perimeter (half of the triangle's perimeter)
+    areas = (s * (s - a) * (s - b) * (s - c)) ** 0.5
+
+    return areas.sum()
+
+
+
+# def compute3D_curved_distance(point1, point2, heightmap=None, three_points_mode=False):
+#     if heightmap is None:
+#         # cannot compute 3D dist
+#         print('no valid height map --> cannot compute curved distance')
+#         return distance_between_points(point1, point2)
+#
+#     pt1_y = int(point1[0])
+#     pt1_x = int(point1[1])
+#     # pt1_z = point1[2]
+#     pt2_y = int(point2[0])
+#     pt2_x = int(point2[1])
+#     # pt2_z = point1[2]
+#     rr, cc = draw.line(pt1_y, pt1_x,
+#                        pt2_y, pt2_x)
+#     # for every point I need get the height of it and compute the real 3D distance --> not hard in fact I think
+#
+#     dist3D = 0
+#
+#     # print(rr, cc,'-->')
+#
+#     if three_points_mode:
+#         # dirty hack to speed up things but ok to find the stuff then really recompute the real distance --> should be ok
+#         rr = [rr[0], rr[int(len(rr) / 2.)], rr[len(rr) - 1]]
+#         cc = [cc[0], cc[int(len(cc) / 2.)], cc[len(cc) - 1]]
+#
+#     # print(rr,cc)
+#     # compute distance of current point with prev one --> TODO
+#     for iii in range(1, len(rr), 1):
+#         y1 = rr[iii - 1]
+#         x1 = cc[iii - 1]
+#         z1 = heightmap[y1, x1]
+#         y2 = rr[iii]
+#         x2 = cc[iii]
+#         z2 = heightmap[y2, x2]
+#         # print(y1, x1, 'height', z1)
+#         # print(y2, x2, 'height', z2)
+#
+#         # print(y1, x1, z1, y2, x2, z2)
+#         # print('--> ', distance3D(y1, x1, z1, y2, x2, z2))
+#         # NB POINTS NEED BE SORTED --> CHECK THAT THIS IS THE CASE --> EASY MAX DIST BETWEEN CONSECUTIVE 2D POINTS CAN ONLY BE SQRT 2
+#
+#         dist3D += distance3D(y1, x1, z1, y2, x2, z2)
+#     # print(dist3D)
+#     return dist3D
+
+# TODO --> do that --> need sorted stuff
+# if points are not sorted then need pavlidis sort them
+# do pretty much the same as in the other
+def perimeter_3D(points, heightmap,points_are_sorted=False,is_closed_contour=False):
+    if not points_are_sorted:
+        sorted_points =pavlidis(points, closed_contour=is_closed_contour)
+    else:
+        sorted_points = points
+
+    if not isinstance(sorted_points, np.ndarray):
+        sorted_points = np.asarray(sorted_points)
+
+    # NOW NEED GET HEIGHT FOR ALL POINTS --> SHOULD BE DOABLE
+
+    search_coords = (sorted_points[..., 0].ravel(), sorted_points[..., 1].ravel())  # 'np.where' like coords
+    # print('search_coords',search_coords)
+    heights = heightmap[search_coords]
+
+
+    # print(sorted_points.shape)
+    # print(heights.shape)
+    # print(heights)
+    heights=heights[..., np.newaxis]
+    # sorted_points = np.append(sorted_points, heights, -1) # add the heights dimension to the sorted points
+    sorted_points = np.append(heights,sorted_points, -1) # add the heights dimension to the sorted points
+    # sorted_points = np.hstack((heights, sorted_points))  # add the heights dimension to the sorted points
+
+    # print('sorted_points',sorted_points)
+    consecutive_distance = compute_distance_between_consecutive_points(sorted_points)
+
+    # print(consecutive_distance)
+
+
+
+    perimeter3D = np.sum(consecutive_distance)
+
+
+    # then compare to the pixel by pixel method of it and should be the same result in fact
+    # then for every point sum the distance from one point to the next...
+
+
+
+    # also find a way to order pixels and get the perimeter right
+    # si > sqrt 2 alors need a connection --> put this as a section and try connect to first or last of every list --> maybe not so hard to implement and in the end all the points should be connected but try on a real example !!!
+    # TODO
+    # do it both for 2D and 3D
+    # the ordering of the pixels is key --> really need do that
+    # then I'll have a fairly good clone of TA that would be great and fully open source!!!
+    # raise NotImplementedError
+
+
+    return perimeter3D
+
+
+if __name__ == '__main__':
+
+        if False:
+            perimeter_3D()
+            import sys
+            sys.exit(0)
+
+        # it all seems to work but now just compute the area in a smarter way
+
+        # triangles3D= [[[2.37749672, -0.99445809,0], [1.20416474, -0.9998551,1], [2.87830002, -0.99819343,2]],[[2.37749672, -0.99445809,0], [1.20416474, -0.9998551,0], [2.87830002, -0.99819343,0]]]
+        # the second triangle is a line --> so area is 0, but 1 is the same but 3D --> in that sense it has an area
+        triangles3D = [[[2, 1, 0], [1, 1, 1], [3, 1, 2]], [[2, 1, 0], [1, 1, 0], [3, 1, 0]],
+                       [[2, 1, 0], [1, 1, 0], [3, 2, 0]], [[2, 1, 0], [1, 1, 0], [2, 2, 0]],
+                       [[0, 0, 0], [3, 0, 0], [3, 3, 0]]]  # why 0 for the second triangle --> do I have a bug ???
+
+        triangles2D = [[[2, 1], [1, 1], [3, 1]], [[2, 1], [1, 1], [3, 1]],
+                       [[2, 1], [1, 1], [3, 2]], [[2, 1], [1, 1], [2, 2]],
+                       [[0, 0], [3, 0], [3, 3]]]  # why 0 for the second triangle -
+
+        heightmap_flat = np.asarray([[0, 0, 0, 0, 0],
+                                     [0, 0, 0, 0, 0],
+                                     [0, 0, 0, 0, 0],
+                                     [0, 0, 0, 0, 0]])
+
+        # print(heightmap_flat)
+
+        heightmap_graded = np.asarray([[1, 2, 3, 4, 5],
+                                       [6, 7, 8, 9, 10],
+                                       [11, 12, 14, 15, 16],
+                                       [17, 18, 19, 20, 21]])
+
+        # print(heightmap_graded)
+
+        # triangles2D= [[[2.37749672, -0.99445809], [1.20416474, -0.9998551], [2.87830002, -0.99819343]],[[2.37749672, -0.99445809], [1.20416474, -0.9998551], [2.87830002, -0.99819343]]]
+        # if heightmap is provided --> get the coords from heightmap otherwise assume what is passed is already 3D
+        # check and compare 2D and 3D
+        # check also no dupes in the triangles!!!
+        print(compute_3D_surfacearea(triangles3D, heightmap=None))  # heightmap_graded # None # heightmap_flat)z
+        print(compute_3D_surfacearea(triangles2D, heightmap=None))
+        print(compute_3D_surfacearea(triangles2D, heightmap=None,stop_on_2D=True))
+
+        # if height map is provided then take it