camera_utils.py

   1 #!/usr/bin/env python3
   2
   3 # © Copyright 2021-2022, Scott Gasch
   4
   5 """Utilities for dealing with webcam images."""
   6
   7 import logging
   8 import platform
   9 import subprocess
  10 import warnings
  11 from dataclasses import dataclass
  12 from typing import Optional
  13
  14 import cv2  # type: ignore
  15 import numpy as np
  16 import requests
  17
  18 import decorator_utils
  19 import exceptions
  20 import scott_secrets
  21
  22 logger = logging.getLogger(__name__)
  23
  24
  25 @dataclass
  26 class RawJpgHsv:
  27     """Raw image bytes, the jpeg image and the HSV (hue saturation value) image."""
  28
  29     raw: Optional[bytes] = None
  30     jpg: Optional[np.ndarray] = None
  31     hsv: Optional[np.ndarray] = None
  32
  33
  34 @dataclass
  35 class SanityCheckImageMetadata:
  36     """Is a Blue Iris image bad (big grey borders around it) or infrared?"""
  37
  38     is_infrared_image: bool = False
  39     is_bad_image: bool = False
  40
  41
  42 def sanity_check_image(hsv: np.ndarray) -> SanityCheckImageMetadata:
  43     """See if a Blue Iris or Shinobi image is bad and infrared."""
  44
  45     def is_near(a, b) -> bool:
  46         return abs(a - b) < 3
  47
  48     rows, cols, _ = hsv.shape
  49     num_pixels = rows * cols
  50     weird_orange_count = 0
  51     hs_zero_count = 0
  52     for r in range(rows):
  53         for c in range(cols):
  54             pixel = hsv[(r, c)]
  55             if is_near(pixel[0], 16) and is_near(pixel[1], 117) and is_near(pixel[2], 196):
  56                 weird_orange_count += 1
  57             elif is_near(pixel[0], 0) and is_near(pixel[1], 0):
  58                 hs_zero_count += 1
  59     logger.debug("hszero#=%d, weird_orange=%d", hs_zero_count, weird_orange_count)
  60     return SanityCheckImageMetadata(
  61         hs_zero_count > (num_pixels * 0.75),
  62         weird_orange_count > (num_pixels * 0.75),
  63     )
  64
  65
  66 @decorator_utils.retry_if_none(tries=2, delay_sec=1, backoff=1.1)
  67 def fetch_camera_image_from_video_server(
  68     camera_name: str, *, width: int = 256, quality: int = 70
  69 ) -> Optional[bytes]:
  70     """Fetch the raw webcam image from the video server."""
  71     camera_name = camera_name.replace(".house", "")
  72     camera_name = camera_name.replace(".cabin", "")
  73     url = f"http://10.0.0.226:8080/{scott_secrets.SHINOBI_KEY1}/jpeg/{scott_secrets.SHINOBI_KEY2}/{camera_name}/s.jpg"
  74     logger.debug('Fetching image from %s', url)
  75     try:
  76         response = requests.get(url, stream=False, timeout=10.0)
  77         if response.ok:
  78             raw = response.content
  79             logger.debug('Read %d byte image from HTTP server', len(response.content))
  80             tmp = np.frombuffer(raw, dtype="uint8")
  81             logger.debug(
  82                 'Translated raw content into %s %s with element type %s',
  83                 tmp.shape,
  84                 type(tmp),
  85                 type(tmp[0]),
  86             )
  87             jpg = cv2.imdecode(tmp, cv2.IMREAD_COLOR)
  88             logger.debug(
  89                 'Decoded into %s jpeg %s with element type %s',
  90                 jpg.shape,
  91                 type(jpg),
  92                 type(jpg[0][0]),
  93             )
  94             hsv = cv2.cvtColor(jpg, cv2.COLOR_BGR2HSV)
  95             logger.debug(
  96                 'Converted JPG into %s HSV HSV %s with element type %s',
  97                 hsv.shape,
  98                 type(hsv),
  99                 type(hsv[0][0]),
 100             )
 101             ret = sanity_check_image(hsv)
 102             if not ret.is_bad_image:
 103                 return raw
 104     except Exception as e:
 105         logger.exception(e)
 106     msg = f"Got a bad image or HTTP error from {url}; returning None."
 107     logger.warning(msg)
 108     warnings.warn(msg, stacklevel=2)
 109     return None
 110
 111
 112 def camera_name_to_hostname(camera_name: str) -> str:
 113     """Map a camera name to a hostname
 114
 115     >>> camera_name_to_hostname('driveway')
 116     'driveway.house'
 117
 118     >>> camera_name_to_hostname('cabin_driveway')
 119     'driveway.cabin'
 120
 121     """
 122     mapping = {
 123         "driveway": "driveway.house",
 124         "backyard": "backyard.house",
 125         "frontdoor": "frontdoor.house",
 126         "cabin_driveway": "driveway.cabin",
 127     }
 128     camera_name = mapping.get(camera_name, camera_name)
 129     if "." not in camera_name:
 130         hostname = platform.node()
 131         suffix = hostname.split(".")[-1]
 132         camera_name += f".{suffix}"
 133     return camera_name
 134
 135
 136 @decorator_utils.retry_if_none(tries=2, delay_sec=1, backoff=1.1)
 137 def fetch_camera_image_from_rtsp_stream(camera_name: str, *, width: int = 256) -> Optional[bytes]:
 138     """Fetch the raw webcam image straight from the webcam's RTSP stream."""
 139     hostname = camera_name_to_hostname(camera_name)
 140     stream = f"rtsp://camera:{scott_secrets.CAMERA_PASSWORD}@{hostname}:554/live"
 141     logger.debug('Fetching image from RTSP stream %s', stream)
 142     try:
 143         cmd = [
 144             "/usr/bin/timeout",
 145             "-k 9s",
 146             "8s",
 147             "/usr/local/bin/ffmpeg",
 148             "-y",
 149             "-i",
 150             f"{stream}",
 151             "-f",
 152             "singlejpeg",
 153             "-vframes",
 154             "1",
 155             "-vf",
 156             f"scale={width}:-1",
 157             "-",
 158         ]
 159         with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) as proc:
 160             out, _ = proc.communicate(timeout=10)
 161             return out
 162     except Exception as e:
 163         logger.exception(e)
 164     msg = f"Failed to retrieve image via RTSP {stream}, returning None."
 165     logger.warning(msg)
 166     warnings.warn(msg, stacklevel=2)
 167     return None
 168
 169
 170 @decorator_utils.timeout(seconds=30, use_signals=False)
 171 def _fetch_camera_image(camera_name: str, *, width: int = 256, quality: int = 70) -> RawJpgHsv:
 172     """Fetch a webcam image given the camera name."""
 173     logger.debug("Trying to fetch camera image from video server")
 174     raw = fetch_camera_image_from_video_server(camera_name, width=width, quality=quality)
 175     if raw is None:
 176         logger.debug("Reading from video server failed; trying direct RTSP stream")
 177         raw = fetch_camera_image_from_rtsp_stream(camera_name, width=width)
 178     if raw is not None and len(raw) > 0:
 179         tmp = np.frombuffer(raw, dtype="uint8")
 180         jpg = cv2.imdecode(tmp, cv2.IMREAD_COLOR)
 181         hsv = cv2.cvtColor(jpg, cv2.COLOR_BGR2HSV)
 182         return RawJpgHsv(
 183             raw=raw,
 184             jpg=jpg,
 185             hsv=hsv,
 186         )
 187     msg = "Failed to retieve image from both video server and direct RTSP stream"
 188     logger.warning(msg)
 189     warnings.warn(msg, stacklevel=2)
 190     return RawJpgHsv(None, None, None)
 191
 192
 193 def fetch_camera_image(camera_name: str, *, width: int = 256, quality: int = 70) -> RawJpgHsv:
 194     try:
 195         return _fetch_camera_image(camera_name, width=width, quality=quality)
 196     except exceptions.TimeoutError:
 197         logger.warning('Fetching camera image operation timed out.')
 198         return RawJpgHsv(None, None, None)
 199
 200
 201 if __name__ == '__main__':
 202     import doctest
 203
 204     doctest.testmod()