Find OpenCV Projects on Upwork with Vollna

Summary

I’m looking for an experienced AI/NLP engineer to help build a lightweight backend service that evaluates AI-generated content for safety, quality, and compliance risks.

This is a small MVP focused on clean architecture, reliable model integration, and clear scoring logic.

Project

Build a FastAPI backend service that analyzes AI-generated text and provides evaluation scores for:

• Toxic or unsafe content
• Personal data exposure (PII detection)
• Bias detection
• Hallucination / factual risk indicators
• Overall quality & safety rating (0–100)

Deliverables

• Well-structured FastAPI backend (async preferred)
• 4–6 REST evaluation endpoints
• Integration of HuggingFace NLP models
• Text classification + entity detection pipelines
• Scoring logic with structured JSON outputs
• Evaluation logging (SQLite or PostgreSQL)
• Clear setup documentation
• Production-quality, modular code

Ideal Skills

• Strong Python experience
• FastAPI development
• HuggingFace Transformers
• NLP classification pipelines
• Experience working with LLM APIs (OpenAI, Claude, Mistral, etc.)
• PyTorch or TensorFlow
• Model inference optimization
• Clean coding practices
• Good communication

Nice to Have

• Experience with AI safety evaluation
• Prompt engineering knowledge
• Experience with OCR or document processing
• OpenCV or computer vision basics
• Experience building AI microservices

Project Details

Scope: Small MVP (backend only, no frontend)
Budget: $700 – $1200
Timeline: 1–2 weeks

If you have built similar AI evaluation systems or NLP backends, please share examples.

I communicate clearly, respect developers, and prefer long-term working relationships if the collaboration goes well.

Project Details (Upwork Settings)

Less than 30 hrs/week
Hourly
Less than 1 month
Duration
Intermediate level
Project Type: One-time project

Custom Photo Kiosk / Photo Booth Software Development

Project Description:
I am looking for a developer to create custom software for a photo kiosk that will be used at conventions and live events. The goal is to build a simple, reliable program that allows customers to take a photo, place it onto a themed background, print the photo, and receive a QR code to download a digital copy.

This will run on a kiosk style setup with a touchscreen monitor, camera, and printer. The software needs to be fast, stable, and simple so that customers can walk up and use it quickly at busy events.

Important:
To show that you read the project description, please start your proposal with the words “Photo Kiosk Developer.” Proposals that do not include this will be ignored.

Core Features Required

1. Touchscreen Photo Capture

Large “Take Photo” button

Optional countdown timer

Photo captured from connected camera or webcam

Simple and clean kiosk interface

2. Face Detection / Auto Framing

Automatically detect the person’s face

Center and scale the photo to fit the template

Crop and position the subject onto the background automatically

3. Background Selection

Customer can choose from multiple preset backgrounds

Backgrounds will be themed (anime, fantasy, etc.)

Captured photo is placed onto the chosen background

4. Photo Output

Final composed image is sent to a connected photo printer

Support for print templates (portrait, ID badge style, etc.)

5. QR Code for Digital Download

System uploads the photo to a website or cloud storage

Generates a unique QR code for that photo

QR code prints on a small receipt or printed alongside the photo

Customer scans the QR code to download their photo later

6. Admin Settings Panel

Upload or change background images

Change print templates

Basic camera and printer settings

Software Requirements

Must run on Windows

Full screen kiosk mode

Touchscreen friendly interface

Reliable for high-volume use at live events

Preferred Technologies (Flexible)

Python

C#

Electron / Node.js

OpenCV (for face detection)

Any stable framework suitable for kiosk applications

Hardware Setup
The system will run on:

Windows computer

Touchscreen monitor

Camera or DSLR

Photo printer

Optional QR receipt printer

Bonus Features (Optional but a plus)

Green screen background removal

Automatic gallery creation for events

Email or text delivery of photos

Animated countdown screen before photo capture

Required Experience

Please only apply if you have experience with at least one of the following:

Photo booth software

Camera integration

Image processing

QR code generation

Printing integration

When applying, please include:

One example of a similar project you have built

What language or framework you would build this in

Estimated timeline for completion

Application Requirement

Please briefly explain how you would approach building this system, including:

How face detection would work

How the captured image would be placed onto the background

How the QR code and digital download system would function

You do not need to provide a full technical plan, but I want to make sure applicants understand the scope of the project.

Real World Use Case

This software will be used at convention booths and live events where customers walk up and take themed photos. The system needs to be fast, reliable, and simple for both customers and booth staff to use.

Typical workflow will look like this:

Customer walks up to the kiosk

Customer taps “Start” or “Take Photo”

Camera captures the photo

Software detects the face and places the photo onto a selected themed background

Final image is generated automatically

Photo is sent to the printer

A QR code is generated for the digital download of the image

QR code prints on a receipt or alongside the photo

Customer scans the QR code to download their photo

The entire process should ideally take under 20 seconds per customer so the booth can handle a high number of people.

The interface should be very simple and clean, since many customers will be using the kiosk for the first time.

Goal of the Project

The goal is to create a smooth kiosk experience where customers can walk up, take a themed photo, receive a printed copy, and download a digital version via QR code.

This system will be used regularly at events, so reliability and speed are extremely important.

Skills: Python, C# Programming, Software Development, Image Processing, OpenCV, Background Removal

## AI Developer Needed: Face Recognition + Subtitle Tagging for Movies (Python)

### Project Overview

We are building a system that automatically identifies actors appearing in a movie and tags them in subtitle files.

The goal is to process a full-length movie (2–3 hours) and output a subtitle CSV enriched with actor tags (and optionally emotions).

---

### Core Requirements

#### 1. Face Detection & Recognition

* Detect faces from video frames using **open-source libraries only**

* Examples: InsightFace, FaceNet, DeepFace, OpenCV, etc.
* Match detected faces with a provided **Actors Faces Library** (images per actor)
* Identify **prominent actors per timestamp**

---

#### 2. Subtitle Integration

* Input:

* Movie video file (MP4/MKV)
* Subtitle file (CSV or SRT converted to CSV)
* Output:

* Same subtitle file with an added column:

```text
hashtags → #actor1 #actor2
```
* Tag actors appearing during each subtitle time window

---

#### 3. Performance Constraints (Important)

* Must handle **full movie (up to 3 hours)**
* Application memory usage:

* **Maximum: 100 GB RAM**
* Efficient implementations preferred (lower RAM = better ranking)
* Should not crash on long videos

---

### Bonus (Extra Payout)

* Emotion detection per face:

* Example output:

```text
#actor1:happy #actor2:angry
```
* Higher accuracy in:

* Face recognition
* Multi-face scenes
* Faster processing time

---

### Provided Data (Zip File)

Participants will receive:

* Movie file
* Subtitle CSV file
* Actors Faces Library (folder per actor with images)

---

### Expected Deliverables

* Python script (or equivalent runnable code)
* Instructions to run (README)
* Output sample CSV
* Requirements file (pip/conda)

---

### Evaluation Criteria

| Criteria | Weight |
| ------------------------------- | ------ |
| Accuracy (actor identification)
| Memory efficiency
| Speed
| Code quality & clarity
| Bonus (emotion detection)

