path: root/src/argaze/AreaOfInterest/AOIFeatures.py

#!/usr/bin/env python

from typing import TypeVar, Tuple
import json

from argaze import DataStructures

import cv2 as cv
import matplotlib.path as mpath
import numpy
from shapely.geometry import Polygon
from shapely.geometry.point import Point

AreaOfInterestType = TypeVar('AreaOfInterest', bound="AreaOfInterest")
# Type definition for type annotation convenience

class AreaOfInterest(numpy.ndarray):
    """Define Area Of Interest as an array of points of any dimension."""

    def __new__(cls, points: numpy.array = numpy.empty(0)) -> AreaOfInterestType:
        """View casting inheritance."""

        return numpy.array(points).view(AreaOfInterest)

    def __repr__(self):
        """String representation"""

        return repr(self.tolist())

    def __str__(self):
        """String display"""

        return repr(self.tolist())

    @property
    def dimension(self) -> int:
        """Number of axis coding area points positions."""
        
        return self.shape[1]

    @property
    def size(self) -> int:
        """Number of points defining the area."""
        
        return self.shape[0]

    @property
    def empty(self) -> bool:
        """Is AOI empty ?"""
        
        return self.shape[0] == 0

    @property
    def center(self) -> numpy.array:
        """Center of mass."""

        return self.mean(axis=0)

    @property
    def area(self) -> float:
        """Area of the polygon defined by aoi's points."""

        return Polygon(self).area

    @property
    def bounding_box(self) -> numpy.array:
        """Get area's bounding box.
        .. warning::
           Available for 2D AOI only."""

        assert(self.size > 1)
        assert(self.dimension == 2)

        min_x, min_y = numpy.min(self, axis=0)
        max_x, max_y = numpy.max(self, axis=0)

        return numpy.array([(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)])
    
    def clockwise(self) -> AreaOfInterestType:
        """Get area points in clockwise order.
        .. warning::
           Available for 2D AOI only."""

        assert(self.dimension == 2)

        O = self.center
        OP = (self - O) / numpy.linalg.norm(self - O)
        angles = numpy.arctan2(OP[:, 1], OP[:, 0])

        return self[numpy.argsort(angles)]

    def contains_point(self, point: tuple) -> bool:
        """Is a point inside area?
        .. warning::
           Available for 2D AOI only.
        .. danger::
           The AOI points must be sorted in clockwise order."""

        assert(self.dimension == 2)
        assert(len(point) == self.dimension)

        return mpath.Path(self).contains_points([point])[0]

    def inner_axis(self, point: tuple) -> tuple:
        """Transform the coordinates from the global axis to the AOI's axis.
        .. warning::
           Available for 2D AOI only.
        .. danger::
           The AOI points must be sorted in clockwise order."""

        assert(self.dimension == 2)

        Src = self
        Src_origin = Src[0]
        Src = (Src - Src_origin).reshape((len(Src)), 2).astype(numpy.float32)

        Dst = numpy.array([[0., 0.], [1., 0.], [1., 1.], [0., 1.]]).astype(numpy.float32)

        P = cv.getPerspectiveTransform(Src, Dst)
        X = numpy.append(numpy.array(numpy.array(point) - Src_origin), [1.0]).astype(numpy.float32)
        Y = numpy.dot(P, X)

        La = (Y/Y[2])[:-1]

        return tuple(numpy.around(La, 4))

    def outter_axis(self, point: tuple) -> tuple:
        """Transform the coordinates from the AOI's axis to the global axis.
        .. warning::
           Available for 2D AOI only.
        .. danger::
           The AOI points must be sorted in clockwise order."""

        assert(self.dimension == 2)

        Src = numpy.array([[0., 0.], [1., 0.], [1., 1.], [0., 1.]]).astype(numpy.float32)

        Dst = self.astype(numpy.float32)
        Dst_origin = Dst[0]
        Dst = (Dst - Dst_origin).reshape((len(Dst)), 2)

        P = cv.getPerspectiveTransform(Src, Dst)
        X = numpy.array([point[0], point[1], 1.0]).astype(numpy.float32)
        Y = numpy.dot(P, X)

        Lp = Dst_origin + (Y/Y[2])[:-1]

        return tuple(numpy.rint(Lp).astype(int))

    def circle_intersection(self, center: tuple, radius: float) -> Tuple[numpy.array, float, float]:
        """Get intersection shape with a circle, intersection area / AOI area ratio and intersection area / circle area ratio.
        .. warning::
           Available for 2D AOI only.

           * **Returns:** 
            - intersection shape, 
            - intersection aoi ratio,
            - intersection circle ratio
        """

        assert(self.dimension == 2)

        self_polygon = Polygon(self)
        args_circle = Point(center).buffer(radius)

        if self_polygon.intersects(args_circle):

            intersection = self_polygon.intersection(args_circle)

            intersection_array = numpy.array([list(xy) for xy in intersection.exterior.coords[:]]).astype(numpy.float32).view(AreaOfInterest)

            return intersection_array, intersection.area / self_polygon.area, intersection.area / args_circle.area

        else:

            empty_array = numpy.array([list([])]).astype(numpy.float32).view(AreaOfInterest)

            return empty_array, 0., 0.

    def draw(self, frame, color, border_size=1):
        """Draw 2D AOI into frame.
        .. warning::
           Available for 2D AOI only."""

        assert(self.dimension == 2)

        if len(self) > 1:

            # Draw form
            pixels = numpy.rint(self).astype(int)
            cv.line(frame, pixels[-1], pixels[0], color, border_size)
            for A, B in zip(pixels, pixels[1:]):
                cv.line(frame, A, B, color, border_size)

            # Draw center
            center_pixel = numpy.rint(self.center).astype(int)
            cv.circle(frame, center_pixel, 1, color, -1)

