frontveg 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

frontveg/__init__.py

@@ -3,15 +3,7 @@ try:
 except ImportError:
     __version__ = "unknown"
 from ._widget import (
-    ExampleQWidget,
-    ImageThreshold,
-    threshold_autogenerate_widget,
-    threshold_magic_widget,
+    vegetation,
 )
 
-__all__ = (
-    "ExampleQWidget",
-    "ImageThreshold",
-    "threshold_autogenerate_widget",
-    "threshold_magic_widget",
-)
+__all__ = ("vegetation",)

frontveg/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

frontveg/_widget.py

@@ -31,99 +31,116 @@ Replace code below according to your needs.
 
 from typing import TYPE_CHECKING
 
+import numpy as np
+import torch
 from magicgui import magic_factory
-from magicgui.widgets import CheckBox, Container, create_widget
-from qtpy.QtWidgets import QHBoxLayout, QPushButton, QWidget
-from skimage.util import img_as_float
+from PIL import Image
+from scipy import ndimage
+from transformers import pipeline
 
 if TYPE_CHECKING:
     import napari
+from frontveg.utils import frontground_part, ground_dino, sam2
 
-
-# Uses the `autogenerate: true` flag in the plugin manifest
-# to indicate it should be wrapped as a magicgui to autogenerate
-# a widget.
-def threshold_autogenerate_widget(
-    img: "napari.types.ImageData",
-    threshold: "float",
-) -> "napari.types.LabelsData":
-    return img_as_float(img) > threshold
+pipe = pipeline(
+    task="depth-estimation", model="depth-anything/Depth-Anything-V2-Large-hf"
+)
 
 
-# the magic_factory decorator lets us customize aspects of our widget
-# we specify a widget type for the threshold parameter
-# and use auto_call=True so the function is called whenever
-# the value of a parameter changes
-@magic_factory(
-    threshold={"widget_type": "FloatSlider", "max": 1}, auto_call=True
-)
-def threshold_magic_widget(
-    img_layer: "napari.layers.Image", threshold: "float"
+@magic_factory(call_button="Run")
+def vegetation(
+    input_data: "napari.types.ImageData",
 ) -> "napari.types.LabelsData":
-    return img_as_float(img_layer.data) > threshold
-
-
-# if we want even more control over our widget, we can use
-# magicgui `Container`
-class ImageThreshold(Container):
-    def __init__(self, viewer: "napari.viewer.Viewer"):
-        super().__init__()
-        self._viewer = viewer
-        # use create_widget to generate widgets from type annotations
-        self._image_layer_combo = create_widget(
-            label="Image", annotation="napari.layers.Image"
+    device = "cuda"
+
+    if input_data.ndim == 4:
+        output_data = np.zeros(
+            (input_data.shape[0], input_data.shape[1], input_data.shape[2]),
+            dtype="uint8",
         )
-        self._threshold_slider = create_widget(
-            label="Threshold", annotation=float, widget_type="FloatSlider"
+        INPUT = []
+        for i in range(len(input_data)):
+            rgb_data = input_data[i, :, :, :].compute()
+            image = Image.fromarray(rgb_data)
+            INPUT.append(image)
+    else:
+        output_data = np.zeros(
+            (1, input_data.shape[0], input_data.shape[1]), dtype="uint8"
         )
-        self._threshold_slider.min = 0
-        self._threshold_slider.max = 1
-        # use magicgui widgets directly
-        self._invert_checkbox = CheckBox(text="Keep pixels below threshold")
-
-        # connect your own callbacks
-        self._threshold_slider.changed.connect(self._threshold_im)
-        self._invert_checkbox.changed.connect(self._threshold_im)
-
-        # append into/extend the container with your widgets
-        self.extend(
-            [
-                self._image_layer_combo,
-                self._threshold_slider,
-                self._invert_checkbox,
-            ]
+        rgb_data = input_data
+        image = Image.fromarray(rgb_data)
+        INPUT = [image]
+    depth = pipe(INPUT)
+    n = len(depth)
+
+    model, processor = ground_dino()
+    predictor, text_labels = sam2()
+
+    for i in range(n):
+        depth_pred = depth[i]["depth"]
+        msks_depth = np.array(depth_pred)
+        msks_front = frontground_part(msks_depth)
+        msks_front = msks_front.astype(np.uint8) * 255
+
+        image = INPUT[i]
+        inputs = processor(
+            images=image, text=text_labels, return_tensors="pt"
+        ).to(device)
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        results = processor.post_process_grounded_object_detection(
+            outputs,
+            inputs.input_ids,
+            box_threshold=0.4,
+            text_threshold=0.3,
+            target_sizes=[image.size[::-1]],
         )
 
-    def _threshold_im(self):
-        image_layer = self._image_layer_combo.value
-        if image_layer is None:
-            return
-
-        image = img_as_float(image_layer.data)
-        name = image_layer.name + "_thresholded"
-        threshold = self._threshold_slider.value
-        if self._invert_checkbox.value:
-            thresholded = image < threshold
+        # Retrieve the first image result
+        result = results[0]
+        for box, score, labels in zip(
+            result["boxes"], result["scores"], result["labels"], strict=False
+        ):
+            box = [round(x, 2) for x in box.tolist()]
+            print(
+                f"Detected {labels} with confidence {round(score.item(), 3)} at location {box}"
+            )
+        if len(result["boxes"]) == 0:
+            masks = np.zeros(image.size[::-1], dtype="uint8")
         else:
-            thresholded = image > threshold
-        if name in self._viewer.layers:
-            self._viewer.layers[name].data = thresholded
+            with (
+                torch.inference_mode(),
+                torch.autocast("cuda", dtype=torch.bfloat16),
+            ):
+                predictor.set_image(image)
+                masks_sam, _, _ = predictor.predict(
+                    box=result["boxes"],
+                    point_labels=result["labels"],
+                    multimask_output=False,
+                )
+            if masks_sam.ndim == 4:
+                masks = np.sum(masks_sam, axis=0)
+                masks = masks[0, :, :]
+            else:
+                masks = masks_sam[0, :, :]
+
+        msks_veg = masks.astype(np.uint8) * 255
+
+        mask1 = msks_front.copy()  # Masque 1
+        mask2 = msks_veg.copy()  # Masque 2
+        mask2 = ndimage.binary_fill_holes(mask2)  # Fill holes
+        mask1 = (mask1 > 0).astype(np.uint8)  # Convertir en binaire
+        mask2 = (mask2 > 0).astype(np.uint8)  # Convertir en binaire
+        if len(np.unique(mask2)) == 2:
+            intersection = (
+                mask1 & mask2
+            )  # Intersection : les pixels qui sont 1 dans les deux masques
+            intersection = intersection > 0
         else:
-            self._viewer.add_labels(thresholded, name=name)
-
-
-class ExampleQWidget(QWidget):
-    # your QWidget.__init__ can optionally request the napari viewer instance
-    # use a type annotation of 'napari.viewer.Viewer' for any parameter
-    def __init__(self, viewer: "napari.viewer.Viewer"):
-        super().__init__()
-        self.viewer = viewer
-
-        btn = QPushButton("Click me!")
-        btn.clicked.connect(self._on_click)
-
-        self.setLayout(QHBoxLayout())
-        self.layout().addWidget(btn)
-
-    def _on_click(self):
-        print("napari has", len(self.viewer.layers), "layers")
+            intersection = mask1.copy()
+        intersection = (intersection * 255).astype(
+            np.uint8
+        )  # Si tu veux un masque avec des 0 et 255 (ex. pour OpenCV)
+        output_data[i, :, :] = intersection
+    return output_data

frontveg/napari.yaml

@@ -6,25 +6,9 @@ visibility: public
 categories: ["Annotation", "Segmentation", "Acquisition"]
 contributions:
   commands:
-    - id: frontveg.make_container_widget
-      python_name: frontveg:ImageThreshold
-      title: Make threshold Container widget
-    - id: frontveg.make_magic_widget
-      python_name: frontveg:threshold_magic_widget
-      title: Make threshold magic widget
-    - id: frontveg.make_function_widget
-      python_name: frontveg:threshold_autogenerate_widget
-      title: Make threshold function widget
-    - id: frontveg.make_qwidget
-      python_name: frontveg:ExampleQWidget
-      title: Make example QWidget
+    - id: frontveg.vegetation
+      python_name: frontveg:vegetation
+      title: Vegetation plugin
   widgets:
-    - command: frontveg.make_container_widget
-      display_name: Container Threshold
-    - command: frontveg.make_magic_widget
-      display_name: Magic Threshold
-    - command: frontveg.make_function_widget
-      autogenerate: true
-      display_name: Autogenerate Threshold
-    - command: frontveg.make_qwidget
-      display_name: Example QWidget
+    - command: frontveg.vegetation
+      display_name: Frontground vegetation

frontveg/utils.py

@@ -0,0 +1,109 @@
+import os
+from collections import Counter
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.signal import find_peaks
+from tqdm import tqdm
+from transformers import AutoModelForZeroShotObjectDetection, AutoProcessor
+
+# CONF = config.get_conf_dict()
+homedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# base_dir = CONF['general']['base_directory']
+base_dir = "."
+
+model_id = "IDEA-Research/grounding-dino-tiny"
+device = "cuda"
+
+processor = AutoProcessor.from_pretrained(model_id)
+model = AutoModelForZeroShotObjectDetection.from_pretrained(model_id).to(
+    device
+)
+
+
+def ground_dino():
+    return model, processor
+
+
+from sam2.sam2_image_predictor import SAM2ImagePredictor
+
+predictor = SAM2ImagePredictor.from_pretrained("facebook/sam2-hiera-large")
+text_labels = ["green region. foliage."]
+
+
+def sam2():
+    return predictor, text_labels
+
+
+def minimum_betw_max(dico_, visua=False):
+    Ax = list(dico_.keys())
+    Ay = list(dico_.values())
+
+    # Approximation par une régression polynomiale
+    x = Ax[1:]
+    y = Ay[1:]
+    degree = 14  # Choisissez le degré selon la complexité de la courbe
+    coefficients = np.polyfit(x, y, degree)
+    polynomial = np.poly1d(coefficients)
+
+    # Points lissés pour tracer la courbe
+    x_fit = np.linspace(min(x), max(x), 500)
+    y_fit = polynomial(x_fit)
+
+    # Détection des maxima
+    peaks, _ = find_peaks(y_fit)
+
+    peak_values = y_fit[peaks]
+    sorted_indices = np.argsort(peak_values)[
+        ::-1
+    ]  # Trier en ordre décroissant
+    top_two_peaks = peaks[
+        sorted_indices[:2]
+    ]  # Les indices des deux plus grands pics
+
+    # Trouver le minimum entre les deux maxima
+    x_min_range = x_fit[top_two_peaks[0] : top_two_peaks[1] + 1]
+    y_min_range = y_fit[top_two_peaks[0] : top_two_peaks[1] + 1]
+    minx = min([top_two_peaks[0], top_two_peaks[1]])
+    maxx = max([top_two_peaks[0], top_two_peaks[1]])
+    x_min_range = x_fit[minx : maxx + 1]
+    y_min_range = y_fit[minx : maxx + 1]
+    min_index = np.argmin(y_min_range)  # Index du minimum dans cette plage
+    x_min = x_min_range[min_index]
+    y_min = y_min_range[min_index]
+
+    if visua:
+        # Tracé
+        plt.scatter(x, y, color="blue")
+        plt.plot(x_fit, y_fit, color="red", label="Polynomial regression")
+        plt.scatter(
+            x_fit[top_two_peaks],
+            y_fit[top_two_peaks],
+            color="green",
+            label="Local maximum",
+        )
+        plt.scatter(x_min, y_min, color="orange", s=100, label="Local minimum")
+        plt.legend()
+        plt.xlabel("Depth pixel")
+        plt.ylabel("Count")
+        # plt.title('Approximation et détection des points maximum')
+        plt.show()
+    return x_min, y_min
+
+
+def frontground_part(depths):
+    depth_one = depths[:, :]
+    n, m = depth_one.shape
+    A = []
+    for i in tqdm(range(n)):
+        for j in range(m):
+            A.append([i, j, depth_one[i, j]])
+    X = np.array(A)
+
+    dico_ = Counter(X[:, 2])
+    min_coord = minimum_betw_max(dico_, visua=False)
+
+    th_ = min_coord[0]
+    msks_depth = depth_one > th_
+    return msks_depth

{frontveg-0.2.1.dist-info → frontveg-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontveg
-Version: 0.2.1
+Version: 0.3.0
 Summary: Segmentation of vegetation located to close to camera
 Author: Herearii Metuarea
 Author-email: herearii.metuarea@univ-angers.fr
@@ -50,13 +50,19 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.10
+Requires-Python: ==3.11.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: magicgui
 Requires-Dist: qtpy
 Requires-Dist: scikit-image
+Requires-Dist: transformers==4.51.3
+Requires-Dist: torch>=2.3.1
+Requires-Dist: torchvision>=0.18.1
+Requires-Dist: hydra-core==1.3.2
+Requires-Dist: iopath>=0.1.10
+Requires-Dist: pillow>=9.4.0
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
 Requires-Dist: pytest; extra == "testing"

frontveg-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+frontveg/__init__.py,sha256=m4oqJTxKFurizNLN-4HNrqF-hvjQkdyLMbIULtTd1NA,179
+frontveg/_version.py,sha256=9WppBElv1NvAyEcEfKgQ7lPPwwYXq7rnN9aaDi0TN-s,532
+frontveg/_widget.py,sha256=eZS0gv2f8NjMzskHFF0J_zscBWPVstqIQaSXIFhJOG4,5389
+frontveg/napari.yaml,sha256=33HxiAA2If2tjogtnkb5PYfeR8bXLxW4uWKV88kDYKQ,511
+frontveg/utils.py,sha256=3t011wr99KhJ4nW-lRYXoFLjZu_DULQOPcoXAlEKEK0,3214
+frontveg/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+frontveg/_tests/test_widget.py,sha256=jaFBX-JpnaRHDvQvU6QbUhOiL6Aejn2yljq11yl3hmY,2265
+frontveg-0.3.0.dist-info/licenses/LICENSE,sha256=2qUWKx6xVq9efOuuI6lxeftgMSY2njkm5Qy4HXLRQgA,1520
+frontveg-0.3.0.dist-info/METADATA,sha256=5DKXT3bY049syECZGRRsQQn7DiefgHXIRjJ4wsqIJMY,7967
+frontveg-0.3.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+frontveg-0.3.0.dist-info/entry_points.txt,sha256=VMaRha_yYtIcJAdA0suCmR0of0MZJfUaUn2aKSYtR0I,50
+frontveg-0.3.0.dist-info/top_level.txt,sha256=skkajXDCaVFNYqsXXqsUv6fqlA6Pl-2cLwKJO52ldBI,9
+frontveg-0.3.0.dist-info/RECORD,,

{frontveg-0.2.1.dist-info → frontveg-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

frontveg-0.2.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-frontveg/__init__.py,sha256=BVJaebsOBu1m--T0j2UjXzD_pG4zBvZ1PHfH3nga9js,373
-frontveg/_version.py,sha256=cTPlZaUCc20I4ZWsDjY35UftpFNRgfDaDBgkWxfIQmg,532
-frontveg/_widget.py,sha256=gyCQpmWr20TvgwkurBZTG5EeBoGEk2GxOEAiS3Zqmpg,4940
-frontveg/napari.yaml,sha256=YTDShC2Rt39ypSM-opRP4lNDOncghjanBNydozPcHvE,1208
-frontveg/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-frontveg/_tests/test_widget.py,sha256=jaFBX-JpnaRHDvQvU6QbUhOiL6Aejn2yljq11yl3hmY,2265
-frontveg-0.2.1.dist-info/licenses/LICENSE,sha256=2qUWKx6xVq9efOuuI6lxeftgMSY2njkm5Qy4HXLRQgA,1520
-frontveg-0.2.1.dist-info/METADATA,sha256=O_Yf9RJNGxSvG_-w4WKW87x48qy0mKqT6BYPVT6eMZ0,7767
-frontveg-0.2.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-frontveg-0.2.1.dist-info/entry_points.txt,sha256=VMaRha_yYtIcJAdA0suCmR0of0MZJfUaUn2aKSYtR0I,50
-frontveg-0.2.1.dist-info/top_level.txt,sha256=skkajXDCaVFNYqsXXqsUv6fqlA6Pl-2cLwKJO52ldBI,9
-frontveg-0.2.1.dist-info/RECORD,,