---

### Technical Expectations

* Should work on CPU (GPU optional but not required)
* Must use **open-source models only**
* No paid APIs

---

### Important Notes

* The solution should be robust to:

* Different lighting conditions
* Multiple faces in frame
* Partial face visibility
* Avoid loading entire video into memory
* Streaming / sequential processing preferred

---

### Winner Selection

The best solution will be selected based on:

* Accuracy
* Stability on long videos
* Resource usage
* Code usability

---

### Budget & Rewards

* Base reward for working solution
* Additional bonus for:

* Emotion detection
* High accuracy
* Optimized performance

---

### Ideal Candidate

* Experience with:

* Computer Vision / Face Recognition
* Python (OpenCV, PyTorch, ONNX, etc.)
* Prior work in:

* Video processing
* ML pipelines

---

If you have built similar systems or can optimize for performance at scale, this is a perfect challenge.

Looking forward to your solutions!


Please check the attached google drive for reference files. As the movie file is greater than 25MB (approved limit of freelancer, uploading drive link)


https://drive.google.com/drive/folders/1Od45MgSYJe6N9TGBnzBND158ZONVSIEr?usp=sharing



i have uploaded lot of actor faces into face library, but I want python or any file to narrow down required actors tagged in CSV file.


Additional 30$ payout if it recognises emotions of tagged actors from the subtitle.

## AI Developer Needed: Face Recognition + Subtitle Tagging for Movies (Python)

### Project Overview

We are building a system that automatically identifies actors appearing in a movie and tags them in subtitle files.

The goal is to process a full-length movie (2–3 hours) and output a subtitle CSV enriched with actor tags (and optionally emotions).

---

### Core Requirements

#### 1. Face Detection & Recognition

* Detect faces from video frames using **open-source libraries only**

* Examples: InsightFace, FaceNet, DeepFace, OpenCV, etc.
* Match detected faces with a provided **Actors Faces Library** (images per actor)
* Identify **prominent actors per timestamp**

---

#### 2. Subtitle Integration

* Input:

* Movie video file (MP4/MKV)
* Subtitle file (CSV or SRT converted to CSV)
* Output:

* Same subtitle file with an added column:

```text
hashtags → #actor1 #actor2
```
* Tag actors appearing during each subtitle time window

---

#### 3. Performance Constraints (Important)

* Must handle **full movie (up to 3 hours)**
* Application memory usage:

* **Maximum: 100 GB RAM**
* Efficient implementations preferred (lower RAM = better ranking)
* Should not crash on long videos

---

### Bonus (Extra Payout)

* Emotion detection per face:

* Example output:

```text
#actor1:happy #actor2:angry
```
* Higher accuracy in:

* Face recognition
* Multi-face scenes
* Faster processing time

---

### Provided Data (Zip File)

Participants will receive:

* Movie file
* Subtitle CSV file
* Actors Faces Library (folder per actor with images)

---

### Expected Deliverables

* Python script (or equivalent runnable code)
* Instructions to run (README)
* Output sample CSV
* Requirements file (pip/conda)

---

### Evaluation Criteria

| Criteria | Weight |
| ------------------------------- | ------ |
| Accuracy (actor identification)
| Memory efficiency
| Speed
| Code quality & clarity
| Bonus (emotion detection)

---

### Technical Expectations

* Should work on CPU (GPU optional but not required)
* Must use **open-source models only**
* No paid APIs

---

### Important Notes

* The solution should be robust to:

* Different lighting conditions
* Multiple faces in frame
* Partial face visibility
* Avoid loading entire video into memory
* Streaming / sequential processing preferred

---

### Winner Selection

The best solution will be selected based on:

* Accuracy
* Stability on long videos
* Resource usage
* Code usability

---

### Budget & Rewards

* Base reward for working solution
* Additional bonus for:

* Emotion detection
* High accuracy
* Optimized performance

---

### Ideal Candidate

* Experience with:

* Computer Vision / Face Recognition
* Python (OpenCV, PyTorch, ONNX, etc.)
* Prior work in:

* Video processing
* ML pipelines

---

If you have built similar systems or can optimize for performance at scale, this is a perfect challenge.

Looking forward to your solutions!


Please check the attached google drive for reference files. As the movie file is greater than 25MB (approved limit of freelancer, uploading drive link)


https://drive.google.com/drive/folders/1Od45MgSYJe6N9TGBnzBND158ZONVSIEr?usp=sharing



i have uploaded lot of actor faces into face library, but I want python or any file to narrow down required actors tagged in CSV file.


Additional 30$ payout if it recognises emotions of tagged actors from the subtitle.

Skills: PHP, Python, Data Processing, Software Architecture, C++ Programming, Face Recognition, OpenCV, Video Processing, Computer Vision, Deep Learning

Hi [Name],

I’m currently scaling a whisky e-commerce and prize draw platform (Highland Vault) and I’d like to bring you in to help with a few key areas.

The role will involve:
• Supporting with website updates (WooCommerce / future Node + React transition)
• Helping build or connect a central dashboard (WooCommerce, Meta Ads, ActiveCampaign, PostHog via APIs)
• Ongoing improvements to conversion, tracking, and performance
• Assisting with automation (email flows, user journeys, basic integrations)

What I need is someone reliable who understands:
• E-commerce (WooCommerce ideally)
• APIs and data dashboards (Looker Studio, Metabase or similar)
• Basic marketing/data tracking (Meta Ads, email platforms)
• Someone who can think commercially, not just technically

This isn’t a one-off task — I’m looking for someone to work with long-term as we scale daily draws and push towards £10k+ weekly revenue.

Let me know your availability and how you’d approach this.

Thanks,
Deepak

I have a custom-built X-ray system dedicated to mango grading. The control electronics expose a Python API that streams 16-bit radiographic frames at conveyor speed and can fire an air-jet gate on command. What I need next is a production-ready program that

• ingests each frame in real time,
• detects spongy, internally damaged or otherwise bad fruit with high precision, and
• sends the gate signal fast enough to remove the defect before the next fruit arrives.

You are free to design the detection pipeline—classical CV with OpenCV or a small CNN in TensorFlow/PyTorch—as long as it runs on the on-board GPU (NVIDIA Jetson Xavier) and meets the timing budget of 60 ms per fruit. I will supply a labelled image set of good vs. spongy mangoes for training and a live video feed for validation.

Deliverables
1. Well-commented Python source code ready to run on Ubuntu 20.04 (Jetson).
2. Model weights and training notebook (if deep learning is chosen).
3. Integration script that toggles the machine’s GPIO gate through the existing SDK.
4. A brief README explaining installation, calibration steps, and how to extend the defect classes in the future.

Acceptance criteria
• ≥95 % recall on the supplied test set, ≤2 % false-positive rate.
• End-to-end latency from frame capture to gate signal ≤60 ms, verified with my high-speed logger.
• Code passes pylint with a score ≥8.0 and runs inside a Docker container I provide.

Once the above criteria are hit, I will run a 4-hour continuous line test; clearing that test triggers final sign-off and payment.

Skills: Python, Electronics, Software Architecture, Arduino, Image Processing, OpenCV, Computer Vision, Deep Learning