AOISceneType = TypeVar('AOIScene', bound="AOIScene")
# Type definition for type annotation convenience

class AOIScene():
    """Define AOI scene as a dictionary of AOI."""

    def __init__(self, dimension: int, areas: dict = None):
        """Initialisation."""

        assert(dimension > 0)

        self.__dimension = dimension
        self.__areas = {}

        # NEVER USE {} as default function argument
        if areas is not None:

            for name, area in areas.items():
                self[name] = AreaOfInterest(area)

    def __getitem__(self, name) -> AreaOfInterest:
        """Get an AOI from the scene."""

        return AreaOfInterest(self.__areas[name])

    def __setitem__(self, name, aoi: AreaOfInterest):
        """Add an AOI to the scene."""

        assert(aoi.dimension == self.__dimension)

        self.__areas[name] = AreaOfInterest(aoi)

        # Expose area as an attribute of the class
        setattr(self, name, self.__areas[name])

    def __delitem__(self, key):
        """Remove an AOI from the scene."""

        del self.__areas[key]

        # Stop area exposition as an attribute of the class
        delattr(self, key)

    def __len__(self):
        """Get number of AOI into scene."""
        return len(self.__areas)

    def __repr__(self):
        """String representation"""

        return str(self.__areas)

    def __str__(self) -> str:
        """String display"""

        output = ''

        for name, area in self.__areas.items():

            output += f'\n\t{name}:\n{area}'

        return output

    def __mul__(self, scale_vector) -> AOISceneType:
        """Scale scene by a vector."""

        assert(len(scale_vector) == self.__dimension)

        for name, area in self.__areas.items():
            
            self.__areas[name] = self.__areas[name] * scale_vector

        return self

    # Allow n * scene operation
    __rmul__ = __mul__

    def items(self) -> Tuple[str, AreaOfInterest]:
        """Iterate over areas."""

        return self.__areas.items()

    def keys(self) -> list[str]:
        """Get areas name."""

        return self.__areas.keys()

    @property
    def dimension(self) -> int:
        """Dimension of the AOIs in scene."""

        return self.__dimension

    @property
    def bounds(self) -> numpy.array:
        """Get scene's bounds."""

        all_vertices = []

        for area in self.__areas.values():
            for vertice in area:
                all_vertices.append(vertice)

        all_vertices = numpy.array(all_vertices) #.astype(numpy.float32)

        min_bounds = numpy.min(all_vertices, axis=0)
        max_bounds = numpy.max(all_vertices, axis=0)

        return numpy.array([min_bounds, max_bounds])

    @property
    def center(self) -> numpy.array:
        """Get scene's center point."""

        min_bounds, max_bounds = self.bounds

        return (min_bounds + max_bounds) / 2

    @property
    def size(self) -> numpy.array:
        """Get scene size."""

        min_bounds, max_bounds = self.bounds

        return max_bounds - min_bounds

    def copy(self, exclude=[]) -> AOISceneType:
        """Copy scene partly excluding AOI by name."""

        scene_copy = type(self)()

        for name, area in self.__areas.items():
            
            if name not in exclude:

                scene_copy[name] = AreaOfInterest(area) #.astype(numpy.float32).view(AreaOfInterest)

        return scene_copy

class TimeStampedAOIScenes(DataStructures.TimeStampedBuffer):
    """Define timestamped buffer to store AOI scenes in time."""

    def __setitem__(self, ts, scene):
        """Force value to inherit from AOIScene."""

        assert(type(scene).__bases__[0] == AOIScene)

        super().__setitem__(ts, scene)