rvimage 0.0.1__tar.gz

rvimage-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: rvimage
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python-headless>=4.11.0.86
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: scipy>=1.15.3

rvimage-0.0.1/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "rvimage"
+version = "0.0.1"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "opencv-python-headless>=4.11.0.86",
+    "pydantic>=2.11.7",
+    "scipy>=1.15.3",
+]

rvimage-0.0.1/rvimage/collection_types.py

@@ -0,0 +1,134 @@
+from typing import Self
+from pydantic import BaseModel
+import numpy as np
+from rvimage.converters import (
+    extract_polys_from_mask,
+    fill_bbs_on_mask,
+    fill_polys_on_mask,
+    mask_to_rle,
+    rle_to_mask,
+)
+from rvimage.domain import BbF, BbI, Poly, enclosing_bb, find_ccs
+
+
+class GeoFig(BaseModel):
+    bbox: BbF | None = None
+    poly: Poly | None = None
+
+
+class Labelinfo(BaseModel):
+    new_label: str
+    labels: list[str]
+    colors: list[list[int]]
+    cat_ids: list[int]
+    cat_idx_current: int
+    show_only_current: bool
+
+
+class BboxAnnos(BaseModel):
+    elts: list[GeoFig]
+    cat_idxs: list[int]
+    selected_mask: list[bool]
+
+    @classmethod
+    def from_mask(cls, mask: np.ndarray, cat_idx: int) -> "BboxAnnos":
+        """
+        Create BboxAnnos from a binary mask.
+        """
+        polys = extract_polys_from_mask(mask, abs_coords_output=True)
+        cat_idxs = [cat_idx] * len(polys)
+
+        return cls(
+            elts=[
+                GeoFig(poly=Poly(points=points, enclosing_bb=enclosing_bb(points)))
+                for points in polys
+            ],
+            cat_idxs=cat_idxs,
+            selected_mask=[False] * len(polys),
+        )
+
+    def extend(self, other: Self) -> "BboxAnnos":
+        """
+        Extend the current BboxAnnos with another BboxAnnos.
+        """
+        return BboxAnnos(
+            elts=self.elts + other.elts,
+            cat_idxs=self.cat_idxs + other.cat_idxs,
+            selected_mask=self.selected_mask + other.selected_mask,
+        )
+
+    def fill_mask(self, im_mask: np.ndarray, cat_idx: int):
+        fill_polys_on_mask(
+            polygons=(
+                elt.poly.points
+                for elt, cat_idx_ in zip(self.elts, self.cat_idxs)
+                if cat_idx == cat_idx_ and elt.poly is not None
+            ),
+            value=1,
+            im_mask=im_mask,
+            abs_coords_input=True,
+        )
+        fill_bbs_on_mask(
+            bbs=(
+                elt.bbox
+                for elt, cat_idx_ in zip(self.elts, self.cat_idxs)
+                if cat_idx == cat_idx_ and elt.bbox is not None
+            ),
+            value=1,
+            im_mask=im_mask,
+            abs_coords_input=True,
+        )
+
+
+class BboxData(BaseModel):
+    annos: BboxAnnos
+    labelinfo: Labelinfo
+
+
+class Canvas(BaseModel):
+    rle: list[int]
+    bb: BbI
+    intensity: float
+
+
+class BrushAnnos(BaseModel):
+    elts: list[Canvas]
+    cat_idxs: list[int]
+    selected_mask: list[bool]
+
+    @classmethod
+    def from_mask(cls, im_mask: np.ndarray, cat_idx: int) -> "BrushAnnos":
+        """
+        Create BrushAnnos from a binary mask.
+        """
+        ccs, _ = find_ccs(im_mask)
+        rles = [mask_to_rle(cc.im) for cc in ccs]
+
+        return BrushAnnos(
+            elts=[
+                Canvas(rle=rle, bb=cc.bb, intensity=1.0) for rle, cc in zip(rles, ccs)
+            ],
+            cat_idxs=[cat_idx] * len(ccs),
+            selected_mask=[False] * len(ccs),
+        )
+
+    def fill_mask(self, im_mask: np.ndarray, cat_idx: int):
+        for elt, cat_idx_ in zip(self.elts, self.cat_idxs):
+            if cat_idx == cat_idx_:
+                im_bb_mask = rle_to_mask(elt.rle, value=1, mask=elt.bb)
+                im_mask[elt.bb.slices] = im_bb_mask
+
+
+class BrushData(BaseModel):
+    annos: BrushAnnos
+    labelinfo: Labelinfo
+
+
+class InputAnnotationData(BaseModel):
+    bbox: BboxData
+    brush: BrushData
+
+
+class OutputAnnotationData(BaseModel):
+    bbox: BboxAnnos
+    brush: BrushAnnos