A POC is required for an AI video analytics system for factories that runs on an edge device and processes live camera feeds. The POC will perform real-time quality control (defect detection) and inventory counting / tracking.
We are seeking an experienced freelancer to develop a Proof of Concept (POC) for a single assembly line. We'll share details, once we are agreed to work.

Core Components/Flow: Custom AI edge device (using off-the-shelf hardware NVIDIA Jetson Orin Nano) for on-device inference. Take video feed from existing cameras (RTSP/ ONVIF/ IP cameras 1080p), process video locally and build output (alerts, API call based notifications).

Real-time computer vision + video analytics to identify:
Defects like missing components, scratches or misalignments in assembly processes. Output bounding boxes, confidence scores, snapshot capture when defects are detected, defect logging with timestamps and trigger immediate alerts via I/O & API.
Raw material estimation (e.g., bin/pallet levels), integrate user-input initial quantities, compute remaining stock, log count and per-cycle usage, for low-stock generate I/O & API alert.

Preferred Tech: Python, OpenCV, PyTorch / TensorFlow, YOLO models, NVIDIA TensorRT / DeepStream, Web based dashboard (Blazor Server)

Scope Exclusions for POC: Full centralized management platform (Video Ingestion, AI Inference Engine, Event Detection, Alert Engine, Local Database, External APIs integration client) , multi-line scalability, physical camera installation, scalable to advanced integrations (e.g. ERP). Keep processing local to edge device + basic web based dashboard for testing (Blazor Server).

Deployment: Turnkey setup for one assembly line/zone, with auto-discovery. Initially, you handle fine-tuning pipeline basics. We'll provide initial training data.

Deliverables:
Functional POC edge device with pre-installed software and base models.
Basic web dashboard for monitoring/alerts (e.g., cycle time charts, defect logs, inventory metrics).
Documentation: Setup guide, code repo (GitHub), test results.
Support for initial on-site deployment guidance.

When Applying Please Include:
- Proven experience in AI edge computing, real-time video processing, computer vision (CV) and video analytics (e.g., OpenCV, YOLO or similar models).
Hands-on with NVIDIA Jetson, Familiarity with industrial applications (quality control, safety, inventory in factories)., Strong Python skills.
- Share Portfolio/experience with similar projects (e.g., real-time AI on edge devices).
- Available for regular updates (weekly calls, via Zoom/Slack).
- Documentation: Setup guide, code repo (GitHub), test results.
- Estimated timeline and budget for this project.

• Describe your recent experience with similar projects

I need a lightweight, reliable identity-verification flow added to my existing web application. The user must be prompted to upload a clear photo of a government-issued ID; once submitted, the image should be checked for authenticity and the result (pass, fail, or manual review) returned to my database in real time.

Please wire it to the UI I already have in place and keep the interaction smooth on both desktop and mobile. You are free to call an external service such as Onfido, Veriff, or a custom OpenCV/Python solution, as long as you reach comparable accuracy and provide full API documentation.

Deliverables
• Functional photo-ID upload and verification endpoint
• Front-end hook that triggers the flow and displays status updates
• Callback that stores the verification outcome in my PostgreSQL table
• README or inline notes covering setup, API keys, and test scenarios

Acceptance criteria
– A test ID passes automatically; a blurred image is flagged for manual review.
– Response time for checks stays under three seconds in staging.

I’ll grant access to a Git branch and staging server so you can integrate directly. Let me know if you need anything else before we begin.

Skills: JavaScript, Python, Django, PostgreSQL, Image Processing, OpenCV, Web Development, API, Web Application

We are looking for an experienced developer to work on two interconnected projects:
________________________________________
Project A – Distributed Infrastructure and Remote Execution
The goal is to create a system of lightweight micro-VMs that can connect to a central server and execute complex tasks in external environments, ensuring security, isolation, and scalability.
Key Functions:
• Create and manage micro-VMs or ultra-light virtualized environments.
• Configure secure networks between VMs and the central server (WireGuard, Tailscale).
• Manage task queues, checkpoints, and logs.
• Execute code in remote environments like Google Colab through secure tunnels.
• Automate monitoring of VM status and resource availability.
Recommended open-source projects to use:
• Nomad
• Ray
• Docker
• Playwright / Browser Use
• n8n (optional)
Freelancer requirements for Project A:
• Experience in distributed systems and microservices.
• Advanced knowledge of Docker, secure networking, and lightweight VMs.
• Experience integrating remote automation systems.
• Ability to implement centralized monitoring and logging for VMs.
________________________________________
Project B – Autonomous Software Audit and Improvement System with AI
The goal is to build a platform capable of analyzing full software projects, executing applications in test environments, detecting issues, and suggesting or applying corrections automatically.
Key Functions:
• Analysis of project documentation and source code.
• Execution of projects in a sandbox and real-time behavior analysis.
• Automatic generation of dashboards, backend, technical documentation, and workflows.
• Integration with ConfiUI for autonomous workflow creation and validation.
Recommended open-source projects to use:
• Ruflo
• OpenDevin
• CrewAI
• OpenPencil
• Browser Use / Playwright
• Screenshot-to-Code
• OpenCV
• LlamaIndex + Qdrant
• Ollama
• n8n
Freelancer requirements for Project B:
• Experience with AI agents, code analysis, and software automation.
• Knowledge of automatic dashboard and backend generation.
• Experience in visual workflow automation (ConfiUI or similar).
• Ability to integrate multiple open-source tools and coordinate AI agents.
• Experience in automated testing, sandboxing, and secure software execution.
________________________________________
How to Apply:
Send your proposal including:
• Relevant experience with similar projects.
• Examples of projects involving autonomous systems, automation, or AI applied to software development.
• A brief description of how you would approach the initial audit and development steps for both projects.

• Describe your recent experience with similar projects
• Please list any certifications related to this project
• Include a link to your GitHub profile and/or website
• What frameworks have you worked with?
• Describe your approach to testing and improving QA

I need a reusable C# user-control for my UNO Platform WebAssembly app that can talk to any connected webcam, detect faces in real-time, and, once a face reaches a minimum pixel size that I specify, verify liveness before doing anything else. As soon as the face passes that liveness check, the control should raise an event returning the cropped face as a PNG byte array or stream.

A configurable switch in the control will then decide whether that same face is pushed into a one-to-many search against a SQL Server-backed gallery. All database work can happen through a lightweight Web API you expose—keep the WASM side clean so the control remains fully client-side except for the search call.

Key expectations
• Runs inside UNO WebAssembly with no platform-specific tweaks needed.
• Accepts any camera resolution—HD, Full HD, 4K, or whatever the user plugs in.
• Minimum face size is set in pixels (width and height separately).
• Liveness technique is up to you; just document it clearly and keep false positives low.
• Event payload includes the PNG, bounding-box coords, and a simple quality score.
• Optional search flag plus API endpoint/DTOs for the SQL Server lookup.
• All third-party libraries (OpenCV, Dlib, Azure Face API, ML.NET, etc.) must be clearly referenced and licensed for commercial use.
utilize FacePlugins .NET SDK

