ialdev-img 0.1.0__py3-none-any.whl

iad/img/__init__.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+from .regions import Regions
+
+Image = np.ndarray

iad/img/camera.py

@@ -0,0 +1,337 @@
+from dataclasses import dataclass, InitVar
+from datetime import datetime
+from enum import Enum
+from math import tan, pi
+from typing import Union, NamedTuple, TYPE_CHECKING
+from warnings import warn
+
+import numpy as np
+
+from iad.core.param import TBox
+from iad.maths.geom import Vec2d, Pose
+
+if TYPE_CHECKING:
+    from iad.core.units import Quantity
+
+
+class Resolution(Enum):
+    HQVGA = (240, 160)
+    QVGA = (320, 240)
+    VGA = (645, 480)
+    WGA = (800, 480)
+    SVGA = (800, 600)
+    DVGA = (960, 640)
+    WXGA = (1280, 800)
+    QFD = (960, 540)
+    HD = (1280, 720)
+    FHD = (1920, 1080)
+    QHD = (2560, 1440)
+    UHD4K = (3840, 2160)
+    UHD8K = (7680, 4320)
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __getitem__(self, item):
+        return (self.x, self.y)[item]
+
+    def __repr__(self):
+        return f'Resolution {self.name}: {self.x}x{self.y}'
+
+    @property
+    def total_pixels(self):
+        return self.x * self.y
+
+    @property
+    def xy(self):
+        return self.x, self.y
+
+
+@dataclass(repr=False)
+class Sensor:
+    pixels: Union[Vec2d, Resolution]
+    center: Vec2d = 0  # [pix], relative to the sensor center
+    colors: str = 'RGB'
+    bits: int = 10
+    pix_size: Vec2d = 1   # in microns
+
+    def __post_init__(self):
+        xy = self.pixels.xy if isinstance(self.pixels, Resolution) else self.pixels
+        self.pixels = Vec2d(xy)   # to support initialization with iterable
+        if self.center == 0:
+            self.center = Vec2d(0, 0)
+        if not hasattr(self.pix_size, '__len__'):
+            self.pix_size = Vec2d(1, 1)
+
+    @property
+    def size(self):
+        """ Return sensor size in mm"""
+        return Vec2d(*self.pixels / np.array(self.pix_size) / 1000)
+
+    def __repr__(self):
+        def dims(v): return f'{v.x}\u2A09{v.y}'
+
+        px_sz = (np.array(self.pix_size) * 10).round() / 10  # with 0.1um accuracy
+        px_sz = dims(Vec2d(*px_sz)) if np.diff(px_sz) else f'{px_sz[0]}'
+
+        return f'Sensor {self.bits}b[{self.colors}] {dims(self.pixels)} pix({px_sz}\u03BCm)'
+
+
+@dataclass(repr=False)
+class Shot:
+    time: datetime = None
+    pose: Pose = None
+    exposure: float = 0
+
+    def __repr__(self):
+        if self.pose is None and self.time is None and not self.exposure:
+            return ''
+        time = self.time.strftime('%y/%d %H:%M:%S.%f') if self.time else ''
+        exps = f'expos:{self.exposure * 1000:.1}ms' if self.exposure is None else ''
+        pose = self.pose if self.pose else ''
+        return f'[{time}] {exps} {pose}'
+
+
+@dataclass(repr=False)
+class Camera:
+    """
+    Camera information class.
+    Contains both geometrical and physical aspects of the camera
+    """
+    pixels: InitVar[Vec2d] = None
+    sensor: Sensor = None
+    focal: float = np.nan  # in mm, along z-axis from the center
+    name: str = ''
+
+    def __post_init__(self, pixels):
+        if self.sensor is None:
+            self.sensor = Sensor(pixels=pixels)
+
+        if np.isnan(self.focal):
+            self.focal = max(*self.sensor.size)  # 90 degrees
+
+    def angles(self, measure='rad'):
+        measure = measure.lower()
+        assert measure in ('rad', 'deg')
+        rad = np.arctan(self.sensor.size / self.focal / 2) * 2
+        return rad if measure == 'rad' else rad * 180 / np.pi
+
+    def __repr__(self):
+        def dims(v): return f'{v.x}\u2A09{v.y}'
+
+        angles = dims(Vec2d(*np.array(self.angles('deg'), dtype=int)))
+        name = f'<{self.name}>' if self.name else ''
+        return f'Camera{name}: {self.sensor}, angles: {angles}\u00B0'
+
+
+def bin_x(im, bin_factor):
+    """ Binning along x direction by given (integer) factor
+
+    :param im:
+    :param bin_factor:
+    :return: binned image
+    """
+    return im.reshape(im.shape[0], im.shape[1] // bin_factor, bin_factor).sum(2)
+
+
+def bin_y(im, bin_factor):
+    """ Binning along y direction by given (integer) factor
+
+    :param im:
+    :param bin_factor:
+    :return: binned image
+    """
+    return im.reshape(im.shape[0] // bin_factor, bin_factor, im.shape[1]).sum(1)
+
+
+def bin_xy(im, x_factor, y_factor):
+    """ Binning along x and y directions by given (integer) factor for each
+    Make sure that image doesn't overflow during sum (for example cast to 16 bits)
+    :param im: input image
+    :param x_factor: binning factor for x axis
+    :param y_factor: binning factor for y axis
+    :return: binned image
+    """
+    return im.reshape(im.shape[0] // y_factor, y_factor, im.shape[1] // x_factor, x_factor).sum(3).sum(1)
+
+
+def to_10bit_gray(img):
+    """ Convert possible rgb image to gray; convert 8-bits image to 10 bits
+
+    :param img: gray or rgb image with 8 or 10 bits
+    :return: gray image with 10 bits
+    """
+    if len(img.shape) == 3:
+        img = img[:, :, 0]
+    if np.max(img) < 256:
+        img = img.astype('uint16') << 2
+    return img
+
+
+class StereoCam(TBox):
+    class XY(NamedTuple):
+        x: float
+        y: float
+
+    views = ('left', 'right')
+
+    @staticmethod
+    def camera_matrix(cam):
+        C = np.identity(4)
+        C[0, 0] = cam.focal.x
+        C[1, 1] = cam.focal.y
+        C[0:2, 2] = cam.center
+        return C
+
+    def rescale_resolution(self, scale):
+        """
+        Apply resolution rescaling to the calibration parameters to change those measured in pixels.
+        scale * resolution MUST lead to an integer new resolution - otherwise ValueError
+        :param scale: coefficient to calculate new resolution
+                Note: If cameras have different resolutions they are still scaled by this same factor.
+        """
+        for side in self.views:
+            if 'resolution' in self[side]:
+                new_resolution = self.XY(*(v * scale for v in self[side].resolution))
+                if not all(v.is_integer() for v in new_resolution):
+                    raise ValueError(f'Rescaling must keep resolution integer! Instead received: {new_resolution}')
+                self[side].resolution = self.XY(*(int(v) for v in new_resolution))
+
+        pix_keys = ('left.focal', 'right.focal',    # TODO: use views to define
+                    'left.center', 'right.center')
+        for key in pix_keys:
+            self[key] = self.XY(*(v * scale for v in self[key]))
+        self.scale *= scale if self.scale else scale
+
+    def __init__(self, obj=None, *, resolution=(640, 480), baseline='60mm', center=None,
+                 focal=None, angle=90, units: Union[int, str, 'Quantity'] = 1, **kwargs):
+        """
+        Stereo (dual) cameras calibration parameters,
+        is accessible as attributes or as dict as following structure:
+            Par:
+                obj: dict or Box kind of object - if provided all the named arguments are ignored (except of kwargs)
+                resolution: (x, y) [pix]
+                baseline:    b [mm]
+                left:
+                    focal:  (fx, fy) [pix]
+                    center: (cx, xy) [pix]
+                right:
+                    focal:  (fx, fy) [pix]
+                    center: (cx, xy) [pix]
+        Args:
+            resolution: (x, y) [pixels] - integer
+            center: (cx, cy) [pixels] - center of the lenses from corner (0, 0) (default - sensor center)
+            focal: (fx, fy) [pixels] - focal length in pixels
+            angle: view angle - used to calculate focal only if its not provided - ignored otherwise
+            units: str or pint-units object describing baseline units
+        """
+        from iad.core.units import assign_units
+        # process special initialization cases
+        if obj is not None:
+            super().__init__(self._convert_xy(obj), **kwargs)
+            if 'baseline' in self:
+                self.baseline = assign_units(self.baseline, units)
+            return
+
+        super().__init__(**kwargs)
+        if '__box_heritage' in kwargs:
+            return
+            #  -------------------------------
+        #
+        # kwargs.setdefault('box_it_up', True)
+        # kwargs.setdefault('default_box', True)
+
+        resolution = self.XY(*resolution)
+        self.baseline = assign_units(baseline, units)
+
+        if focal is None:
+            fsc = tan(angle / 360 * pi)
+            focal = [v / 2 / fsc for v in resolution]
+        elif not hasattr(focal, '__len__'):
+            focal = [focal, focal]
+        self.left = dict(focal=self.XY(*focal),
+                         resolution=resolution)
+
+        if center is None:
+            center = [(v - 1) / 2 for v in resolution]
+        self.left.center = self.XY(*center)
+
+        self.right = dict(self.left)
+
+    def validate(self):
+        """
+        Validate the configuration structure
+        :return: True if OK
+        """
+        from numbers import Number
+        ref_keys = self.__class__().keys(deep=True)
+
+        dif = set(ref_keys).difference(self.keys(deep=True))
+        invalids = [k for k, v in TBox(self.to_dict()).items(deep=True) if not isinstance(v, Number) or np.isnan(v)]
+
+        if dif: warn(f'Missing keys: {dif}')
+        if invalids: warn(f'Invalid values: {invalids}')
+
+        return not (dif or invalids)
+
+    def to_dict(self, *, xy=True):
+        """ Recursively converts to dict
+        :param xy: if True all the XY namedtuple fieled are also converted to dict
+        :return recursive dictionary
+         """
+        XY = StereoCam.XY
+        return {k: (dict(XY._asdict(v)) if isinstance(v, XY) and xy
+                    else (self.__class__.to_dict(v, xy=xy) if hasattr(v, 'keys')
+                          else v)) for k, v in self.items()}
+
+    def to_yaml(self, filename=None, **kw_box):
+        """
+        Convert to YAML format.
+        :param filename: optional - to save yaml
+        :param kw_box: yaml, box keyword arguments
+        :return: str if filename=None or None
+        """
+        from iad.core.units import un
+        d = self.to_dict()
+        if isinstance(d['baseline'], un.Quantity):
+            d['baseline'] = d['baseline'].to_tuple()
+        return TBox(d).to_yaml(filename=filename, **kw_box)
+
+    @classmethod
+    def _convert_xy(cls, obj):
+        XY = cls.XY
+        for k in obj:
+            item = obj[k]
+            if hasattr(item, 'items'):
+                obj[k] = XY(**item) if not set(XY._fields).symmetric_difference(item) else cls._convert_xy(item)
+        return obj
+
+    @classmethod
+    def from_yaml(cls, yaml_string=None, filename=None, **kwargs):
+        from iad.core.units import un
+        d = TBox.from_yaml(yaml_string=yaml_string, filename=filename, **kwargs)
+        if isinstance(d['baseline'], str):
+            d['baseline'] = un(d['baseline'])
+        return cls._convert_xy(d)
+
+    @classmethod
+    def from_tiff(cls, file_name: str):
+        from iad.io.inu.utils.imread import tiff_inu_cam
+        return tiff_inu_cam(file_name)
+
+    def center_crop(self, width, height):
+        """Return camera parameters for sensor symmetrically cropped around center
+
+        :param width: new width in pixels
+        :param height: new height in pixels
+        """
+        if self.left != self.right:
+            raise ValueError("Central crop on Camera Params is defined only if left == right")
+        par = self.left
+        xsz, ysz = par.resolution
+        return StereoCam(baseline=self.baseline,
+                         focal=par.focal,
+                         center=(par.center.x - (xsz - width) // 2,
+                                 par.center.y - (ysz - height) // 2),
+                         resolution=(width, height))

iad/img/regions.py

@@ -0,0 +1,176 @@
+from typing import Union, Optional
+
+import numpy as np
+import toolz as tz
+
+from iad.core import nptools as npt
+
+
+class Regions(dict):
+    """
+    Collection labeling regions in 2D array.
+
+    Organized as a dict of binary masks (of same shape) for every kind of regions.
+    Support arithmetic on the regions as logical operation on the masks.
+
+    Overrides iteration protocol to yield Regions object built around every region
+    item in the container (instead of keys, as in dict)
+    """
+
+    def __init__(self, regions: Union[dict, np.array] = None,
+                 rgn_codes: Optional[dict] = None, **kw_rgs):
+        """
+        Create from a dict of maps or a single map and dict of codes
+        :param regions: dict of maps - then just built upon it, or
+                        map of values - then dict of masks is formed using
+                        `rgn_codes` dict mapping codes in the map into keys
+        :param rgn_codes: mapping of names into values in `regions` array
+        :param kw_rgs: regions maps as kw arguments
+        """
+        if rgn_codes:
+            assert isinstance(regions, np.ndarray)
+            regions = tz.valmap(regions.__eq__, rgn_codes)
+        regions = {**(regions or {}), **kw_rgs}
+        super().__init__(regions)
+
+    def __and__(self, other):
+        # print('====> [&]', list(self.keys()),
+        #       list(other.keys()) if isinstance(other, dict) else '[M]')
+
+        def _and(r1, m1, r2, m2):
+            t1, t2 = m1.dtype.kind, m2.dtype.kind
+            if t1 == 'b':
+                if t2 == 'b':
+                    return f"{r1} & {r2}", m1 & m2
+                else:
+                    return r1, npt.fill_mask(m2, ~m1)
+            elif t2 == 'b':
+                return r1, npt.fill_mask(m1, ~m2)
+            return r1, m1
+
+        if isinstance(other, dict):
+            return Regions(dict(_and(*it1, *it2) for it1 in self.items()
+                                for it2 in other.items()))
+        else:
+            return Regions({r: (m & other) for r, m in self.items()})
+
+    def __iter__(self):
+        return (Regions({k: self[k]}) for k in self.keys())
+
+    def items(self):
+        """Iterator over regions (name, data)"""
+        return ((k, self[k]) for k in self.keys())
+
+    def __or__(self, other):
+        return Regions({f"{r1} | {r2}": m1 | m2
+                        for r1, m1 in self.items() for r2, m2 in other.items()})
+
+    def __xor__(self, other):
+        return Regions({f"{r1} ^ {r2}": m1 ^ m2
+                        for r1, m1 in self.items() for r2, m2 in other.items()})
+
+    def __add__(self, other):
+        return Regions({**self, **other})
+
+    def __sub__(self, other):
+        return
+
+    def __repr__(self):
+        if len(self):
+            shapes = set(map(lambda x: x.shape, self.values()))
+            types = set(map(lambda x: x.dtype, self.values()))
+            if len(shapes) == 1 and len(types) == 1:
+                h, w = shapes.pop()
+                tp = types.pop()
+                return ', '.join(self.keys()) + f": [{h}×{w}]{tp.kind}{tp.itemsize}"
+        return "\n".join(f"{k}: [{m.shape[0]}×{m.shape[1]}]"
+                         f"{m.dtype.kind}{m.dtype.itemsize}"
+                         for k, m in self.items())
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __iadd__(self, other: 'Regions'):
+        self.update(other)
+        return self
+
+    def __call__(self, *kinds):
+        """Return subset of the regions as a new Regions object"""
+        return Regions({kind: self[kind] for kind in kinds})
+
+    def __invert__(self):
+        return Regions({'~' + k: ~m if m.dtype is np.dtype(bool) else m
+                        for k, m in self.items()})
+
+    @property
+    def key(self):
+        """Assuming there is only one region returns its name, or None"""
+        return next(iter(self.keys())) if len(self) == 1 else None
+
+    @property
+    def mask(self):
+        """Assuming there is only one region returns its mask, or None"""
+        return next(iter(self.values())) if len(self) == 1 else None
+
+    @property
+    def masks(self):
+        return Regions({k: m for k, m in self.items() if m.dtype.kind == 'b'})
+
+    @property
+    def scores(self):
+        return Regions({k: m for k, m in self.items() if m.dtype.kind != 'b'})
+
+    @property
+    def areas(self):
+        return tz.valmap(np.sum, self)
+
+    @property
+    def area(self):
+        return self.mask.sum() if len(self) == 1 else None
+
+    @property
+    def shape(self):
+        """Return shape if all shapes are same or None"""
+        shape = None
+        for k, m in self.items():
+            if shape is None:
+                shape = m.shape
+            elif m.shape != shape:
+                return None
+        return shape
+
+    @staticmethod
+    def from_larger_than(tag: str, score, thr, out):
+        """
+        Helper function to use when creating regions calculators
+        :param tag: name of this regions kind
+        :param score: score 2d array - base for the output
+        :param thr: threshold to convert score into binary mask: score > thr
+        :param out: format and content of the output:
+                - '<tag>'  - binary mask score > thr or score < thr
+                - 'score'  - float score (before threshold application)
+                - 'region' - Regions obj with '<tag>' mask
+                - 'all'    - Regions obj with '<tag>' mask and '<tag>_score'
+                Use thr=None & 'region' for Regions obj with '<tag>_score'
+        :return:
+        """
+        score_rgn = Regions({f'{tag}_score': score})
+        if thr is None:
+            if out in {'region', 'all'}:
+                return score_rgn
+            elif out == 'score':
+                return score
+            raise ValueError(f"Can't calculate {tag} mask without `thr`!")
+        else:
+            if out == 'score':
+                return score
+
+            with np.errstate(invalid='ignore'):
+                mask = score > thr
+
+            if out == tag:
+                return mask
+            if out == 'all':
+                return Regions({tag: mask}) + score_rgn
+            if out == 'region':
+                return Regions({tag: mask})

iad/img/tools.py

@@ -0,0 +1,242 @@
+import numpy as np
+
+from .regions import Regions
+
+
+def center_crop(im, width, height):
+    from iad.img.camera import StereoCam
+
+    def slice_(sz, lim):
+        offs = (sz - lim) // 2
+        return slice(offs, offs + lim) if offs > 0 else slice(None)
+
+    if isinstance(im, Regions):
+        assert im.shape  # shape must be defined (all regions share same)
+        for k in im.keys():
+            im[k] = center_crop(im[k], width, height)
+        return im
+    elif isinstance(im, StereoCam):
+        return im.center_crop(width, height)
+
+    if im.ndim == 3:
+        h, w, _ = im.shape
+        return im[slice_(h, height), slice_(w, width), :]
+    else:
+        h, w = im.shape
+        return im[slice_(h, height), slice_(w, width)]
+
+
+def _crop_slices(rect, shape):
+    """ Return slices to crop a `rect` shape from an image of given `shape`.
+
+    :param rect: [i0, j0, height, width] - may exceed the range of the shape
+    :param shape: shape of 2D array to crop
+    :return src, trg: 2d indexers to broadcast src image into the trg image of rect[2,3] shape
+
+    :Example:
+        - src, trg = crop_crop_slices([-10, 40, 100, 160], im.shape]
+        - zeros([100, 160])[trg] = im[src]
+    """
+    src = np.array(rect)
+    src[2:] += src[:2]  # [i0, j0, i_end, j_end
+    trg = np.array([0, 0, *rect[2:]])
+    for i in [0, 1]:
+        if src[i + 2] > shape[i]:
+            src[i + 2], trg[i + 2] = shape[i], shape[i] - src[i]
+        if src[i] < 0:
+            src[i], trg[i] = trg[i], -src[i]
+    return tuple(np.s_[x[0]:x[2], x[1]:x[3]] for x in (src, trg))
+
+
+def crop(im, rect):
+    """ Crop rect from the image. rect may exceed the image are (filled wth 0).
+
+    :param im: 2D array
+    :param rect: rect: [i0, j0, height, width] - may exceed the range of the shape
+    :return cropped_image: negative margins will be filled with 0
+
+    :Example: crop_im = _crop_slices(im, [-10, 40, 100, 160])
+    """
+    new_im = np.zeros(rect[2:], dtype=im.dtype)
+    src, trg = _crop_slices(rect, im.shape)
+    new_im[trg] = im[src]
+    return new_im
+
+
+def image_2D(im: np.ndarray):
+    """Squeeze dimensions or collapse colors to produce 2D image"""
+    if im.ndim == 2:
+        return im
+    im = im.squeeze()
+    if im.ndim != 2:
+        if im.ndim == 3 and im.shape[2] == 3:
+            from skimage.color import rgb2gray
+            im = rgb2gray(im)
+        else:
+            raise ValueError('Invalid input image shape')
+    return im
+
+
+def to_3d(im: np.ndarray):
+    """Add if needed 3-rd dimension to the 2d array"""
+    if im.ndim == 3:
+        return im
+    if im.ndim == 2:
+        return im[..., None]
+    raise ValueError('Input must be 2 or 3 dimensional!')
+
+
+def im2col_sliding_broadcasting(A, BSZ, stepsize=1):
+    """ # TODO: [DOC]
+
+    :param A:
+    :param BSZ:
+    :param stepsize:
+    :return:
+    """
+    # Parameters
+    M, N = A.shape
+    col_extent = N - BSZ[1] + 1
+    row_extent = M - BSZ[0] + 1
+
+    # Get Starting block indices
+    start_idx = np.arange(BSZ[0])[:, None] * N + np.arange(BSZ[1])
+
+    # Get offsetted indices across the height and width of input array
+    offset_idx = np.arange(row_extent)[:, None] * N + np.arange(col_extent)
+
+    # Get all actual indices & index into input array for final output
+    return np.take(A, start_idx.ravel()[:, None] + offset_idx.ravel()[::stepsize])
+
+
+def im2col_sliding_strided(A, BSZ, stepsize=1):
+    """ # TODO: [DOC]
+
+    :param A:
+    :param BSZ:
+    :param stepsize:
+    :return:
+    """
+    # Parameters
+    m, n = A.shape
+    s0, s1 = A.strides
+    nrows = m - BSZ[0] + 1
+    ncols = n - BSZ[1] + 1
+    shp = BSZ[0], BSZ[1], nrows, ncols
+    strd = s0, s1, s0, s1
+
+    out_view = np.lib.stride_tricks.as_strided(A, shape=shp, strides=strd)
+    return out_view.reshape(BSZ[0] * BSZ[1], -1)[:, ::stepsize]
+
+
+def im2col_sliding_strided_v2(A, BSZ, stepsize=1):
+    """  # TODO: [DOC]
+
+    :param A:
+    :param BSZ:
+    :param stepsize:
+    :return:
+    """
+    from skimage.util import view_as_windows as viewW
+    return viewW(A, (BSZ[0], BSZ[1])).reshape(-1, BSZ[0] * BSZ[1]).T[:, ::stepsize]
+
+
+def wind_center_proc(imc, func, wnd, *, imw=None, shape=None, fill=None, out=None):
+    """ Apply custom rolling window processing on the image.
+
+    The processing sums outputs of the provided func(wind_center, pixel) over the window pixels
+    to produce a single pixel in the output.
+
+    The shape of the output may be either 'same' as the input or limited only to the 'valid' area.
+    The ill-defined boundary of the 'same' shape can be filled by:
+    - a provided numeric value (dafault is 0)
+    - 'mirror' the valid results along the boundary
+    - 'extend' the valid values on the boundary
+
+    :param im:   the input image
+    :param oper: function(c,p) to be applied on each pixel p in the window
+    :param wnd:  (height, width) of the window - must be even
+    :param shape: shape of the result, one of: ['same'] | 'valid'
+    :param fill:  [number=0] | 'mirror' | 'extend'
+    """
+    # process arguments
+    hy, hx = tuple(w // 2 for w in wnd)
+    assert tuple(w * 2 + 1 for w in (hy, hx)) == wnd
+    wsz = wnd[0] * wnd[1]
+
+    valid_area = np.s_[hy:-hy, hx:-hx]
+    imc_valid = imc[valid_area]
+
+    if imw is None:
+        imw = imc
+
+    if out is None:
+        if shape is None:
+            shape = 'same'
+    else:
+        if out.shape == imc.shape:
+            assert shape == 'same' or shape is None
+            shape = 'same'
+        elif out.shape == imc_valid.shape:
+            assert shape == 'valid' or shape is None
+            same = 'valid'
+        else:
+            raise ValueError('out.shape %s must be either ''same'' %s or ''valid'' %s!' %
+                             (out.shape, imc.shape, imc_valid.shape))
+
+            # calculate
+    imc_stride = imc_valid.reshape(-1).repeat(wsz, axis=0).reshape(imc_valid.size, wsz).T
+    imw_stride = im2col_sliding_strided_v2(imw, wnd)
+    res = func(imc_stride, imw_stride).sum(axis=0).reshape(imc_valid.shape)
+
+    # pack output
+    if shape == 'valid':
+        if out is None:
+            out = res
+        else:
+            out[:, :] = res
+    else:
+        if out is None:
+            out = np.zeros_like(imc, dtype=res.dtype)
+        out[valid_area] = res
+        fill_bounds(out, margs=(hx, hy), fill=fill)
+    return out
+
+
+def fill_bounds(im, margs, *, fill='extend', out=True):
+    """ Fill (in place) boundary area of the image according to the given rule
+
+    :param im:  the image with boundaries to fill
+    :param margs:   (top, left, bot, right) or
+                    (top, left) or  # then right == left and bottom = top
+                    marg            # then all (top, left, bot, right) == marg
+    :param fill: ['extend'] | 'mirror' | None - do nothing | number to fill
+    :param out:  [True] | False - return filled image
+    """
+    import numbers
+    if isinstance(margs, numbers.Number):
+        margs = (margs,) * 4
+    elif len(margs) == 2:
+        margs = margs * 2
+    top, left, bot, right = margs
+
+    if fill is None:
+        pass
+    elif fill == 'extend':
+        im[:top, :] = im[top, :].reshape(1, im.shape[1])
+        im[-bot:, :] = im[-bot, :].reshape(1, im.shape[1])
+        im[:, :left] = im[:, left].reshape(im.shape[0], 1)
+        im[:, -right:] = im[:, -right].reshape(im.shape[0], 1)
+    elif fill == 'mirror':
+        im[:top, :] = im[2 * top:top:-1, :]
+        im[-bot:, :] = im[-2 * bot:-bot:-1, :]
+        im[:, :left] = im[:, 2 * left:left:-1]
+        im[:, -right:] = im[:, -2 * right:-right:-1]
+    else:
+        im[:top, :] = fill
+        im[-bot:, :] = fill
+        im[:, :left] = fill
+        im[:, -right:] = fill
+
+    if out:
+        return im

iad/img/transforms.py

@@ -0,0 +1,158 @@
+"""
+Includes transforms for images
+"""
+import numpy as np
+from xxhash import xxh32_intdigest
+
+
+def norm(im, scale=1, offset=0, dtype=None, inverse=False):
+    res = (im / scale + offset) if inverse else (im - offset) * scale
+    return res.astype(dtype) if dtype else res
+
+def take_ch(im, channel):
+    mapping = {'red': 0, 'green': 1, 'blue': 2}
+    return im[:, :, mapping[channel.lower()]]
+
+def alpha_blend(im, channel):
+    from skimage.color.colorconv import rgba2rgb
+    return rgba2rgb(im, channel_axis=channel)
+
+def gamma(im: np.array, g=1.0, inp_bits=8, out_bits=8):
+    inp_range = 2 ** inp_bits - 1  # 8 -> 255 ; 10 -> 1023
+    out_range = 2 ** out_bits - 1
+
+    # build a lookup table mapping the pixel values [0, inp_range+1] to
+    # their adjusted gamma values using the range [0, out_range+1]
+    inp_range = float(inp_range)
+    inv_g = 1.0 / g
+    return ((im / inp_range) ** inv_g) * out_range
+
+
+def shot_noise(im, *, max_electrons, num_bits, norm_pool=None, clip: float | bool = True, stable=True,
+               detect_overflow: bool | float = True, dtype=None):
+    """
+    Add shot noise to image.
+    Uses internal normal generator unless pool is provided.
+
+    :param im: input image to add the noise to
+    :param norm_pool: 1D array of pre-generated random numbers with normal distribution sigma=1
+    :param max_electrons: Sensor parameter - electrons / charge for full well. MUST include
+    :param num_bits:      Data parameter - number of bits the images are made of. MUST include.
+                          Both max_electrons and num_bits create the gl2el (gray_level->electrons) conversion.
+    :param detect_overflow: do not add noise to the pixels with overflow (dtype.max or given number)
+    :param clip: clip result into range (0, dtype.max or clip value)
+    :param dtype: output must fit into this dtype, if None - use im.dtype
+    """
+    import torch
+    if dtype is None:
+        dtype = im.dtype
+
+    rnd = np.random
+
+    if isinstance(im, torch.Tensor):
+        if norm_pool or stable or detect_overflow:
+            raise ValueError("Normal pool, stable output or overflow not supported for torch tensor input.")
+        create_norm = lambda : torch.normal(0,1, im.shape).to(device)
+        device = im.device
+        sqrt = lambda _ : torch.sqrt(_)
+        max_val = torch.iinfo(dtype).max if clip is True else clip
+        clip = lambda _ : torch.clamp(_, 0, max_val)
+
+    elif isinstance(im, np.ndarray):
+        if dtype.kind == 'f' and True in (clip, detect_overflow):
+            raise ValueError("Clipping or overflow are defied only for integer types")
+        create_norm = lambda : rnd.normal(0, 1, im.shape)
+        sqrt = lambda  _ : np.sqrt(_)
+        max_val = np.iinfo(dtype).max if clip is True else clip
+        clip = lambda _ : np.clip(_, 0, max_val)
+    else:
+        raise ValueError(f'Type {type(im)} for input is not supported')
+
+    if stable is True:
+        if not im.flags.c_contiguous:
+            im = np.ascontiguousarray(im)
+        seed = xxh32_intdigest(im)
+        rnd = np.random.RandomState(seed)
+
+    if norm_pool is None:
+        rn = create_norm()
+    else:
+        rn = rnd.choice(norm_pool, im.size).reshape(im.shape)
+
+    gl2el = max_electrons / (2 ** num_bits)
+    scaler = sqrt(im / gl2el) # noise =  [sqrt(im * gl2el)] / gl2el , returned as gray levels
+    noise = scaler * rn
+
+    if detect_overflow:
+        max_val = np.iinfo(dtype).max if detect_overflow is True else detect_overflow
+        noise[im >= max_val] = 0
+
+    res = im + noise
+    if clip:
+        res = clip(res)
+    return res
+
+
+def gamma_lut(im: np.array, g=1.0, inp_bits=8, out_bits=8):
+    """
+    Using gamma transformation to change dynamic range of input image.
+    Also enables to switch between number of bits - only if input bits are higher than outputs'.
+
+    Gamma values < 1 will shift the image towards the darker end of the spectrum,
+     while gamma values > 1 will make the image appear lighter.
+    A gamma value of g == 1 will have no effect on the input image.
+
+    Using a Look-up table to create results in O(1) time.
+    The built-in function of LUT in cv2 works with either 1 or more channels,
+    and for 10 bit images we create our own LUT.
+
+    :param im: input image. Can either be uint array with 1 channel, or uint8 with 1 or more channels
+    :param g: gamma value.
+    :param inp_bits: input image bits to calculate range
+    :param out_bits: output image bits to calculate range
+    :return:
+    """
+    import cv2
+    if im.dtype.kind == 'f' and im.max() <= 1.0:  # image with range 0-1
+        raise NotImplementedError("Please use only  integer types as input."
+                                  "to not lose information in the transformation")
+    inp_range = 2 ** inp_bits - 1  # 8 -> 255 ; 10 -> 1023
+    out_range = 2 ** out_bits - 1
+
+    # build a lookup table mapping the pixel values [0, inp_range+1] to
+    # their adjusted gamma values using the range [0, out_range+1]
+    inp_range = float(inp_range)
+    inv_g = 1.0 / g
+    table = np.array([((i / inp_range) ** inv_g) * out_range
+                      for i in np.arange(0, inp_range + 1)])
+
+    table = np.round(table)
+    # special case
+    if out_bits > inp_bits:
+        raise ValueError("Please pre process your input image to have "
+                         "equal or more bits as your output image bits")
+
+    # op1 - 10 bit input image (with 1 channel)
+    elif inp_bits > 8:
+        table = table.astype("uint8") if out_bits == 8 else table.astype("uint16")
+        return table[im]  # apply gamma correction using the lookup table
+
+    # op2 - 8 bit input image - with 1 or more channels - use cv2
+    else:
+        table = table.astype("uint8")
+        return cv2.LUT(im, table)
+
+
+def conv(a, b, bound='extend'):
+    """ Wraps signal.convolve2d and adds bound 'extend' to extend the boundary values into the margins"""
+    from scipy.signal import convolve2d
+    from .tools import fill_bounds
+
+    if bound == 'extend':
+        marg = (b.shape[0] // 2, b.shape[1] // 2)
+        am = np.empty([da + db - 1 for da, db in zip(a.shape, b.shape)], a.dtype)
+        am[marg[0]:-marg[0], marg[1]:-marg[1]] = a
+        fill_bounds(am, marg, fill=bound, out=False)
+        return convolve2d(am, b, mode='valid')
+    else:
+        return convolve2d(a, b, mode='same', boundary=bound)

ialdev_img-0.1.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ialdev-img
+Version: 0.1.0
+Summary: iad.img — image transforms, regions, and stereo camera models
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ialdev-core
+Requires-Dist: ialdev-io
+Requires-Dist: ialdev-maths
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: xxhash>=3.0.0
+Requires-Dist: toolz>=0.11.0
+Requires-Dist: pytest>=7.0.0 ; extra == "dev"
+Provides-Extra: dev
+
+# ialdev-img (`imgtools/`)
+
+**PyPI:** `ialdev-img` **Imports:** `iad.img`
+
+Former `algutils.image` plus stereo camera types moved from I/O.
+

ialdev_img-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+iad/img/__init__.py,sha256=nJWLsstryFVhoBmGCYvYifZJ9QYAC20dA6EbaiRBT08,69
+iad/img/camera.py,sha256=WRKoVBkP_W_H1mR_UjSI1IufKg_S5fTrDvp5Hoj-6ts,11453
+iad/img/regions.py,sha256=ZRfEYFMu6KZ9v15GPwurMpKSgaU16lUWvavkT9rDHa4,6179
+iad/img/tools.py,sha256=41UmGsB6P8ijNPe7TOF_KuPA0laxx3VL1oo5yPRGTnA,7655
+iad/img/transforms.py,sha256=vifnMgShUR_J8xSNAuoJz-KDeDj9nzpp21u362ByYRk,6342
+ialdev_img-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+ialdev_img-0.1.0.dist-info/METADATA,sha256=Ql2pwQSWPeAQhd5GY5CD7tlOOyPdmvdgbXu3oX4tIUc,566
+ialdev_img-0.1.0.dist-info/RECORD,,

ialdev_img-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any