rvimage-0.0.1/rvimage/converters.py

@@ -0,0 +1,99 @@
+from collections.abc import Sequence, Iterable
+import numpy as np
+import cv2
+
+from rvimage.domain import BbF, BbI, Point
+
+
+def rle_to_mask(rle: list[int], value: float, mask: np.ndarray | BbI) -> np.ndarray:
+    if isinstance(mask, BbI):
+        mask = np.zeros((mask.h, mask.w), dtype=np.uint8)
+    else:
+        mask = mask
+    shape = mask.shape[:2]
+    flat_mask = mask.ravel()
+    pos = 0
+    for i, n_elts in enumerate(rle):
+        if i % 2 == 1:
+            flat_mask[pos : pos + n_elts] = value
+        pos = pos + n_elts
+    return flat_mask.reshape(shape)
+
+
+def mask_to_rle(mask: np.ndarray) -> list[int]:
+    mask_w, mask_h = mask.shape
+    flat_mask = mask.flatten()
+    rle = []
+    current_run = 0
+    current_value = 0
+    for y in range(mask_h):
+        for x in range(mask_w):
+            value = flat_mask[int(y * mask_w + x)]
+            if value == current_value:
+                current_run += 1
+            else:
+                rle.append(current_run)
+                current_run = 1
+                current_value = value
+    rle.append(current_run)
+    return rle
+
+
+def fill_bbs_on_mask(
+    bbs: Iterable[BbI | BbF],
+    value: int,
+    im_mask: np.ndarray,
+    abs_coords_input: bool = True,
+):
+    if abs_coords_input:
+        h, w = 1, 1
+    else:
+        h, w = im_mask.shape
+
+    im_mask = im_mask.copy()
+    for bb in bbs:
+        if isinstance(bb, BbF):
+            bb = bb.scale(w, h).to_bbi()
+        im_mask[bb.slices] = value
+
+
+def fill_polys_on_mask(
+    polygons: Iterable[Sequence[Point]],
+    value: int,
+    im_mask: np.ndarray,
+    abs_coords_input: bool = True,
+):
+    if abs_coords_input:
+        h, w = 1, 1
+    else:
+        h, w = im_mask.shape
+
+    im_mask = im_mask.copy()
+    for poly in polygons:
+        polygon_ = np.round(np.array([[[p.x * w, p.y * h] for p in poly]])).astype(
+            np.int32
+        )
+        im_mask = cv2.fillPoly(img=im_mask, pts=polygon_, color=value)  # type: ignore
+    return im_mask
+
+
+def extract_polys_from_mask(
+    im_mask: np.ndarray, abs_coords_output: bool
+) -> list[list[Point]]:
+    contours, _ = cv2.findContours(im_mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    polygons = []
+    h, w = im_mask.shape
+
+    for obj in contours:
+        polygon = []
+
+        for point in obj:
+            assert isinstance(point, np.ndarray)
+            if abs_coords_output:
+                x, y = point[0][0], point[0][1]
+            else:
+                x, y = point[0][0] / w, point[0][1] / h
+            polygon.append(Point(x=x, y=y))
+
+        polygons.append(polygon)
+    return polygons

rvimage-0.0.1/rvimage/domain.py

@@ -0,0 +1,120 @@
+import math
+import numpy as np
+from pydantic import BaseModel
+from scipy.ndimage import find_objects
+from scipy.ndimage import label as scpiy_label
+
+
+class BbI(BaseModel):
+    x: int
+    y: int
+    w: int
+    h: int
+
+    @classmethod
+    def from_slices(cls, slices: tuple[slice, slice]):
+        x = slices[1].start
+        y = slices[0].start
+        w = slices[1].stop - x
+        h = slices[0].stop - y
+        return cls(x=x, y=y, w=w, h=h)
+
+    @property
+    def slices(self) -> tuple[slice, slice]:
+        """
+        Returns the slices for indexing a numpy array.
+        """
+        return slice(self.y, self.y + self.h), slice(self.x, self.x + self.w)
+
+
+class BbF(BaseModel):
+    x: float
+    y: float
+    w: float
+    h: float
+
+    def to_bbi(self) -> "BbI":
+        """
+        Convert to integer bounding box.
+        """
+        return BbI(
+            x=int(np.round(self.x)),
+            y=int(np.round(self.y)),
+            w=int(np.round(self.w)),
+            h=int(np.round(self.h)),
+        )
+
+    def scale(self, scale_x: float, scale_y) -> "BbF":
+        """
+        Scale the bounding box by a factor.
+        """
+        return BbF(
+            x=self.x * scale_x,
+            y=self.y * scale_y,
+            w=self.w * scale_x,
+            h=self.h * scale_y,
+        )
+
+
+class Point(BaseModel):
+    x: float
+    y: float
+
+
+class Poly(BaseModel):
+    points: list[Point]
+    enclosing_bb: BbF
+
+
+class CC:
+    def __init__(
+        self,
+        slices: tuple[slice, slice],
+        label: int,
+        im: np.ndarray,
+        im_labeled: np.ndarray,
+    ):
+        self.im = im.copy()
+        self.im[im_labeled != label] = 0
+        self.slices = slices
+        self.bb = BbI.from_slices(slices)
+        self.label = label
+
+    def __str__(self):
+        return "CC with " + str(self.bb)
+
+
+def _find_cc_slices(im: np.ndarray):
+    im_labeled, n_ccs = scpiy_label(im)  # type: ignore
+    return find_objects(im_labeled), im_labeled, n_ccs
+
+
+def find_ccs(im: np.ndarray) -> tuple[list[CC], np.ndarray]:
+    """Find connected components in a binary image.
+    Args:
+        im: A binary image (2D numpy array) where connected components are to be found.
+    Returns:
+        A tuple containing:
+            - A list of CC objects representing the connected components.
+            - A labeled image where each connected component is assigned a unique label.
+    """
+    cc_slices, im_labeled, _ = _find_cc_slices(im)
+    ccs = [CC(slc, i + 1, im, im_labeled) for i, slc in enumerate(cc_slices)]
+    return ccs, im_labeled
+
+
+def enclosing_bb(points: list[Point]) -> BbF:
+    min_x = math.inf
+    min_y = math.inf
+    max_x = -math.inf
+    max_y = -math.inf
+    for point in points:
+        if point.x < min_x:
+            min_x = point.x
+        if point.y < min_y:
+            min_y = point.y
+        if point.x > max_x:
+            max_x = point.x
+        if point.y > max_y:
+            max_y = point.y
+    return BbF(x=min_x, y=min_y, w=max_x - min_x, h=max_y - min_y)

rvimage-0.0.1/rvimage.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: rvimage
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python-headless>=4.11.0.86
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: scipy>=1.15.3

rvimage-0.0.1/rvimage.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+rvimage/collection_types.py
+rvimage/converters.py
+rvimage/domain.py
+rvimage.egg-info/PKG-INFO
+rvimage.egg-info/SOURCES.txt
+rvimage.egg-info/dependency_links.txt
+rvimage.egg-info/requires.txt
+rvimage.egg-info/top_level.txt
+test/test.py

rvimage-0.0.1/rvimage.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rvimage-0.0.1/rvimage.egg-info/requires.txt

@@ -0,0 +1,3 @@
+opencv-python-headless>=4.11.0.86
+pydantic>=2.11.7
+scipy>=1.15.3

rvimage-0.0.1/rvimage.egg-info/top_level.txt

@@ -0,0 +1 @@
+rvimage

rvimage-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rvimage-0.0.1/test/test.py

@@ -0,0 +1,44 @@
+import numpy as np
+from rvimage.converters import extract_polys_from_mask, fill_polys_on_mask
+from rvimage.converters import rle_to_mask, mask_to_rle
+from rvimage.domain import Point
+
+
+def test_rle():
+    im_mask = np.zeros((10, 10), dtype=np.uint8)
+    im_mask[0:2, 0:5] = 1
+
+    rle = mask_to_rle(im_mask)
+    assert rle == [0, 5, 5, 5, 85]
+    im_mask_converted = rle_to_mask(rle, 1, im_mask)
+    assert np.array_equal(im_mask, im_mask_converted)
+
+
+def test_polygon():
+    im_mask = np.zeros((10, 10), dtype=np.uint8)
+    polygons = [
+        [
+            Point(x=0, y=0),
+            Point(x=5, y=0),
+            Point(x=5, y=5),
+            Point(x=2, y=7),
+            Point(x=0, y=5),
+        ]
+    ]
+    value = 1
+
+    mask = fill_polys_on_mask(polygons, value, im_mask, abs_coords_input=True)
+    print(mask)
+    assert np.sum(mask) > 0
+
+    polygons_converted = extract_polys_from_mask(mask, abs_coords_output=True)
+    assert len(polygons_converted) > 0
+    im_mask = np.zeros((10, 10), dtype=np.uint8)
+    mask_converted = fill_polys_on_mask(polygons, value, im_mask, abs_coords_input=True)
+
+    assert np.allclose(mask, mask_converted), "Masks are not equal after conversion"
+
+
+if __name__ == "__main__":
+    test_rle()
+    test_polygon()