Deliverables
1. Source code of the UNO user-control with clear comments.
2. A short README explaining setup, public properties, and the liveness strategy.
3. Sample WebAssembly page demonstrating capture, event handling, and database search toggle.
4. SQL schema + minimal seed data for the one-to-many gallery.
5. Quick test script or unit tests proving face size filtering and liveness flow.

If anything is unclear let me know early so we can lock requirements before you dive into code.

Skills: .NET, C# Programming, Software Architecture, Machine Learning (ML), C++ Programming, Face Recognition, Web API, Computer Vision

We are developing a computer vision prototype to detect banknotes in real time using a camera.
The system must identify banknotes and classify their denomination.

The goal of this first prototype is simple:
detect banknotes from a live camera feed and output the detected value.

Preferred technologies: Python, OpenCV, YOLO or similar object detection models.

This is the first stage of a larger project related to retail cash monitoring systems.

• Have you previously worked on object detection projects using YOLO or similar models?
• Can you provide an example of a computer vision project you built involving real-time video detection?
• What approach would you use to detect and classify banknotes from a camera feed?

I already have a complete .vrm avatar; what it lacks is my real-world expression. Your task is to build a Unity scene that takes a live webcam feed, tracks only my eyes and mouth, and projects them onto the model in real time so the character blinks, looks and speaks with my actual features.

The workflow I have in mind is straightforward:
1. Unity (latest LTS) loads the .vrm file through UniVRM.
2. A webcam stream is processed on the fly—OpenCV, MediaPipe, or any other lightweight library you prefer—to isolate eye and mouth regions.
3. Those regions are then composited onto the avatar’s existing eye and mouth meshes or UVs with minimal latency, keeping head pose from the original rig intact.

Deliverables
• A self-contained Unity project or package with clearly commented C# scripts.
• A short calibration routine so I can line up the tracking once and save the offsets.
• Simple UI toggle to start/stop the overlay and switch back to the default textures.
• Quick README or screen-share video that shows setup, play-mode demo, and how to replace the webcam if I upgrade hardware later.

Acceptance criteria
• Overlay stays locked during normal talking and blinking, under 70 ms end-to-end latency.
• Works on a standard 1080p webcam without additional hardware.
• No noticeable artifacts when the avatar turns ±30° on the Y-axis.

If you have prior VTuber or AR face-tracking examples, feel free to share when you bid so I can gauge fit. I’m ready to test builds as soon as you have a prototype.

Skills: C# Programming, C++ Programming, Unity 3D, Game Development, Augmented Reality, OpenCV, Computer Vision, Unity

We are Moontrail Animation Studios, an AI-native animation studio focused on next-generation kids animation.

We are looking for a senior technical hire to help us prototype a stealth product at the intersection of:

computer vision

machine learning

video understanding

3D scene reconstruction

creative editing workflows

This is a founding-stage role for someone who can help shape the technical direction of a new platform, not just execute isolated development tasks.

The product involves transforming short-form video into a more structured, editable, and production-ready format for creative workflows.

What we need

We are looking for someone with strong experience in:

computer vision

video processing

segmentation and tracking

depth estimation

camera and motion estimation

3D scene understanding

PyTorch / OpenCV / Python

production-grade ML systems

Strong plus if you have experience with

NeRF

Gaussian splatting

SLAM / SfM

differentiable rendering

3D graphics pipelines

Blender / Unreal / Unity

generative video workflows

media-tech / VFX / creative tools

Who this role is for

This is for a senior engineer, ideally with 7+ years of relevant experience, who can work independently, evaluate technical feasibility, build prototypes, and help define the MVP and future architecture.

Deliverables in the first phase

technical feasibility assessment

prototype architecture

initial proof of concept for video analysis / scene reconstruction

recommendations for MVP scope

input on future team structure

To apply, please include

relevant projects you have worked on

your role in those projects

links to GitHub, demos, papers, or case studies

a short note on your experience with video + computer vision + 3D systems

We are looking for someone exceptional with deep technical judgment. Confidentiality is required.

II'm looking to find detection in CEOs using narcissistic language. I already have the repository that I'd like to use which is a free one on Github. I just need some help.

Python/OpenCV Developer for Mobile Game Automation (macOS)

I am looking for a Python developer with experience in computer vision and automation to build a bot for a mobile mini-game.

The game runs on an iPhone that is mirrored to my Mac using iPhone Mirroring (macOS Sequoia). The bot would run on macOS and interact with the mirrored game window by detecting visual elements and triggering clicks.

There are a few mini-games in the app. Each game lasts about 30–60 seconds.

Example mini-games:

Timing Game:
A meter moves back and forth with a white indicator. When the indicator reaches a colored zone (orange or purple), the bot should click at the correct moment. The closer the click is to the center of the zone, the higher the score.

Mole Game:
Moles appear on screen and need to be tapped quickly. The bot should detect moles and click them while ignoring non-mole objects.

Requirements:

Python

Computer vision (OpenCV or similar)

Screen capture / image detection (mss, pyautogui, or similar)

Automated clicking on macOS

Script runs locally on my Mac (no cloud/server)

Preferred:

Experience building screen-based automation or game bots

Ability to add slight randomness to click timing and position so actions appear natural

Familiarity with macOS and iPhone Mirroring latency considerations

Deliverables:

Working Python script

Instructions for running the script on macOS

Configurable settings (click timing, randomness, etc.) so I can adjust without modifying code

Debug overlay or logging (optional but helpful)

I can provide screen recordings and screenshots of the mini-games to help with development.

Budget: Open to proposals — please include your estimated hours and hourly rate or fixed price

Skills: Python, Software Architecture, Objective C, C++ Programming, Debugging, Game Development, OpenCV, Computer Vision, Automation, Bot Development

Project Overview

We are a UK-based industrial distributor (Bearings & Drives Ltd) with approximately 50,000 SKUs across engineering and MRO products. We are replacing our legacy ERP system (Orderwise) with a modern architecture based on ERPNext + WooCommerce.

We are looking for an experienced ERPNext / Frappe developer who can set up the technical foundation for this system.

Scope of Work

We require a freelancer to implement the following:

Server 1 – ERP System

Install and configure ERPNext in production

Configure all required services (MariaDB, Redis, Bench, Nginx)

Set up domain/subdomain (e.g. erp.domain.com)

Configure backups and security

Basic company configuration within ERPNext

Server 2 – Website

Install WordPress + WooCommerce

Configure WooCommerce ready for future integration with ERPNext

Configure domain (e.g. www.domain.com)

Ensure the system is scalable for a large catalogue

Integration Preparation

The systems must be prepared for future integration so that:

Products are managed in ERPNext

Inventory syncs from ERPNext to WooCommerce

Orders sync from WooCommerce to ERPNext

Experience with ERPNext API integrations is highly desirable.

Ideal Freelancer

We are looking for someone with experience in:

ERPNext / Frappe framework

Linux server setup (Ubuntu / VPS)

WooCommerce

API integrations

inventory or ERP implementations

Goal

Deliver a clean, stable foundation for a modern ERP + ecommerce platform that will support a large industrial product catalogue and warehouse operations.

Summary
Deploy a prototype edge-AI warehouse safety system using NVIDIA Jetson Orin Nano and YOLO to detect PPE breaches, proximity risks, and zone violations, with uploads to AWS S3 and Supabase.

