visiongraph.input.BaseDepthCamera

  1from abc import ABC, abstractmethod
  2from argparse import ArgumentParser, Namespace, ArgumentError
  3from typing import Tuple, Optional
  4
  5import cv2
  6import numpy as np
  7
  8from visiongraph.input.BaseCamera import BaseCamera
  9from visiongraph.input.BaseDepthInput import BaseDepthInput
 10from visiongraph.model.CameraStreamType import CameraStreamType
 11from visiongraph.util import MathUtils
 12
 13
 14class BaseDepthCamera(BaseCamera, BaseDepthInput, ABC):
 15    """
 16    Abstract base class for depth cameras that handle both color and depth input streams.
 17    """
 18
 19    def __init__(self):
 20        """
 21        Initializes the BaseDepthCamera with default settings.
 22        """
 23        super().__init__()
 24        self.use_infrared = False
 25
 26    def configure(self, args: Namespace):
 27        """
 28        Configures the camera settings based on command line arguments.
 29
 30        :param args: The command line arguments namespace.
 31        """
 32        super().configure(args)
 33        self.use_infrared = args.infrared
 34
 35    def _calculate_depth_coordinates(self, x: float, y: float, width: int, height: int) -> Tuple[int, int]:
 36        """
 37        Calculates depth coordinates from given normalized coordinates.
 38
 39        :param x: The x coordinate (normalized).
 40        :param y: The y coordinate (normalized).
 41        :param width: The width of the image.
 42        :param height: The height of the image.
 43
 44        :return: The calculated pixel coordinates (ix, iy).
 45        """
 46        x, y = MathUtils.transform_coordinates(x, y, self.rotate, self.flip)
 47
 48        if self.crop is not None:
 49            norm_crop = self.crop.scale(1.0 / width, 1.0 / height)
 50            x = MathUtils.map_value(x, 0.0, 1.0, norm_crop.x_min, norm_crop.x_max)
 51            y = MathUtils.map_value(y, 0.0, 1.0, norm_crop.y_min, norm_crop.y_max)
 52
 53        ix, iy = width * x, height * y
 54
 55        ix = round(MathUtils.constrain(ix, upper=width - 1))
 56        iy = round(MathUtils.constrain(iy, upper=height - 1))
 57
 58        return ix, iy
 59
 60    @staticmethod
 61    def _colorize(
 62        image: np.ndarray,
 63        clipping_range: Tuple[Optional[int], Optional[int]] = (None, None),
 64        colormap: Optional[int] = None,
 65    ) -> np.ndarray:
 66        """
 67        Colorizes a depth image within a specified clipping range.
 68
 69        :param image: The image to colorize.
 70        :param clipping_range: The clipping range for normalization.
 71        :param colormap: The OpenCV colormap to apply.
 72
 73        :return: The colorized image.
 74        """
 75        if clipping_range[0] is not None and clipping_range[1] is not None:
 76            low, high = clipping_range
 77            delta = high - low
 78
 79            img = image.clip(low, high)
 80            img = (((img - low) / delta) * 255).astype(np.uint8)
 81        else:
 82            img = image
 83            img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
 84
 85        if colormap is not None:
 86            img = cv2.applyColorMap(img, colormap)
 87        return img
 88
 89    @abstractmethod
 90    def pre_process_image(
 91        self, image: np.ndarray, stream_type: CameraStreamType = CameraStreamType.Color
 92    ) -> Optional[np.ndarray]:
 93        """
 94        Pre-processes the input image based on the stream type.
 95
 96        :param image: The image to be pre-processed.
 97        :param stream_type: The type of the camera stream (default is CameraStreamType.Color).
 98
 99        :return: The pre-processed image or None if unprocessable.
100        """
101        return image
102
103    @abstractmethod
104    def get_raw_image(self, stream_type: CameraStreamType = CameraStreamType.Color) -> Optional[np.ndarray]:
105        """
106        Retrieves the raw image from the camera based on the stream type.
107
108        :param stream_type: The type of the camera stream (default is CameraStreamType.Color).
109
110        :return: The raw image or None if unavailable.
111        """
112        pass
113
114    def get_image(
115        self,
116        stream_type: CameraStreamType = CameraStreamType.Color,
117        pre_processed: bool = True,
118        post_processed: bool = True,
119    ) -> Optional[np.ndarray]:
120        """
121        Retrieves and processes the image from the camera stream.
122
123        :param stream_type: The type of the camera stream (default is CameraStreamType.Color).
124        :param pre_processed: Whether to pre-process the image (default is True).
125        :param post_processed: Whether to post-process the image (default is True).
126
127        :return: The processed image or None if unavailable.
128        """
129        frame = self.get_raw_image(stream_type)
130
131        if frame is None:
132            return None
133
134        # apply camera pre-processing
135        if pre_processed:
136            frame = self.pre_process_image(frame, stream_type)
137
138        # apply base camera post-processing
139        if post_processed:
140            _, frame = self._post_process(0, frame)
141            return frame
142
143        return frame
144
145    @property
146    def color_image(self) -> Optional[np.ndarray]:
147        """
148        Returns the processed color image.
149
150        :return: The processed color image or None if unavailable.
151        """
152        return self.get_image(CameraStreamType.Color, True, True)
153
154    @property
155    def depth_image(self) -> Optional[np.ndarray]:
156        """
157        Returns the processed depth image.
158
159        :return: The processed depth image or None if unavailable.
160        """
161        return self.get_image(CameraStreamType.Depth, True, True)
162
163    @property
164    def infrared_image(self) -> Optional[np.ndarray]:
165        """
166        Returns the processed infrared image.
167
168        :return: The processed infrared image or None if unavailable.
169        """
170        return self.get_image(CameraStreamType.Infrared, True, True)
171
172    @property
173    def raw_color_image(self) -> Optional[np.ndarray]:
174        """
175        Returns the raw color image from the camera.
176
177        :return: The raw color image or None if unavailable.
178        """
179        return self.get_raw_image(CameraStreamType.Color)
180
181    @property
182    def raw_depth_image(self) -> Optional[np.ndarray]:
183        """
184        Returns the raw depth image from the camera.
185
186        :return: The raw depth image or None if unavailable.
187        """
188        return self.get_raw_image(CameraStreamType.Depth)
189
190    @property
191    def raw_infrared_image(self) -> Optional[np.ndarray]:
192        """
193        Returns the raw infrared image from the camera.
194
195        :return: The raw infrared image or None if unavailable.
196        """
197        return self.get_raw_image(CameraStreamType.Infrared)
198
199    @staticmethod
200    def add_params(parser: ArgumentParser):
201        """
202        Adds camera-specific parameters to the argument parser.
203
204        :param parser: The argument parser instance.
205        """
206        super(BaseDepthCamera, BaseDepthCamera).add_params(parser)
207        BaseDepthInput.add_params(parser)
208
209        try:
210            parser.add_argument("-ir", "--infrared", action="store_true", help="Use infrared as input stream.")
211        except ArgumentError as ex:
212            if ex.message.startswith("conflicting"):
213                return
214            raise ex
215
216    @property
217    def is_playback(self) -> bool:
218        """
219        Indicates whether the camera is in playback mode.
220
221        :return: False since this is a real-time camera.
222        """
223        return False