• Pull request size

• Pull Panda

• CRUD
  • Create a new pipeline
  • Configure a pipeline
  • Add/remove elements
  • Update configuration
  • Set pipeline activation rules
  • Edit pipeline activation rules
• Pipeline Activation API:
  • Rules and Triggers schema
  • Define a rule
  • Define a trigger
  • External triggers (e.g. MQTT, HASS)
  • Internal triggers (output from other pipelines)

• FOSSA

• Github risk assessment action

• Gstreamer hangups, AV source plug/unplug
• Gradual component healing, termination, forceful recycling based on component responsiveness: stop signal, SIGTERM, SIGKILL. Cleanup sub-process zombies.
• Gradual component healing from smallest to largest scope: PipeElement, Pipeline, Root servers
• Test coverage

• One JPG image with positive object detection

• Face identification
• Face verification.

• CodeCov

• AnyLine
• CommitLint PR

• EdgeTPU hangups, plug/unplug
• Gradual component healing, termination, forceful recycling based on component responsiveness: stop signal, SIGTERM, SIGKILL. Cleanup sub-process zombies.
• Test coverage

• Build from source
• Run tests
• Run code coverage report
• Build docker image
• Publish docker image on docker hub

• Gradual component healing, termination, forceful recycling based on component responsiveness: stop signal, SIGTERM, SIGKILL. Cleanup sub-process zombies.
• Gradual component healing from smallest to largest scope: PipeElement, Pipeline, Root servers
• Test coverage

• CodeFactor
• Codacy
• LGTM

• Filter previous detection output on
• Labels(categories)
• Pass remaining detections on to next element
• Move 'person' iteration code from FaceDetect to mew mask element.

• Process live video stream (e.g. rtsp)
• Process live audio stream
• Process single still image input

(taking input from ai pipe, not gstreamer)

• Async events
  • How elements should fire async evens (e.g. new detections, new saved samples available, etc.)
  • How clients should consume events.
  • Auto broker from Python to MQTT
  • Auto broker from Python to WebSockets
  • Auto broker to Kafka

• Build and publish ARMx (RPI 3&4) images
• Build and publish x86 images

• Live:

  • Example 1: real time person detection at front door.
  • Example 2: real time face recognition for door unlock.

• Offline:

  • Example 1: alert if the same unknown face shows up around the building more than once a week.
  • Example 2: count all unique persons who entered the building in the past month.

Why:

• Live models are usually busy during peak hours and often idle during nighttime.
• Offline can run when resources aren't tied up by live models.
• Better resource utilization would allow a broader set of use cases to be handled on the same system.

• Use EdgeTPU when available
• Fall back to TFLite otherwise

• Travis CI
• Docker Hub

• MergeDroid

• Dependabot

• Provide face recognition timeline events (in addition to face detection) for known faces
• Enable users to provide face recognition labeling by presenting them with detected faces and allowing them to provide tags or names for known faces. Similar to FB's friends tagging ,except no cloud image uploads.
• Use the labeling data to train a local on-device face recognition model.
• Allow multiple edge devices to collaborate in training via federated learning to better recognize people in a given household or professional facility premises.

Related resources:

• https://medium.com/@estebanuri/real-time-face-recognition-with-android-tensorflow-lite-14e9c6cc53a5
• https://pypi.org/project/face-recognition/
• https://medium.com/@BhashkarKunal/face-recognition-real-time-webcam-face-recognition-system-using-deep-learning-algorithm-and-98cf8254def7
• https://machinelearningmastery.com/how-to-develop-a-face-recognition-system-using-facenet-in-keras-and-an-svm-classifier/

Future work:

• Use federated learning to enable multiple edge devices (owned by the same user) to work together on recognizing user known faces without sharing image data with each other or any third parties.

Enhance data configuration parameters to prevent running out of space.

Options to consider:

• Delete oldest files after space available is under certain %
• Keep data for up to day/week/month
• Keep data up to a certain amount of MB

PWA has similar data retention issues that are automatically addressed by modern browsers. We can use browser designs as a reference:
https://web.dev/storage-for-the-web/

Chrome allows the browser to use up to 60% of total disk space. You can use the StorageManager API to determine the maximum quota available. Other Chromium-based browsers may allow the browser to use more storage.

Describe the solution you'd like
We can run a cron job to automatically remove data files older than a configurable time period.

Example:
https://stackoverflow.com/questions/41416628/cron-job-to-auto-delete-folder-older-than-7-days-linux

Describe alternatives you've considered
An alternative would be to implement data retention policy for each service that stores data on the local edge device.

• REST API
  • Get/set element config at deployment level
  • Get/set element config at a pipeline level
  • Search element historical data per pipeline
  • Get element historical data per pipeline
  • Add element to pipeline
  • Remove element from pipeline
• Python API
  • Python to REST auto proxy rules
• Notifications API
  • Async events
  • How elements should fire async evens (e.g. new detections, new saved samples available, etc.)
  • How clients should consume events.

• notify web app (PWA Push Notification) that new samples are available to show to users.
• notify external notification handler (e.g. IFTTT, Zapier, MQTT) that allows integration with a wide variety of end points.

• Serve multiple AI models at runtime on the same EdgeTPU
• Share the same EdgeTPU between multiple pipe elements in the same pipeline
• Share the same EdgeTPU between multiple pipelines
• Fall back to TFLite when EdgeTPU is not available

• Accept arbitrary SVG to be scaled and applied against input image samples
• Accept arbitrary polygon defined as a sequence of lines.
• Mask out by painting in solid black all pixels outside of the polygon.
• Crop out border of solid black to maximize the visible region fed onto the next AI element.