Responsibilities:
• Configure Jetson Orin Nano (JetPack, multi-camera input, ~15–20 FPS inference)
• Implement and optimise YOLO detection pipeline across 3 camera streams
• Upload detection clips to S3 and log metadata to Supabase
• Build simple deployment scripts for multi-site rollout
• Provide setup, troubleshooting, and handover documentation

Tech:
Python, OpenCV, YOLO, NVIDIA Jetson, AWS S3, Supabase
Nice to have: Docker, TensorRT/ONNX, RTSP/IP cameras, React context

Deliverables:
• Working Jetson safety detection prototype
• Automated S3 + Supabase data pipeline
• Replicable deployment scripts (10+ sites)
• Documentation and 2–4 hour handover session

This has been posted both hourly and as a complete piece of work.

Deploy a prototype edge-AI warehouse safety system using NVIDIA Jetson Orin Nano and YOLO to detect PPE breaches, proximity risks, and zone violations, with uploads to AWS S3 and Supabase.

Responsibilities:
• Configure Jetson Orin Nano (JetPack, multi-camera input, ~15–20 FPS inference)
• Implement and optimise YOLO detection pipeline across 3 camera streams
• Upload detection clips to S3 and log metadata to Supabase
• Build simple deployment scripts for multi-site rollout
• Provide setup, troubleshooting, and handover documentation

Tech:
Python, OpenCV, YOLO, NVIDIA Jetson, AWS S3, Supabase
Nice to have: Docker, TensorRT/ONNX, RTSP/IP cameras, React context

Deliverables:
• Working Jetson safety detection prototype
• Automated S3 + Supabase data pipeline
• Replicable deployment scripts (10+ sites)
• Documentation and 2–4 hour handover session

Description:
Need a developer to build a Python system that controls multiple Android devices via ADB. The script should execute specific touch/navigation sequences across devices, handle device connections/disconnections, and log outcomes.

Requirements:

Strong Python

Deep ADB/Android debugging experience

Experience with device orchestration (multiple devices)

Ability to simulate taps/swipes reliably

Error handling & device recovery

Nice to have:

UI Automator experience

OpenCV for screen detection

Budget: Open – provide estimate.

To Apply: Briefly describe your Android automation experience and similar projects.

Computer Vision Engineer (TensorFlow Preferred) — 6-Month Contract (Lahore or Remote)

Title: Computer Vision Engineer (TensorFlow/Keras) | Deep Learning + Production ML | 6-Month Contract
Project Length: 6 months
Hours: 20–40 hrs/week (flexible based on fit)
Location: Lahore (preferred) or Remote
Start: Immediately
Industry: Healthcare / Medical Imaging (computer vision)

Description

We are looking for an experienced Computer Vision Engineer for a 6-month contract to help us build and productionize modern deep learning models for real-world imaging workflows. This role requires strong hands-on TensorFlow (TF 2.x / Keras) experience and solid software engineering best practices (clean architecture, testing, Git discipline, production readiness).

What You’ll Do

Develop and improve computer vision models for:

Classification, detection, and segmentation

Implement and fine-tune modern architectures:

EfficientNet, ConvNeXt, ViT/Swin

Build image quality assessment pipelines (blur, illumination/exposure, artifacts, field-of-view, contrast/sharpness) and integrate into ingestion flows.

Apply advanced techniques:

Transfer learning, fine-tuning, robust augmentation

Self-supervised learning (MAE/DINO/SimCLR-style) when applicable

Domain adaptation/generalization for camera/device variability

Uncertainty estimation & calibration for safe thresholds

Create strong evaluation and reporting:

F1, AUROC, sensitivity/specificity, error analysis, ablations

Productionize models:

Packaging and deployment with TensorFlow Serving / TFLite / TF-TRT (as needed)

Optimize performance (latency/throughput/cost), reliability, and monitoring signals

Collaborate with product + engineering to ship tested, maintainable deliverables.

Required Skills

TensorFlow 2.x / Keras (preferred) + strong Python

Proven experience in at least one:

Segmentation (U-Net variants, DeepLab, Mask R-CNN)

Detection (YOLO-family, RetinaNet/Faster R-CNN, DETR-style)

Classification (multi-class/multi-label, multi-task)

Strong understanding of training best practices:

Losses, augmentation, imbalance handling, validation strategy

Strong software engineering habits:

Clean code, modular design, code reviews

Unit/integration testing

Git workflows, documentation, reproducibility

Nice to Have

TensorFlow deployment: TF Serving, TFLite, TF-TRT

MLOps & cloud: experiment tracking, model registry, AWS

Medical imaging familiarity (bonus): DICOM/DICOMWeb, clinical workflows

Explainability methods (Grad-CAM/saliency/attention maps)

Deliverables / Outcomes (Examples)

Baseline + improved model(s) with documented training/evaluation

Image quality gating module integrated into pipeline

Exported/served model (TF Serving / TFLite) with performance benchmarks

Reproducible training scripts + evaluation reports + tests

How to Apply (Please Include)

Resume / LinkedIn

GitHub or portfolio (if available)

A brief note: best TensorFlow CV model you shipped + where it ran (cloud/edge)

Your weekly availability + timezone

Multi-Sensor Fusion & Time-Series Thermal Analysis

We are rapid-prototyping a non-contact, IoT-connected monitoring device. The device uses a single multi-sensor array to track a dynamic subject's 3D spatial position, monitor localized movements, capture audio, and perform real-time, high-precision frequency analysis on specific localized thermal fluctuations.

The primary challenge of this project is applying sub-pixel micro-fluctuation analysis (such as Eulerian Video Magnification) and advanced bandpass filtering to thermal imaging data running entirely on a local hardware stack.

The Hardware Stack
Sensor: Luxonis OAK-T (Integrated RGB, Stereo Depth, and Thermal camera with onboard Myriad X VPU).

Host/Relay: Raspberry Pi 4/5 (or similar SBC) to handle external IoT communications and audio processing.

Audio: Standard USB Omni-directional microphone.

Core Responsibilities & Technical Requirements
We need a Python script/pipeline that successfully executes the following steps in real-time:

1. Sensor Fusion & Dynamic Tracking (DepthAI)

Utilize the OAK-T’s RGB and Depth sensors to detect a specific moving target, track its X/Y/Z spatial coordinates, and monitor general displacement/movement.

Detect specific landmarks/nodes on the target (using standard object tracking or landmark models) and accurately map those exact bounding boxes/ROIs onto the synchronized thermal video stream.

2. Low-Frequency Thermal Analysis

Isolate a specific thermal ROI based on the mapped coordinates.

Track low-frequency cyclical temperature fluctuations (approx. 0.2 Hz – 0.5 Hz) and calculate the cycle rate using peak detection algorithms.

3. High-Frequency Micro-Fluctuation Analysis (The Core Challenge)

Isolate a secondary thermal ROI on the moving target.

Extract the raw radiometric thermal data over time. Apply robust bandpass filters (approx. 0.8 Hz – 3.0 Hz) and FFT or EVM (Eulerian Video Magnification) techniques to isolate and extract a dominant micro-frequency from the thermal noise.

