// Create the closed contour path from points
let path = CGMutablePath()
path.addLines(between: points)
path.closeSubpath()

// Create CAShapeLayer matching the dimensions of the input frame
let layer = CAShapeLayer()
layer.frame = frame.extent // Assuming frame is the input CIImage with the face

// Set background and fill color and set the path
layer.fillColor = UIColor.white.cgColor
layer.backgroundColor = UIColor.black.cgColor
layer.path = path

// Render the contents of the CAShapeLayer to CGImage
let width = Int(layer.bounds.width)
let height = Int(layer.bounds.height)
let context = CGContext(data: nil,
                        width: width,
                        height: height,
                        bitsPerComponent: 8,
                        bytesPerRow: 4 * width,
                        space: CGColorSpaceCreateDeviceRGB(),
                        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!

layer.render(in: context)
let cgImage = context.makeImage()!

// Create CIImage out of it
let ciImage = CIImage(cgImage: cgImage)

// To create clear background CIImage just do this:
let bgImage = CIImage.clear.cropped(to: frame.extent)

import UIKit
import Vision

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    var imageOrientation = CGImagePropertyOrientation(.up)
    
    override func viewDidAppear(_ animated: Bool) {
        
        super.viewDidAppear(animated)
        
        if let image = UIImage(named: "group") {
            imageView.image = image
            imageView.contentMode = .scaleAspectFit
            imageOrientation = CGImagePropertyOrientation(image.imageOrientation)
            
            guard let cgImage = image.cgImage else {return}
            setupVision(image: cgImage)
        }
    }
    
    private func setupVision (image: CGImage) {
        let faceDetectionRequest = VNDetectFaceRectanglesRequest(completionHandler: self.handelFaceDetectionRequest)
        
        let imageRequestHandler = VNImageRequestHandler(cgImage: image, orientation: imageOrientation, options: [:])
    
        do {
            try imageRequestHandler.perform([faceDetectionRequest])
        }catch let error as NSError {
            print(error)
            return
        }
    }
    
    private func handelFaceDetectionRequest (request: VNRequest?, error: Error?) {
        if let requestError = error as NSError? {
            print(requestError)
            return
        }
        
        guard let image = imageView.image else {return}
        guard let cgImage = image.cgImage else {return}
        
        let imageRect = self.determineScale(cgImage: cgImage, imageViewFrame: imageView.frame)
        
        self.imageView.layer.sublayers = nil
        
        if let results = request?.results as? [VNFaceObservation] {
            for observation in results {
                let faceRect = convertUnitToPoint(originalImageRect: imageRect, targetRect: observation.boundingBox)
                
                let emojiRect = CGRect(x: faceRect.origin.x, y: faceRect.origin.y - 5, width: faceRect.size.width  + 5, height: faceRect.size.height + 5)
            
                let textLayer = CATextLayer()
                textLayer.string = "🦸‍♂️"
                textLayer.fontSize = faceRect.width
                textLayer.frame = emojiRect
                textLayer.contentsScale = UIScreen.main.scale
                
                self.imageView.layer.addSublayer(textLayer)
                
            }
        }
    }

    
}

import UIKit

class UIViewController {
    
    public func convertUnitToPoint (originalImageRect: CGRect, targetRect: CGRect) -> CGRect {
        
        var pointRect = targetRect
        
        pointRect.origin.x = originalImageRect.origin.x + (targetRect.origin.x * originalImageRect.size.width)
        pointRect.origin.y = originalImageRect.origin.y + (1 - targetRect.origin.y - targetRect.height)
        pointRect.size.width *= originalImageRect.size.width
        pointRect.size.height *= originalImageRect.size.height
        
        return pointRect
    }
    
    public func determineScale (cgImage: CGImage, imageViewFrame: CGRect) -> CGRect {
        let originalWidth = CGFloat(cgImage.width)
        let originalHeigth = CGFloat(cgImage.height)
        
        let imageFrame = imageViewFrame
        let widthRatio = originalWidth / imageFrame.width
        let heigthRatio = originalHeigth / imageFrame.height
        
        let scaleRatio = max(widthRatio, heigthRatio)
        
        let scaledImageWidth = originalWidth / scaleRatio
        let scaledImageHeigth = originalHeigth / scaleRatio
        
        let scaledImageX = (imageFrame.width - scaledImageWidth) / 2
        let scaledImageY = (imageFrame.height - scaledImageHeigth) / 2
        
        return CGRect(x: scaledImageX, y: scaledImageY, width: scaledImageWidth, height: scaledImageHeigth)
    }
    
}

