Source code for stonesoup.feeder.image

import numpy as np

try:
    import cv2
except ImportError as error:
    raise ImportError('Use of the image feeder classes requires that opencv-python is installed.')\
        from error

from .base import Feeder
from ..base import Property
from ..buffered_generator import BufferedGenerator
from ..types.sensordata import ImageFrame


[docs] class CFAR(Feeder): """Cell-averaging (CA) Constant False Alarm Rate (CFAR) image data feeder The CFAR feeder reads grayscale frames from an appropriate :class:`~.FrameReader`or :class:`~.Feeder` and outputs binary frames whose pixel values are either 0 or 255, indicating the lack or presence of a detection, respectively. See `here <https://en.wikipedia.org/wiki/Constant_false_alarm_rate#Cell-averaging_CFAR>`__ for more information on CA-CFAR. .. note:: The frames forwarded by the :attr:`~.CFAR.reader` must be grayscale :class:`~.ImageFrame` objects. As such :attr:`~.ImageFrame.pixels` for all frames must be 2-D arrays, containing grayscale intensity values. """ train_size: int = Property(doc="The number of train pixels", default=10) guard_size: int = Property(doc="The number of guard pixels", default=4) alpha: float = Property(doc="The threshold value", default=1.) squared: bool = Property(doc="If set to True, the threshold will be computed as a function of " "the sum of squares. The default is False, in which case a " "simple sum will be evaluated.", default=False) @BufferedGenerator.generator_method def data_gen(self): for timestamp, frame in self.reader: img = frame.pixels.copy() output_img = self.cfar(img, self.train_size, self.guard_size, self.alpha, self.squared) new_frame = ImageFrame(output_img, frame.timestamp) yield timestamp, new_frame
[docs] @staticmethod def cfar(input_img, train_size=10, guard_size=4, alpha=1., squared=False): """ Perform Constant False Alarm Rate (CFAR) detection on an input image Parameters ---------- input_img: numpy.ndarray The input grayscale image. train_size: int The number of train pixels. guard_size: int The number of guard pixels. alpha: float The threshold value. squared: bool If set to True, the threshold will be computed as a function of the sum of squares. The default is False, in which case a simple sum will be evaluated. Returns ------- numpy.ndarray Output image containing 255 for pixels where a target is detected and 0 otherwise. """ # Get width and height of image width, height = input_img.shape # Compute the CFAR window size window_size = 1 + 2*guard_size + 2*train_size # Initialise empty output image output_img = np.zeros(input_img.shape, np.uint8) # Iterate through all pixels for i in range(height-window_size): for j in range(width-window_size): # Compute coordinates of test pixel c_i = i + guard_size + train_size c_j = j + guard_size + train_size # Select the pixels inside the window v = input_img[i:i + window_size, j:j + window_size].copy() # Exclude pixels inside guard zone v[train_size:train_size + 2 * guard_size + 1, train_size:train_size + 2 * guard_size + 1] = 0 # # The above should be equivalent to the code below # v = np.zeros((window_size, window_size)) # for k in range(window_size): # for l in range(window_size): # if (k >= train_size) and (k < (window_size - train_size)) \ # and (l >= train_size) and (l < (window_size - train_size)): # continue # v[k, l] += input_img[i+k,j+l] # Compute the threshold if squared: v = v**2 threshold = np.sum(v) / (window_size**2 - (2*guard_size + 1)**2) # Populate the output image input_value = input_img[c_i, c_j] if squared: input_value = input_value**2 if input_value/threshold > alpha: output_img[c_i, c_j] = 255 return output_img
[docs] class CCL(Feeder): """Connected Component Labelling (CCL) image data feeder The CCL feeder reads binary frames from an appropriate :class:`~.FrameReader`or :class:`~.Feeder` and outputs labelled frames whose pixel values contain the label of the connected component to which each pixel is has been assigned. See `here <https://en.wikipedia.org/wiki/Connected-component_labeling#Graphical_example_of_ two-pass_algorithm>`__ for more information on and example applications of CCL. .. note:: The frames forwarded by the :attr:`~.CCL.reader` must be binary :class:`~.ImageFrame` objects. As such :attr:`~.ImageFrame.pixels` for all frames must be 2-D arrays, where each element can take only 1 of 2 possible values (e.g. [0 or 1], [0 or 255], etc.). """ @BufferedGenerator.generator_method def data_gen(self): for timestamp, frame in self.reader: img = frame.pixels.copy() _, labels_img = cv2.connectedComponents(img) new_frame = ImageFrame(labels_img, frame.timestamp) yield timestamp, new_frame