Note: The system must dynamically keep this ROI locked onto the correct part of the target even if the target shifts position.

4. Audio Capture

Integrate a basic continuous audio capture or acoustic anomaly trigger logging via the attached USB microphone.

5. IoT Connectivity (Bluetooth & WiFi)

Configure a BLE GATT server on the host SBC to accept WiFi network credentials from a mobile app.

Format the final processed data streams (Low-Frequency Rate, High-Frequency Rate, 3D Position, Movement Status) and push it via MQTT/HTTP to a cloud dashboard.

Ideal Candidate Profile
Proven experience with the Luxonis DepthAI API and mapping spatial coordinates across different sensor lenses.

Strong background in OpenCV, NumPy, and time-series signal processing (e.g., scipy.signal, FFT, bandpass filtering).

Prior experience with extracting micro-signals from video feeds (like EVM or similar academic frameworks) is highly preferred.

Experience with IoT deployments, BLE provisioning, and MQTT.

Deliverables
Fully commented, clean Python codebase that runs on the target hardware.

Documentation detailing how to install dependencies, run the pipeline, and adjust variables (like filter frequencies or ROI bounding box sizes).

A brief demonstration of the code successfully running and extracting the required frequencies from a test subject.

Budget & Structure: We are hiring on an hourly basis, ideally between $50 - $90/hr depending on experience.

Phase 1 (Feasibility): We will begin with a strict cap of 15 hours/week for the first 2 weeks. Your sole objective in Phase 1 is to run the raw thermal data through your DSP/EVM pipeline to prove that extracting the high-frequency micro-fluctuation (0.8 Hz – 3.0 Hz) is mathematically feasible with our hardware's signal-to-noise ratio.

Phase 2 (Integration): If Phase 1 yields a clean frequency output, we will lift the cap and proceed with integrating the DepthAI tracking, audio, and IoT connectivity.

This project presents an AI-powered facial emotion recognition system designed to analyze human facial expressions from still images and accurately predict emotional states using deep learning techniques.

The system leverages Convolutional Neural Networks (CNNs) to identify and classify facial emotions with high accuracy, providing a confidence score for each prediction.

# Supported Emotion Classes

The model is trained to classify the following emotions:

* Happiness
* Sadness
* Anger
* Surprise
* Fear
* Neutral
* Disgust

# How the System Works

1. Face Detection– Automatically detects faces within the input image.

2. Image Preprocessing – The detected face is processed using:
* Grayscale conversion
* Image resizing
* Pixel normalization

3. Emotion Prediction – The processed image is passed through a trained CNN model to classify the emotion.

4. Confidence Scoring – The system outputs the predicted emotion along with a probability/confidence score.

# Key Features
* The system was designed and implemented by me to analyze still images only, without requiring a camera or live streaming input.
* Automatic face detection within images
* Deep learning-based emotion classification using CNN
* Provides confidence level for each prediction
* Supports batch processing of multiple images
* Clean, modular, and scalable Python implementation

# Potential Applications
* Customer emotion analysis for marketing insights
* User behavior analysis and sentiment research
* Human–Computer Interaction (HCI) systems
* Intelligent image analysis platforms
* AI-powered analytics tools for businesses

# Technologies Used
* Python
* Deep Learning (CNN)
* TensorFlow / Keras or PyTorch
* OpenCV for face detection
* NumPy & data preprocessing tools

Skills: Python, Matlab and Mathematica, Algorithm, Machine Learning (ML), OpenCV, Keras, Deep Learning, Convolutional Neural Network

We are looking for an experienced Python developer to build an AI tool that replaces wall and floor tiles in interior photos.
The tool must:

Accept inputs: room photo + reference tile photo + tile dimensions in cm
Replace wall or floor tiles with the reference tile texture photorealistically
Scale tiles mathematically correct using OpenCV (not estimated by AI)
Support laying patterns: straight, brick bond, herringbone, opus romain
Work on real photos AND 3D architectural renders
Process time max 60 seconds

We have a working prototype using Google Gemini API (gemini-3.1-flash-image-preview) that produces good color and texture results but inconsistent tile scaling. Ideal solution combines Gemini for texture replacement + mathematical OpenCV grid overlay for exact sizing.
Target use cases: bathrooms, living rooms, kitchens, new construction apartments where buyers want to visualize their chosen tile before purchasing.
Deliverable: Working Python script (Google Colab or standalone) or simple web interface. Clean documented code

.Please contact me before placing a bid. I will share example images including the original room photo, reference tile photos, and our best render result so far so you can fully understand the project scope.
Budget: fixed price preferred. Timeline: within 2 weeks.

Selam Alleikum,

We are looking for a senior react native developer, who will support us in developing a mobile application.

Job Title: Senior Computer Vision Engineer: Real-Time Ball Tracking for Tennis & Padel (Mobile)
Job Description:
We are developing SmashIt, a cutting-edge mobile app designed to provide professional-grade analytics for Padel and Tennis players. We are looking for an expert Computer Vision developer to build a high-performance, on-device tracking engine that works seamlessly across both sports.

The app uses a smartphone camera (mounted on a tripod) to analyze live gameplay. The goal is to provide instant feedback on ball trajectory, speed, and court logic.

Core Technical Challenges:
Dual-Sport Object Tracking: Robust tracking of high-speed balls (Tennis & Padel) in diverse lighting and backgrounds.

Complex Game Logic: Identifying line touches (In/Out), net hits, and sport-specific bounces (e.g., glass/wall bounces in Padel vs. standard Tennis court boundaries).

Mobile Optimization: Achieving 30+ FPS on modern iOS/Android devices while maintaining thermal stability (preventing CPU/GPU throttling).

Auto-Calibration: Seamless court detection and perspective correction for different court types and surfaces.

Requirements:
Expertise in Mobile AI: Deep experience with TensorFlow Lite, CoreML, or MediaPipe.

OpenCV & Video Pipelines: Strong background in C++ / Native modules for performance-critical tasks.

Mathematical Foundation: Experience with homography, camera calibration, and 3D-to-2D projection.

Proven Track Record: You must demonstrate previous work in motion analysis, sports tech, or real-time object detection on mobile.

Deliverables:
A cross-platform (C++/Native) library or optimized module for ball and court detection.

High-accuracy logic for "In/Out" and "Bounce Type" detection.

Performance benchmarks for mid-to-high-end mobile devices.

• Motion Blur: How will you handle motion blur for a high-speed ball on a 30fps mobile sensor to ensure accurate tracking?
• Thermal Stability: How do you plan to optimize the CV engine to prevent mobile overheating during a 60-minute match?
• Padel Logic: How would you distinguish between a valid court bounce and a wall/glass touch using a single-camera setup?
• Portfolio: Please share a link to a specific mobile project you’ve built involving real-time motion or sports tracking.

We are seeking a skilled web developer to create an AI-powered rendering website similar to mnml.ai and home-design.ai. The ideal candidate will have experience in developing interactive web applications that leverage artificial intelligence for rendering and design purposes. You will be responsible for the entire development process, from conceptualization to deployment. Strong attention to detail and a passion for innovative technology are essential. If you have a portfolio showcasing similar projects, we'd love to see it.