extension CGImagePropertyOrientation {
    
    init(_ orientation: UIImage.Orientation) {
        
        switch orientation {
        case .up: self = .up
        case .upMirrored: self = .upMirrored
        case .down: self = .down
        case .downMirrored: self = .downMirrored
        case .right: self = .right
        case .rightMirrored: self = .rightMirrored
        default: self = .up
        }
    }
}

let connectionVideo = videoDataOutput.connection(with: AVMediaType.video)
connectionVideo?.videoOrientation = AVCaptureVideoOrientation.portrait

["en-US", "fr-FR", "it-IT", "de-DE", "es-ES", "pt-BR", "zh-Hans", "zh-Hant"]

["en-US", "fr-FR", "it-IT", "de-DE", "es-ES", "pt-BR"]

["en-US"]

import cv2
import os
import numpy as np
import PIL

#abspath = "/Users/johannpally/Documents/GitHub/HydraBot/vis_processing/hydra_sample_imgs/00049.jpg"
#note we are in the vis_processing folder already
#PIL.Image.open(path)

path = os.getcwd() + "/hydra_sample_imgs/00054.jpg"
img = cv2.imread(path)
c_img = cv2.imread(path)

#==============GEOMETRY MASKS===================
# start result mask with circle mask

ww, hh = img.shape[:2]
r = 173
xc = hh // 2
yc = ww // 2
cv2.circle(c_img, (xc - 10, yc + 2), r, (255, 255, 255), -1)
hsv_cir = cv2.cvtColor(c_img, cv2.COLOR_BGR2HSV)

l_w = np.array([0,0,0])
h_w = np.array([0,0,255])
result_mask = cv2.inRange(hsv_cir, l_w, h_w)

#===============COLOR MASKS====================
hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

#(hMin = 7 , sMin = 66, vMin = 124), (hMax = 19 , sMax = 255, vMax = 237)
# Threshold of orange in HSV space output from the HSV picker tool
l_orange = np.array([7, 66, 125])
h_orange = np.array([19, 255, 240])
orange_mask = cv2.inRange(hsv_img, l_orange, h_orange)
orange_res = cv2.bitwise_and(img, img, mask = orange_mask)

#===============COMBINE MASKS====================
for i in range(len(result_mask)):
    for j in range(len(result_mask[i])):
        if result_mask[i][j] == 255 & orange_mask[i][j] == 255:
            result_mask[i][j] = 255
        else:
            result_mask[i][j] = 0

c_o_res = cv2.bitwise_and(img, img, mask=result_mask)

# We have to use gray image (1 Channel) to use cv2.findContours
gray = cv2.cvtColor(c_o_res, cv2.COLOR_RGB2GRAY)

contours, _ = cv2.findContours(gray, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

minAreaSize = 150
for contour in contours:
    if cv2.contourArea(contour) > minAreaSize:

        # -------- UPDATE 1 CODE --------
        # Rectangle Bounding box Drawing Option
        # rect = cv2.boundingRect(contour)
        # x, y, w, h = rect
        # cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
        
        # FINDING CONTOURS CENTERS
        M = cv2.moments(contour)
        cX = int(M["m10"] / M["m00"])
        cY = int(M["m01"] / M["m00"])
        # DRAW CENTERS
        cv2.circle(img, (cX, cY), radius=0, color=(255, 0, 255), thickness=5)
        # -------- END OF UPDATE 1 CODE --------

        # DRAW
        cv2.drawContours(img, contour, -1, (0, 255, 0), 1)


cv2.imshow('FinallyResult', img)

cv2.imshow('res', c_o_res)
cv2.waitKey(0)
cv2.destroyAllWindows()

// example function which fills a buffer with image data

#include 

__declspec(dllexport) int capture(uint16_t * buffer) 
{
  int width,height;
  width = 2500;
  height = 3052;


  // check pointer
  if(!buffer){
    return -1;
  }

  // fill buffer with some data for testing

  // this should be a greyscale gradient 
  // black in the top left corner
  // to white in the bottom left

  for(int row = 0; row