• Have you built systems using Stable Diffusion or SDXL?
• How would you design the rendering pipeline?
• Which GPU cloud would you recommend?
• How would you optimize inference cost?
• Do you have experience with ControlNet pipelines?

Project Description:
We are looking for a hands-on developer to build an internal tool that automates the creation of Webtoon/Manhwa-style comics for our team of creators. We do not need a complex backend, scalable databases, or a customer-facing frontend; we are looking for a simple and functional dashboard where our employees can generate comic chapters with minimal friction.

The system must connect a workflow between an LLM (for the script) and the Seedream V4/V5 API (for the images), effectively solving the challenge of character consistency throughout the story.

Workflow to Automate (What the tool will do):

Story Input: The employee writes a general idea or premise in the interface.

Script Generation: The tool sends the idea to an uncensored LLM (we strongly recommend using Grok or a similar open-source model) to generate the chapter's script, structuring the panels, image descriptions (prompts), and dialogues.

Graphic Generation (Seedream): The script takes the prompts and automates the calls to the Seedream V4/V5 API.

Critical Requirement: The tool must allow uploading/selecting "Reference Images" of the characters to send them in the Seedream API request to maintain strict visual consistency across all panels. Note: The exact technical approach, development, and logic to solve this challenge are left entirely to the developer's discretion and expertise.

Automatic Assembly: The system stitches the generated images into a vertical format (typical Webtoon scroll) and overlays the text bubbles with the dialogues generated in step 2.

Review Interface: The employee reviews the result in the interface, with the option to regenerate a specific panel if there was a visual error, edit a dialogue, or export the final file ready for publishing.

Technical Requirements:

INDISPENSABLE: Advanced knowledge of Prompt Engineering. The developer must know how to structure, test, and configure master prompts hardcoded within the script, both for the LLM (Grok) and the image engine (Seedream). It is vital that the system knows exactly what parameters to send automatically so the flow works from start to finish, without the end-user needing to know how to write prompts.

Solid experience in Python.

Demonstrable experience integrating generative AI APIs.

Ability to build fast and lightweight internal interfaces (e.g., Streamlit, Gradio, or a very basic web frontend in HTML/JS connected to Flask/FastAPI).

Knowledge of automated image manipulation (using libraries like Pillow or OpenCV) to crop, stitch, and add text to the panels.

Deliverable:
A script/application hosted locally or on a basic server that allows our internal team to open the tool, write an idea, upload their reference images, and download an assembled vertical comic.

AI-Powered Visitor Management System (SaaS) – Full Stack Developer (Python, TypeScript, Next.js, AI)
We are looking for an experienced Full Stack Developer to build a comprehensive AI-powered Visitor Management System (VMS) as a SaaS platform. The goal is to develop a modern, scalable, and secure solution that enables organizations to manage visitor check-ins, track visitor activity, and automate front-desk operations using AI.
This system will be used by businesses, offices, co-working spaces, and organizations that want to streamline visitor management and improve security through automation and intelligent features.

Project Overview
The project involves designing and developing a cloud-based SaaS platform that includes:
* Visitor registration and check-in system
* AI-assisted visitor identification and automation
* Admin dashboard for monitoring and management
* Multi-tenant SaaS architecture
* Real-time visitor tracking and analytics
* Integration with modern authentication and notification systems
We are looking for someone who can handle both backend and frontend development, with strong experience building scalable SaaS products.

Responsibilities
1. Backend Development
* Develop a robust backend using Python (FastAPI or Django preferred).
* Design RESTful or GraphQL APIs for frontend communication.
* Implement secure authentication and authorization (JWT, OAuth, RBAC).
* Build a multi-tenant SaaS architecture.
* Integrate AI/ML components for visitor automation.
* Ensure performance, scalability, and security.
* Work with databases such as PostgreSQL, MongoDB, or similar.

2. Frontend Development
* Develop a modern frontend using TypeScript and Next.js.
* Build a responsive and user-friendly dashboard for administrators.
* Implement visitor check-in interfaces (tablet/kiosk friendly).
* Integrate APIs and ensure smooth UX.
* Optimize performance and accessibility.

3. AI Integration
The system should include AI-powered features such as:
* Automated visitor recognition (optional facial recognition)
* Smart check-in suggestions
* Visitor behavior insights
* Automated host notifications
* AI-based visitor categorization
* Intelligent analytics and reporting
Experience with AI frameworks such as TensorFlow, OpenCV, or similar tools is a plus.

4. SaaS Platform Features
The system should support:
* Multi-organization accounts
* Subscription plans
* User roles and permissions
* Visitor history and logs
* Notification systems (Email/SMS/WhatsApp)
* Data analytics dashboard
* API integrations with other systems

Required Skills
* Strong experience with Python (FastAPI, Django, or Flask)
* Frontend development using Next.js and TypeScript
* Experience building SaaS platforms
* Database design and optimization
* API development and integrations
* AI/ML implementation experience
* Cloud deployment experience (AWS, GCP, or Azure)
* Docker and containerization
* Git version control

I am looking for a Python developer with experience in computer vision and automation to build a bot for a mobile mini game.

The game runs on an iPhone that is mirrored to my Mac, and I control the game from the Mac. The bot would run on macOS and interact with the mirrored game window by detecting visual elements and triggering clicks.

There are a few mini games in the app. Each game lasts about 30 60 seconds.

Example mini games:

Timing Game:
A meter moves back and forth with a white line. When the line reaches a colored zone (orange or purple), the bot should trigger a click at the correct moment. The closer the timing is to the center of the zone, the higher the score.

Mole Game:
Moles appear on the screen and need to be tapped quickly to score points. The bot should detect Moles and click them while avoiding non-mole objects.

Requirements:

Python

Computer vision (OpenCV or similar)

Screen capture / image detection

Automated clicking

Script must run on macOS

Preferred:

Experience building screen based automation or game bots

Ability to add slight randomness to click timing/position so actions appear natural

Deliverables:

Working Python script

Instructions for running the script on macOS

Ability for me to run the bot locally on my machine

I can provide screen recordings or screenshots of the mini games to help with development.

Poker Vision and GTO Analysis Tool — Developer Specification

Objective

Develop an offline application that analyzes recorded poker footage, screenshots, or manually entered hand data to detect the game state and generate GTO-based recommendations for post-session review and training.

The system is intended for study and hand analysis only. It must not provide live in-game assistance.

Scope

The application should:
• Detect hole cards, community cards, player positions, pot size, bet sizing, and approximate stack sizes from recorded media.
• Reconstruct the full hand state in a structured format.
• Pass the reconstructed state into a GTO analysis module or solver-based recommendation engine.
• Display recommendations, alternative lines, and relevant metrics in a simple user interface.
• Include testing, performance optimization, and documentation for long-term maintainability.

Recommended Technologies
• Python for rapid prototyping and backend development
• OpenCV for image and video processing
• PyTorch for model training and inference
• YOLO or a similar object detection model for card and chip recognition
• NumPy / Pandas for data processing
• PySide6 or Tkinter for the desktop interface
• Optional solver integration if precomputed strategy outputs are available

Development Plan

1. Define requirements and architecture
Before implementation, define the exact project goals, constraints, and module boundaries. The developer should specify:
• supported input types
• poker format(s)
• expected accuracy targets
• acceptable processing time
• target operating system(s)
• internal module interfaces

The system should be split into the following components:
• media input and frame extraction
• visual detection
• state reconstruction
• strategy analysis
• user interface
• testing and logging

2. Prepare and annotate datasets
Create or collect annotated datasets for:
• hole cards
• board cards
• chips or stack indicators
• table regions
• action areas
• pot and numeric displays

Tasks include:
• defining annotation rules
• labeling training images consistently
• creating train, validation, and test splits
• ensuring examples cover different lighting, resolutions, and layouts
• versioning the dataset for reproducibility

3. Build the media input module
Develop the media input layer to handle:
• recorded video files
• screenshots
• screen captures
• manually entered hand states for testing

This module should:
• extract frames at configurable intervals
• support cropping and region-of-interest selection
• normalize images before inference
• assign timestamps and frame identifiers for debugging

4. Implement card and stack detection
Train and deploy a visual detection model to identify:
• card ranks and suits
• community cards
• chip stacks or stack indicators
• relevant UI areas and seat locations

Tasks:
• train an object detection model such as YOLO
• add post-processing to reject invalid detections
• estimate stack sizes using visual chip counts or numerical overlays
• improve robustness against blur, occlusion, and inconsistent lighting

5. Reconstruct the poker state
Convert the detection outputs into a structured hand-state representation.

The output schema should include:
• hero cards
• board cards
• seat positions
• stack sizes
• pot size
• current street
• action history
• bet sizes
• effective stack
• frame or timestamp reference

This layer should also:
• combine detections across multiple frames
• resolve conflicting information
• validate impossible game states
• support manual correction in the interface when confidence is low

6. Integrate the GTO analysis module
Once the hand state is reconstructed, feed it into a strategy engine.

Input fields should include:
• position
• stack depth
• action sequence
• board texture
• hand combination
• betting context

The analysis module should return:
• recommended action
• strategy frequency
• EV or decision quality metrics
• optional alternative actions for comparison

This module may use:
• precomputed solver outputs
• lookup tables
• a trained policy approximation model
• a hybrid rules-plus-model architecture

7. Build the user interface
Create a simple interface that allows the user to:
• upload media
• inspect detected cards and stacks
• review reconstructed hand states
• correct detection mistakes manually
• view solver recommendations clearly

The UI should prioritize:
• readability
• fast correction workflows
• traceability between frames and detected states
• easy debugging for developers

8. Perform end-to-end testing
After the interface is functional, run full pipeline tests.

Validation should include:
• detection accuracy under different lighting and camera angles
• state reconstruction consistency
• reliability of the strategy output
• stability across different input sources
• acceptable processing time for offline review

9. Optimize performance
Once the pipeline works correctly, optimize:
• frame extraction speed
• inference time
• memory usage
• model size
• error recovery logic

The goal is to make the application stable, efficient, and usable on standard hardware.

10. Ensure continuous integration between modules
All modules must exchange data using clearly defined formats and interfaces. Add integration tests to ensure that changes in one component do not silently break another.

11. Run stress tests in different environments
Test the application on:
• different operating systems
• different screen resolutions
• different video qualities
• different table layouts
• longer sessions with many hands

This will improve robustness and reduce environment-specific failures.

12. Plan for long-term model maintenance
The system should support future retraining and improvement. This includes:
• collecting new annotated examples
• retraining detection models on updated layouts
• maintaining versioned datasets and models
• documenting retraining procedures
• tracking model performance over time

Documentation Requirements

Every module must be documented so another developer can understand and maintain the project. Documentation should include:
• module purpose
• inputs and outputs
• dependencies
• known limitations
• test procedures
• setup instructions
• deployment notes

Delivery Checklist
1. Requirements definition and technology selection
2. Dataset preparation and annotation
3. Media capture and input pipeline
4. Card and stack detection model
5. State reconstruction layer
6. GTO analysis integration
7. User interface
8. Accuracy and latency testing
9. Performance optimization
10. Cross-module integration checks
11. Stress testing across environments
12. Model maintenance and retraining plan
13. Full technical documentation and handoff

Skills: Python, Testing / QA, User Interface / IA, Machine Learning (ML), Software Development, Image Processing, OpenCV, Computer Vision, Object Detection, YOLO

About the Project

We are building an AI-powered intravascular imaging platform for a medical device company. The platform processes
multi-channel catheter imagery (white light, fluorescence, laser reflectance) and integrates with hospital PACS
and EHR systems. We need a developer with deep DICOM expertise and strong Python skills to lead protocol-level
integration work.

What You Will Do

- Build and maintain DICOM networking services (C-STORE, C-FIND, C-MOVE, C-GET) for sending and receiving medical
images to and from hospital PACS
- Implement DICOM Structured Report (DICOM-SR) generation following PS3.16 reporting templates and IHE Cardiology
profiles
- Parse, validate, and transform DICOM headers for de-identification (HIPAA Safe Harbor) and metadata extraction
- Integrate with HL7 FHIR R4 endpoints for EHR connectivity (Epic, Cerner/Oracle Health)
- Work with multi-channel 12-bit image data, handling custom transfer syntaxes and pixel data encoding
- Support PDF export of structured reports for non-DICOM environments
- Write clean, testable Python code with unit test coverage of 90% or higher
- Collaborate with ML engineers building image analysis pipelines that consume DICOM inputs

Required Skills and Experience

- 5+ years working directly with the DICOM standard in a production environment
- Strong proficiency with pydicom and pynetdicom libraries
- Hands-on experience integrating with hospital PACS (any major vendor)
- Solid understanding of DICOM networking, conformance statements, and SOP classes
- Experience with DICOM-SR (Structured Reporting) templates
- Python 3.10+ with modern tooling (pytest, type hints, virtual environments)
- Familiarity with medical image formats and multi-frame, multi-channel datasets
- Understanding of HIPAA requirements for handling protected health information

Preferred (Nice to Have)

- Experience with HL7 FHIR R4 and python-fhir or fhirclient libraries
- Background in intravascular imaging (IVUS, OCT, or similar catheter-based modalities)
- Familiarity with IEC 62304 software lifecycle documentation for medical devices
- Experience with IHE integration profiles (Cardiology, Radiology)
- Knowledge of FDA regulatory requirements for Software as a Medical Device (SaMD)
- Experience with NumPy/OpenCV for medical image preprocessing
- AWS cloud experience (S3, Lambda, ECS)

About Our Team

Dasnuve is a US-based technology consultancy supporting a medical device company through their platform build. You
will work directly with our technical lead and a small, focused engineering team. The work is meaningful and the
domain is fascinating. You will be contributing to technology that helps interventional cardiologists visualize
and assess coronary arteries in real time.

To Apply, Please Include

1. A brief description of your DICOM project experience, specifically which SOP classes and networking services
you have implemented
2. Any experience with intravascular or cardiac imaging systems
3. Your availability (hours per week) and preferred working hours/time zone
4. Links to relevant work samples or GitHub repositories if available