Find OpenCV Projects on Upwork with Vollna

[SECRET WORD REQUIREMENT: Please see the bottom of this job post before applying]

We are seeking an experienced Python developer with a strong background in computer vision (CV) and real-time game automation to develop a low-latency target tracking control loop.

The project involves taking a live stream from a capture card, running it through a pre-trained YOLOv8/YOLOv11 object detection model, calculating spatial target offsets, and routing those coordinates instantly to console hardware.

The catch: This script must be written specifically to integrate with the Titan Two hardware emulator inside Gtuner IV's Computer Vision (GCV) panel. Standard PC mouse-injection libraries (like PyAutoGUI or Win32 API) will not work for this project.

Core Technical Requirements:
Language & Stack: Python 3.8 - 3.11, OpenCV, Ultralytics (YOLO).

Hardware Interface: Deep understanding of the native Gtuner Python API. You must be comfortable writing a modular script formatted as a ⁠GCVWorker⁠ class that outputs data directly via ⁠gtuner.gcv_set_val()⁠ to the hardware analog stick registers (⁠STICK_1_X⁠ and ⁠STICK_1_Y⁠).

Optimization: Expertise in minimizing latency. You must know how to export or compile raw PyTorch ⁠.pt⁠ weights into an optimized execution format like NVIDIA TensorRT or ONNX Runtime to keep frame inference times under 5ms.

Personal & Performance Requirements:
FPS Game Knowledge: You must be well-versed in competitive FPS games and understand design choices like deadzones, linear vs. exponential thumbstick scaling, and coordinate normalization (translating a bounding box from a 640x640 vision matrix back to an analog controller scale of -100 to 100).

Collaborative & Adaptive Mindset: We are looking for someone who treats this as an active partnership. The tracking loop will likely require iterative tweaking (balancing acceleration, smoothing functions, and target-switching filters). You must be open to brainstorming features, listening to gameplay feedback, and working collaboratively to fix bugs or tracking faults.

Deliverables (Phase 1):
1. A clean, well-documented ⁠.py⁠ script implementing the ⁠GCVWorker⁠ interface for Gtuner IV.
2. Implementation of target prioritization logic (e.g., locking onto the entity closest to the center crosshair).
3. Smoothness and sensitivity scaling adjustments exposed as variables at the top of the script for easy user calibration.

Mandatory Screening Questions:
1. Have you ever written a Python script that explicitly interacts with Gtuner IV or hardware input controllers? If so, briefly outline how you handled joystick clamping and stick drift variables.
2. If our capture card inputs a 1080p stream at 60 FPS, but our YOLO model runs inference on a 640x640 frame, how will your script calculate the target pixel offset and scale it accurately to the controller's axis values?
3. To eliminate automated bot proposals, what is the secret word hidden at the bottom of this post?

How to Apply:
To prove you read this entire post and understand the project scope, please start the very first line of your proposal with the secret word "TITAN".

We are looking for a contractor with strong experience in computer vision, signal processing, multimedia systems, and Python-based research prototyping.

The work involves designing and evaluating algorithms for video analysis, content protection, robustness testing, and experimental research.

Ideal candidates should have experience with:

Python
OpenCV
FFmpeg
NumPy / SciPy
Computer Vision
Signal Processing
Image / Video Processing
Experimental Evaluation
Technical Report Writing

Selected candidates will be asked to complete a paid technical assessment involving the design and evaluation of a video-processing algorithm.

Skills: Python, Matlab and Mathematica, Algorithm, Machine Learning (ML), Image Processing, OpenCV, NumPy, SciPy, Video Processing, Computer Vision

Project Description:

We are looking for a freelance computer vision developer to design a real-time cattle tracking and counting system using a fixed camera installed in a livestock building.

The main objective is individual animal tracking: each bovine must be assigned a unique and persistent identifier to ensure reliable counting without duplicates (even in the event of crossing paths or leaving/re-entering the camera's field of view), as well as movement statistics (density heatmap, time spent in each zone).

Project Scope:

- Cattle detection using YOLOv8 (or equivalent SOTA model)
- Multi-object tracking (ByteTrack or BoT-SORT) to assign a unique and persistent ID to each animal
- Handling of occlusions and re-identification after temporary loss of tracking
- Generation of a heatmap/density map based on tracked paths
- Real-time counting without duplicates (target more than 15 FPS)
- Web dashboard (Flask) displaying the video stream annotated with IDs, the live count, and the heatmap
- Deployment on edge hardware (Raspberry Pi 4 or Jetson Nano) for 100% local processing

Expected Deliverables:

- Trained YOLOv8 model (.pt + .onnx)

- Configured and calibrated tracking module
- Documented Python script (complete pipeline: capture → detection → tracking → counting) → heatmap)
- Functional Flask dashboard
- Export of tracking data (CSV/JSON: positions, trajectories, counts)
- Technical documentation and deployment guide
- Source code on a Git repository

Required skills:

- Python, OpenCV
- YOLOv8 / Ultralytics
- Multi-object tracking algorithms (ByteTrack, BoT-SORT, DeepSORT)
- Flask or equivalent lightweight web framework
- Experience deploying on embedded hardware (Raspberry Pi / Jetson Nano) is a plus

To apply, please provide:

- Your previous projects involving object detection and/or tracking (links or examples welcome)
- Your approach to preventing ID switches in a dense herd
- An estimated timeframe and budget for this project

Role Overview
We are seeking a talented Python Developer with strong expertise in AI and ML to join our team. This position will work collaboratively with key members of the AI development team responsible for growing our agent-driven platform.

In this role, you will work on our core platform, which utilizes MCP (Media Content Platform) with proprietary agents, integrated seamlessly with Langchain and Retrieval-Augmented Generation (RAG) techniques. You will contribute to building and maintaining AI-powered automations, handling extensive API integrations, and leveraging Blender libraries for 3D modeling and rendering tasks. This position is ideal for someone passionate about applying AI in creative industries, with a focus on automation, generative tools, and specialized ML models.

Key Responsibilities
• Design, develop, and maintain Python-based applications and scripts that integrate MCP with proprietary agents for AI-driven workflows in media and entertainment.
• Implement and optimize Langchain integrations, including RAG pipelines, to enhance data retrieval, processing, and generation for content automation.
• Build and manage complex API integrations to connect our AI systems with external services, ensuring seamless data flow and automation across platforms.
• Develop and deploy AI/ML models for automation, including generative AI tools and specialized models tailored to media/entertainment use cases such as content recommendation, asset generation, and workflow optimization.
• Collaborate with cross-functional teams (e.g., data scientists, designers, and engineers) to troubleshoot, debug, and scale AI integrations.
• Conduct code reviews, ensure best practices in Python development, and contribute to architectural decisions for scalable, maintainable systems.
• Stay updated on emerging AI/ML trends, particularly in GenAI and automation, and apply them to improve our proprietary systems.

Required Qualifications
• 7+ years of professional experience as a Python developer, with a proven track record in AI/ML projects.
• Strong proficiency in Python, including libraries such as NumPy, Pandas, Scikit-learn, TensorFlow/PyTorch, and experience with API development (e.g., RESTful APIs, FastAPI/Flask).
• Hands-on experience with Langchain, RAG techniques, and building agent-based systems.
• Solid understanding of AI for automation, including generative AI (e.g., Stable Diffusion, GPT models) and specialized ML models.
• Excellent problem-solving skills, with the ability to handle complex integrations and debug AI-driven systems.
• Strong communication skills and a collaborative mindset for working in a fast-paced team environment.

Preferred Qualifications
• Experience with MCP or similar proprietary agent-based platforms in AI contexts.
• Knowledge of cloud services (e.g., AWS, GCP) for deploying AI/ML models.
• Background in media-specific tools and libraries (e.g., OpenCV, FFmpeg).
• Familiarity with Blender's Python API and scripting for automation in 3D environments.
• Contributions to open-source AI/ML projects or publications in relevant fields.
• Familiarity with DevOps practices, including CI/CD pipelines and containerization.

What We Offer
• Competitive salary or hourly rate.
• Opportunities to work on innovative projects in media and entertainment sector.
• A collaborative, inclusive work environment with flexible remote/hybrid options.
• Professional development resources, including access to AI/ML tools and training.
• The chance to make a real impact by shaping the future of AI-driven media automation.

If you are a Python expert passionate about AI/ML in creative industries, we encourage you to apply. Please submit your cover letter highlighting your relevant experience.

About MetaBull Entertainment
MetaBull Entertainment has automated much of the CGI process for film and television. Our platform, Felix (v2), combines models created by artists with our proprietary agent-driven workflows, real-time viewports and multi-shot conversational AI to deliver unparalleled creative control and efficiency. Backed by a global team of engineers, scientists and filmmakers, we prioritize ethical content creation—rigorously protecting licensed assets and intellectual property. Committed to democratizing production, we empower a diverse creative community with accessible, professional-grade tools that streamline workflows and elevate visual storytelling.

Job Title:Backend Engineer Needed for Private B2B Procurement Portal & Media Pipeline (2-Week Timeline)Job Description:We are seeking an expert Backend / Full-Stack Developer to build a private procurement and inventory asset platform for an industrial goods distributor (35,000 SKUs). We have 50 active users waiting to onboard, so this project requires a compressed, phased 2-week timeline.This role focuses heavily on relational database management, third-party data synchronization, and automated image processing pipelines.📋 Phased Deliverables:Phase 1 (48 Hours): Deploy a Minimum Viable Product (MVP) portal using Glide (Business Plan) with a static template list of 500 catalog rows so users can manually log interaction requests immediately.Phase 2 (Days 3–7): Build the private master database using Supabase or PostgreSQL. Design automated script pipelines to batch-update pricing data on a quarterly cycle from provided supplier data sheets and web endpoints.Phase 3 (Days 7–10): Build an automated Python media processing pipeline (using Pillow/OpenCV). The system must source missing part graphics via image search APIs, normalize image resolutions, auto-crop backgrounds/overlays, and programmatically apply our transparent company watermark.Phase 4 (Days 11–14): Program our masked profit margins (+15%) into the frontend view, optimize database queries to comfortably support 50+ concurrent users, and integrate order-routing queues via Make.com.🛠️ Required Technical Skills:Advanced Python & backend automation workflows.Image manipulation and computer vision libraries (OpenCV or Pillow).Database Architecture (Supabase / PostgreSQL) optimized for 35,000+ rows.No-Code Frontend Deployment (Glide).API Integrations (Make.com).

I am putting together an instructional animation and need a five-person AI task-force to power the technical side of the production. The core roles are Machine Learning Experts, Data Scientists, and Computer Vision Specialists—ideally people who feel at home moving between Python notebooks, TensorFlow / PyTorch stacks, and OpenCV pipelines.

Your main focus will be data analysis and algorithm development. Concretely, I’ll count on you to:

• Analyse raw video and motion-capture data so we can pinpoint the most engaging sequences to animate.
• Develop custom algorithms that automate character rigging, lip-sync, and scene transitions, feeding those outputs directly into our animation software (Blender and After Effects).
• Optimise and document the entire workflow so our creative team can reproduce results without heavy technical hand-holding.

I’ll provide the datasets, style guidelines, and a shared Git repo; you bring reproducible code, clear comments, and model checkpoints ready for review. Once your contributions plug seamlessly into the animation pipeline and the test renders pass quality checks, the job’s done.

If collaborating on an AI-driven instructional video excites you, let’s talk timelines and milestones.

Skills: Python, CUDA, Machine Learning (ML), C++ Programming, Data Science, OpenCV, Data Analysis, Computer Vision

PROJECT CONTEXT

We are building a Computer Vision system for video analysis. We need to hire 2 profiles:
1. ARCHITECT (technical design, decisions, oversight)
2. DEVELOPER (implementation, coding, optimization)

This is a 6-8 week MVP project to build the FOUNDATION of our system (foundation + basic detection/tracking).

After Phase 1 validation, we may extend with future phases.

CRITICAL POINT

This project CANNOT be solved with:
- LLM (ChatGPT, Claude, Gemini)
- Generic vision APIs (Google Cloud, Azure)
- Low-code solutions or templates
- "Quick solutions"

This project REQUIRES:
- Real expertise in classical Computer Vision
- Deep Learning (PyTorch or TensorFlow)
- Proven experience: object detection + video tracking
- GPU optimization (NVIDIA CUDA)
- Production-grade code

TECHNICAL ARCHITECTURE

MVP Phase 1 = 2 main components:

1. VIDEO PIPELINE FOUNDATION
• Optimized video-to-frames decomposition
• Robust extraction and preprocessing
• Memory management for video streams
• Stack: OpenCV, FFmpeg, NumPy

2. DETECTION + TRACKING INTEGRATION
• YOLO v8+ for object/person detection
• DeepSORT for temporal tracking
• Frame-to-frame ID association
• Real-world condition reliability
• Stack: YOLO (Ultralytics), DeepSORT, PyTorch

MVP PHASE 1 TIMELINE

DURATION: 6-8 weeks total

WEEK 1-2: Architecture & Setup
- System design and technical decisions
- Development environment setup
- Testing framework design
- Performance benchmarking plan

WEEK 3-4: Video Pipeline
- Frame extraction pipeline
- Preprocessing and optimization
- Performance tests

WEEK 5-6: Detection + Tracking
- YOLO integration
- DeepSORT implementation
- ID management and stability

WEEK 7-8: Integration & Polish
- End-to-end testing
- Performance optimization
- Documentation and handoff
- Code cleanup and tests

DELIVERABLE: Working MVP with clean code + documentation

TECHNICAL STACK

Languages:
- Python 3.9+ (mandatory)
- C++ (optional, optimization)

Deep Learning & CV:
- PyTorch (preferred) or TensorFlow
- Ultralytics YOLO
- DeepSORT
- OpenCV, NumPy, scikit-image

Infrastructure:
- NVIDIA CUDA + cuDNN
- GPU memory optimization
- Docker (containerization)
- Git (version control)

WE'RE LOOKING FOR 2 PROFILES

PROFILE 1: ARCHITECT
- 5+ years Computer Vision experience
- Experience designing CV systems from scratch
- Strong understanding of YOLO, tracking algorithms
- Can make technical trade-off decisions
- Proposes optimizations and alternatives
- Oversees code quality and architecture
- Part-time or full-time OK (oversight role)

PROFILE 2: DEVELOPER (Senior)
- 3+ years production Computer Vision experience
- Expert in YOLO, OpenCV, PyTorch
- Experience with DeepSORT or similar tracking
- Strong Python + GPU optimization skills
- Can write clean, tested, production code
- Follows architectural decisions
- Full-time commitment preferred for 6-8 weeks

APPLICATION INSTRUCTIONS

Specify which role you're applying for: ARCHITECT or DEVELOPER

1. PORTFOLIO (mandatory)
- 2-3 CV projects you've delivered
- GitHub repos OR description + results
- Technologies used, your exact role

2. EXPERIENCE
- Years in Computer Vision (total)
- YOLO / object detection (versions)
- Tracking experience (DeepSORT, centroid, etc.)
- PyTorch/TensorFlow experience
- GPU optimization experience
- Production projects (not just Kaggle)

3. TECHNICAL OPINION
- Feasibility of MVP in 6-8 weeks: realistic?
- Any concerns or risks?
- Your approach to Phase 1?

4. TEAM PREFERENCE
- Have you worked with an architect/developer pair before?
- Preference for sync or async communication?

EXPECTED DELIVERABLES

CODE:
- GitHub repo (private/shared)
- Clean, tested Python code
- Unit tests (pytest)
- Requirements.txt / poetry.lock
- Meaningful docstrings

DOCUMENTATION:
- Architecture README (with diagrams)
- Installation guide
- API / usage examples
- Performance benchmarks (FPS, memory)
- Known limitations

HANDOFF:
- Code review completed
- Setup verified on clean machine
- Performance validated

FAQ

Q: Can one person do both (architect + developer)?
A: Possible for strong senior, but better with 2 people. More progress, better oversight.

Q: What YOLO version?
A: Open. v8 good starting point, v10 or ByteTrack alternatives welcome if justified.

Q: After MVP, what happens?
A: We evaluate quality. Strong MVP = potential Phase 2-4 continuation.

Let's build something solid!

• Describe your recent experience with similar projects

I have a dataset of natural-scene photographs and I need a reliable image classification pipeline that flags very specific visual features on each shot. The challenge is to teach a model to pick out those subtleties rather than just labeling broad object classes, so I’m looking for someone confident with convolutional networks, transfer learning, and the usual Python stack—PyTorch or TensorFlow with supporting libraries such as OpenCV, scikit-image, NumPy, and pandas for preprocessing and analysis.

You will receive the curated training and validation folders, along with a brief that explains exactly which visual cues matter to me. I’d like you to design, train, and fine-tune the network, then benchmark it with clear metrics (accuracy, precision/recall, confusion matrix). If data augmentation or additional sampling techniques are needed to improve generalization, feel free to implement them and document your rationale.

Deliverables:
• Clean, well-commented source code
• Trained model weights and an inference script that accepts a folder of images and outputs predictions
• A concise report summarizing architecture choices, training parameters, and evaluation results
• Quick-start instructions so I can reproduce the run on my own machine (GPU or CPU)

I value readable, maintainable code and straightforward explanations over flashy notebooks, so keep it pragmatic. Once we agree on acceptance criteria, I’m happy to move fast and iterate together until the classifier zeroes in on those features with solid confidence.

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

Job Title: Senior Embedded Hardware & Vision Engineer — Drone EO/IR Payload
Project: Building a NextVision-class EO/IR camera payload for defence UAVs (Indian market)

Must Have

PCB design in Altium or KiCad — 6 to 10 layer, high-speed, impedance controlled
MIPI CSI-2 sensor bring-up on Linux (V4L2 drivers)
Experience with Sony IMX or FLIR Boson/Lepton integration
NVIDIA Jetson Orin or equivalent SoC — board bring-up, BSP customization
Basic ISP pipeline — exposure, white balance, noise reduction, HDR
H.264/H.265 hardware encode, RTSP streaming via GStreamer
Power electronics — multi-rail DC-DC design from 12V or 28V UAV bus
EMI/EMC layout discipline


Good to Have

Gimbal controller electronics — FOC/BLDC, SimpleBGC or custom
TensorRT or OpenCV deployment on edge
MISB ST 0601 metadata embedding
Experience with defence or aerospace payloads


Deliverables Expected

Sensor interface PCB schematic and layout files
Working video stream from EO and/or IR sensor on Jetson
H.265 encoded RTSP output with stable latency under 150ms
Basic ISP tuning for outdoor UAV lighting conditions


Experience Required: 8+ years in embedded systems with at least 2–3 years specifically in camera/vision hardware
Engagement: Freelance, milestone-based, long-term if fit is right

I am looking for a Python developer with expertise in GIS/Digital Mapping and Computer Vision to build a custom property lead-generation pipeline for the UK market.

The goal of the tool is to identify specific building characteristics (large, blank vertical facades) across targeted commercial routes in Manchester, UK.

Project Workflow & Requirements:

Data Pipeline: Connect to the official Google Street View API to evaluate location metadata and analyze street-level perspectives along a provided list of Manchester A-road coordinates.

Computer Vision Analysis: Process the image stream using an object detection model (such as YOLOv8/v11 or OpenCV). The model needs to analyze the building facades to detect large, continuous surfaces while filtering out buildings with heavy window density, obstructions, or complex architecture.

Compliance Filters: Cross-reference the coordinates with open UK heritage databases to ensure flagged locations are not Grade II listed.

Output: Structure the validated data into a clean Google Sheet containing the Street View coordinates, address, and a link to the UK Land Registry.

Milestones:

Milestone 1 ($200): Successful API pipeline development and routing configuration.

Milestone 2 ($200): Computer Vision logic integration and Google Sheets output optimization.

Please include the word "MANCHESTER" at the top of your proposal.

Project Description

We are building an early-stage AI-powered vehicle damage assessment startup.

We are looking for an experienced Computer Vision Engineer to develop the core AI engine for our prototype.

We only need:

* AI model training
* Cloud deployment
* API development

Project Scope

1. Prepare and clean vehicle damage datasets.
2. Fine-tune a YOLOv8 / YOLOv11 model (or equivalent) for vehicle damage detection.
3. Detect damaged vehicle parts and classify damage categories.
4. Generate structured JSON output.
5. Deploy the trained model to the cloud.
6. Build a FastAPI endpoint for inference.
7. Provide documentation for API integration.

Deliverables

* Trained model weights
* Source code
* Dataset preparation pipeline
* FastAPI endpoint
* Cloud deployment
* API documentation
* Basic testing/demo interface (optional)

Required Skills

* Python
* PyTorch
* YOLOv8 / YOLOv11
* Computer Vision
* Image Segmentation
* FastAPI
* Cloud Deployment

Nice to Have

* Automotive damage assessment experience
* Custom dataset training experience


How to Apply

Please start your proposal with the word:

“Prototype”

and include:

1. Similar computer vision projects.
2. Experience training custom YOLO models.
3. GitHub profile or portfolio.
4. Estimated timeline.
5. Your estimated budget range for this scope
6. Brief explanation of how you would approach the dataset and model training process.
We are looking for a long-term technical partner for future phases.

Hello all you talented people!

I am (unfortunately) a non-coder and I need a standalone Python utility script for Windows 11.

I use AI tools to generate artworks of characters holding my custom trading cards (making trading cards is my biggest hobby). The cards they are holding are good quality and but a bit blurry. I have separate, massive, high-resolution 25MB master PNG files of those exact same cards. For example, I can generate an image of a character holding a card called "Toxicant Skull", which looks okay until you zoom in, and want it replaced with the actual PNG of "Toxicant Skull" which is ultra sharp.

I need a program with a simple terminal menu where I select the artwork and select my HD card, and the program automatically stamps the HD card perfectly over the blurry one. I've tried making it myself with Claude Code, both using some "fill" attempt to fill a black or neon blank card, and a visual matching version to replace the blurry art with the matching HD one. Both failed me.

GOALS & REQUIREMENTS:
1. It must automatically detect the card's position, 3D tilt, and angle inside the artwork.
2. It must automatically keep fingers, hands, and hair ON TOP of the new card. I do not want the card pasting over the character's fingers. I will show an example of what a perfect version looks like (as Claude Code did manage to make ONE look great).
3. No ugly black borders or shadow bugs around the rotated card frame. The PNG basically must replace the original card in the artwork, and preserving the aspect ratio of the original PNG of is the most important thing, as I cannot completely control the thickness or aspect ratio of the card generated in the artwork.

A quick note on testing:
I'm looking for a universal tool because I generate new card art all the time! Once you finish the script using the 7-or-so samples, I'll do a quick test-run on 3-of-so "blind" images on my end that the script hasn't seen yet. This is just to make sure the program made works on new arts and not just the ones I provide. If it automatically handles those new images just as perfectly without needing any code changes, then we are completely good to go, and I'll release the payment immediately! In fact, if the script passes my blind tests smoothly on the very first try without needing bug fixes, I am more than happy to add a nice bonus to the final payout, along with a glowing five-star review!

(Note: An AI helped me write the exact technical specs below so you know what tools to use):
- Must use OpenCV (SIFT/ORB and Homography/RANSAC) for visual feature matching alignment.
- Must use alpha channel blending for seamless background borders.
- Must use pixel-disparity illumination-normalized masking for foreground occlusion (no rigid RGB skin thresholds).

Also, as I am not a coder, if there is a better way to do what I am requesting, I am 100% open to hearing a better way to have this done. If you a skilled with coding or using AI code and this program would be better using a different tech method let me know.

Due to Upwork's 10-file limit, I have only attached a few core examples here. As soon as we open a chat room together, I will instantly send you the zipped full folder containing all 10 test artworks and all matching HD card PNG files! It also includes various screenshots of my failed attempts, and the 2 programs made by Claude Code that couldn't get those attempts right.

If this program works beautifully, I am highly interested in keeping you on for future contract work! I have several other ideas for small utility apps and tools to support this card game as it expands.

P.S. - "Bonus Stress Test Mat.png" - This is the ultimate end-game test file. There are 6 different active cards flat on the playmat along with 3 card backs on the playmat, for a total of 9. If your script can loop through and replace multiple cards at once on this mat, that's amazing! But if the script can only handle 1, 2 or 3 hand images right now, that is completely fine and it will NOT be a dealbreaker for the project payout.

I appreciate the time of anyone who tries to help me. This card game is my life's work! :)

WHAT WE'RE SEEKING
We are seeking a skilled developer to build an offline, real-time assessment system that analyses a user through webcam and microphone input.
The system should assess visible communication signals such as posture, gaze/head position, facial cues, hand movement, body movement, and voice delivery cues such as pitch, pace, pauses, volume, and intonation.
This is not a cartoon avatar, game character, VR experience, or VFX project. The core deliverable is the local assessment engine. The realistic human-facing interface is a separate presentation layer and should be implemented using the simplest practical method that meets the agreed requirements.

THE MISSION
Build a local computer vision and voice analysis system that processes live webcam and microphone input in real time, converts those signals into assessment-ready features, applies configurable assessment logic, and produces real-time feedback through a realistic human-facing interface.
The human-facing interface may use pre-recorded human video states, a lightweight talking-head interface, a voice-led coach interface, visual overlays, or another local method proposed by the developer.
All execution must run locally. No cloud inference, telemetry, analytics, external callouts, or subscription runtime dependencies are permitted.

TARGET DEVICE
Primary target: Windows 11 consumer hardware.
Must be benchmarked on the agreed target machine.
GPU acceleration may be used where appropriate.
Must not require non-consumer cluster GPUs.
Kinect, depth cameras, or specialist hardware may be proposed only as optional enhancements, not default requirements.

IN SCOPE

- Real-time webcam capture.
- Real-time microphone capture.
- Webcam-based pose estimation / body landmark tracking.
- Face landmark detection.
- Hand landmark tracking where practical.
- Gaze or head-pose estimation where practical.
- Voice feature extraction, including pitch, pace, pauses, volume, energy, and intonation features.
- Feature extraction layer that converts raw landmarks/audio into assessment signals.
- Configurable assessment logic using local JSON/YAML-style configuration.
- Hot reload for assessment logic without restarting the application.
- Real-time feedback events based on the assessment logic.
- Realistic human-facing interface layer.
- Visual debug overlay showing extracted landmarks/features during development and demo.
- Local benchmarking of latency, FPS, CPU/GPU usage, RAM usage, and sustained runtime.
- Offline verification showing no external calls.
- Clear separation between capture, feature extraction, assessment logic, scoring, feedback events, configuration, human interface, and application/UI layers.
- Documented interfaces between major components.
- Setup documentation, run commands, architecture notes, benchmark notes, and known limitations.

TECH STACK
Note: We will mutually agree on any tech stack changes to ensure no risk to target expectations and success factors:
* Visual engine: Unreal Engine 5
* Human character: MetaHuman first; custom rig later only if needed
* Face/lip animation: NVIDIA Audio2Face-3D / ACE Unreal Plugin
* Body/gaze/gesture: Unreal animation state machine
* Real-time audio/session: LiveKit Agents
* Turn-taking: LiveKit turn detector + Silero VAD
* TTS: Benchmark Chatterbox Turbo
* Backend: Existing backend via clean event bridge
* UI: React Tauri 1.8 wrapper - AJ to do vs PYQT6
* External webcam: OBS Virtual Camera only if needed
MediaPipe : Local multi-modal framework that extracts face, iris, hand, and body pose landmarks concurrently using device hardware.​
ONNX Runtime (onnxruntime-gpu): High-performance local inference engine optimized for running .onnx models utilizing Windows CUDA or DirectML acceleration.​
OpenCV (opencv-python): Native computer vision library used for real-time webcam frame acquisition, image preprocessing, and drawing visual debug overlays.​
sounddevice: Thread-safe audio library interfacing with Windows WASAPI/ASIO drivers to stream raw microphone input into NumPy arrays.​
Silero VAD: Ultra-lightweight voice activity detection model running locally via ONNX to segment real-time speech and calculate pauses.​
parselmouth (Praat for Python): Local acoustic analysis library utilizing mathematical signal processing to extract fundamental frequency for pitch tracking.​
scipy.signal & numpy: Scientific computing libraries used to perform instantaneous local RMS calculations for real-time volume and energy tracking.​
opensmile: Standardized feature extraction framework optimized in C++ to capture comprehensive acoustic parameter sets completely offline.​
PyQt6 / PySide6: C++ backed GUI framework providing hardware-accelerated widgets (QMediaPlayer) and thread-safe signaling to drive the presentation layer.​
watchdog: Local file monitoring utility that actively monitors file changes and triggers instantaneous hot-reloads of configuration files.​
psutil: System monitoring tool that queries the local OS kernel to benchmark CPU, RAM, and application process utilization.​
pynvml: Direct local wrapper for the NVIDIA Management Library used to programmatically log real-time GPU and VRAM metrics.

CLIENT TECHNICAL ENVIRONMENT:
* RTX 4080 15GB VRAM
* Ryzen 9 4950H
* 32GB RAM

PROCESSES (to be refined):
- User Experience During Session
app launch -- zoom like experience (see image)

- Post Session
User stats evaluation summary (driven by all of the info captured within this project): BPS, Pros, Cons, Body Language

Settings menu (icon) -
- Content : Load data (subject matter for user to discuss) - Rules config
- Presenter Persona : System Prompt
- LLM: Choose Ollama Model from drop-down list. User can download local models. Show local models downloaded. Can be deleted. Include synch button to fetch latest models/changes.



OUT OF SCOPE
- Cloud computer vision APIs.
- Cloud speech or voice analysis APIs.
- Subscription-based runtime dependencies.
- Telemetry, analytics, or external callouts.
- Enterprise production-grade deployment.
- Full 3D character pipeline unless separately approved.
- Skeletal mesh / rigged character development unless separately approved. (no only head, shoulder, arms only)
- VFX-heavy digital human rendering unless separately approved.
- Kinect or depth-camera dependency as a default requirement. (going into the distance)
- Deepfake-style synthesis unless explicitly approved in writing.
- Multilingual translation.
- Audio transcription beyond what is required for direct voice delivery analysis.
- Emotion recognition claims unless legally, technically, and contractually approved.
- Hardcoded assessment rules where configuration is practical.

IDEAL EXPERIENCE
Computer Vision
- Real-time pose estimation.
- Body landmark / skeletal landmark tracking.
- Face landmark detection.
- Hand tracking.
- Head-pose or gaze-related estimation.
- OpenCV, MediaPipe, ONNX Runtime, PyTorch, TensorRT, or equivalent local tooling.

Audio / Voice Analysis
- Real-time microphone handling.
- Pitch, tempo, pause, volume, energy, and intonation feature extraction.
- Local DSP/audio feature pipelines.
ffmpeg, PyAudio, sounddevice, librosa, torchaudio, or equivalent tooling.

Local ML / Runtime Optimisation
- Running models locally on consumer hardware.
- Optimising for latency and memory usage.
- Practical benchmarking and profiling.
- ONNX, PyTorch, TensorRT, or equivalent runtime choices.

Human Interface
- Video-based human presenter interfaces.
- Lightweight talking-head interfaces.
- Voice-led coaching interfaces.
- Real-time feedback UI.
- Ability to keep the presentation layer separate from the assessment engine.

Architecture
- Clean modular design.
- Testable component boundaries.
- Configuration-driven behaviour.
- Clear handover documentation.
- Practical trade-off decisions.
- Low technical debt MVP delivery.

NON-NEGOTIABLES
Offline Operation
- The system must run locally.
- No required internet connection.
- No telemetry.
- No analytics.
- No subscription runtime dependency.

Performance
- Target end-to-end feedback latency: under 100ms where technically practical.
- Candidate must benchmark actual latency on the agreed hardware.
- Candidate must benchmark memory usage and sustained runtime.
- Candidate must identify any parts that cannot realistically meet the target and explain why.

Architecture Quality
- The assessment engine and human-facing interface must be separate.
- Webcam capture, audio capture, feature extraction, assessment logic, configuration, feedback events, and presentation must not be tightly coupled.
- Assessment rules must be configurable where practical.
- The MVP must be maintainable, modular, and suitable for clean handover.

Communication
- Explain technical decisions clearly. - at least 30min video catch up, everyother day.
- Flag unclear requirements early.
- Flag delivery risks at least one day before they affect delivery.
- Shared-screen review sessions may be required.
- Live walkthroughs of architecture, benchmarks, and code may be required.
- Mutually agree any changes before committing

Output Quality
- AI-assisted coding is permitted up to a maximum of 60%.
- The developer remains responsible for all code quality.
- Code must be lean, modular, testable, and documented.
- No unsupported implementation choices.
- No unnecessary complexity.
- No hidden dependencies.

Handover
- Hand over all source code, assets, configuration files, setup notes, benchmark results, and documentation.
- Provide clear run instructions.
- Provide dependency and licensing notes.
- Provide known limitations.
- Remove project files and assets from supplier infrastructure after handover unless written approval is given.

DEFINITION OF DONE
The project is complete when:
- The application runs locally on the agreed Windows 11 hardware.
- Webcam and microphone input are captured and processed in real time.
- The system extracts pose/body landmarks, face landmarks, and agreed voice delivery features.
- The system extracts hand, gaze/head-pose, or equivalent visible communication features where technically practical.
- The system converts raw landmarks and audio features into assessment-ready signals.
- The system applies configurable local assessment logic.
Configuration changes can be hot reloaded without restarting the application.
- The system produces real-time feedback events. (BPS, body language, eye-tracking)
- The feedback events drive the agreed human-facing interface.
- The human-facing interface is separate from the assessment engine.
- The system includes a visual debug mode showing key extracted landmarks/features.
- Offline testing confirms no network calls (with exception of ollama cloud and initial system install), telemetry, analytics, or cloud dependencies.
- Source code is modular and documented.
- Handover package is complete.

ACCEPTANCE CRITERIA
- Live Demo
- Demonstrates webcam and microphone input being processed in real time.
- Shows extracted body/pose, face, and voice features.
- Shows real-time feedback being generated.
- Shows feedback driving the agreed human-facing interface.
- Configuration Demo
- Assessment logic is stored in local configuration files.
- A configuration value is changed during the demo.
- The system applies the changed logic without application restart.
- Offline Evidence
- Demo runs with network disabled.
- Logs or monitoring evidence show no external calls.
- No telemetry or analytics are present.
- Benchmark Evidence
- Benchmark report includes hardware used, model/runtime choices, FPS, latency, CPU/GPU usage, RAM usage, and sustained runtime.
- Any missed performance target is explained with evidence and mitigation options.
- Architecture Evidence
- Code review confirms separation between capture, feature extraction, assessment logic, configuration, feedback events, human interface, and application/UI layers.
- Interfaces between major components are documented.
- Architecture notes identify key trade-offs and known limitations.
- Source code, assets, configuration files, setup instructions, run commands, benchmark results, and known limitations are provided.
- Supplier confirms deletion of retained project materials unless written approval is given

PAYMENT CONDITIONS
* I’ll only accept work that meets the agreed standards. These will not change from what we've discussed

INVOICING
* Invoice like this please per week:
25hrs x 24.61 = 615GBP

Coding standards:
* Must have a clear and true seperation of concerns between FE and BE
* This means the front and backend are completely seperate and connected only by an integration layer.
* You can make superficial changes to the front layer, with zero risk to the backend.
* All files must be under 600 lines long inclusive of comments and single purpose. Only exception are shared utilities
* If a file exceeds 600 lines, then consider that it's either inefficient/bloated, or is doing more that one thing
* Examples of sinlge purpose: One file is for LLM integration, one file for feature x, another file for feature y (and so on)
* All code must include comments within files (applies only where possible, since you cannot add comments to some files due to syntax issues ). This includes:
* Before imports: file name with path + points on the unique features of the file
* Comments throughout code to explain what is dynamic such that any idiot like me can understand the code
* Ensure code is dynamic and flexible - not rigid, fragile or with hardcoded values .

We are looking for a remote Machine Learning Engineer to help build and deploy production document-AI systems. The work centres on optical character recognition (OCR), document analysis, computer vision, and NLP/LLM components that automate document-heavy operational processes. You will develop and optimise deep-learning models, build end-to-end ML pipelines (data ingestion, feature engineering, training, evaluation, inference), and deploy them using Docker, Kubernetes, and modern MLOps practices. Essential skills: strong Python; TensorFlow and/or PyTorch; OpenCV; and hands-on experience with OCR and computer vision. Familiarity with LLMs and document-analysis techniques (e.g., TrOCR) is a strong plus. This is an ongoing, fully remote contract role with flexible hours.

I want shoppers on the Laxmi Opticians site to slip on any frame from our catalogue without leaving the page. The idea is a lightweight, 2-D computer-vision overlay that precisely positions sunglasses and prescription glasses on a customer’s face, working fluidly on both desktop and mobile browsers. No full 3-D modelling, no manual prompt engineering—just an instant preview that feels as natural as looking in a mirror.

The experience must offer two entry points:
• Real-time overlay through the user’s webcam or phone camera.
• Photo upload for those who prefer to try glasses on a still image.

Accuracy is critical: pupils should align, temple angles should respect head pose, and scaling must stay consistent as users lean closer or farther from the camera. I’m open to the stack you choose—MediaPipe FaceMesh, OpenCV, TensorFlow.js, or a custom WebAssembly module—as long as the final JS/HTML/CSS bundle is small, loads quickly, and can be dropped into a React storefront with minimal wiring.

Deliverables
1. Embeddable front-end component (React preferred) with clear API hooks for product ID, frame PNG/SVG, and colour variants.
2. Back-end or edge function (if needed) for any image pre-processing.
3. Integration guide and commented source so my in-house devs can extend it.
4. Short test plan demonstrating alignment accuracy across common devices and lighting conditions.

Acceptance will be based on latency (<150 ms overlay update on mid-range mobile), alignment precision (≤3 px average pupil offset in sample tests), and straightforward plug-and-play integration into our existing checkout flow.

Skills: JavaScript, CSS, C++ Programming, HTML, OpenGL, OpenCV, 2D Animation, Computer Vision

We are seeking an experienced engineer to assist with a confidential software initiative involving advanced data processing, visualization, and geometry. The ideal candidate will have a strong background in software engineering and data processing, with the ability to work independently on complex projects. This is a part-time, short-term engagement with a focus on delivering high-quality results.

Required Experience

* 5+ years professional software engineering experience
* Strong Python development experience
* Experience working with large datasets
* Experience building automated processing pipelines
* Experience with visualization technologies
* Experience with geometric or spatial data
* Experience with desktop and/or web-based applications
* Strong problem-solving and analytical skills

Highly Preferred Experience

One or more of the following:

* Computer vision
* Scientific computing
* Scientific visualization
* Biomedical engineering
* Computational geometry
* Image processing
* CAD/CAM systems
* Mesh processing
* Data reconstruction workflows
* Machine learning
* Research and development environments

Technical Background Desired

Experience with some combination of:

* Python
* C++
* OpenCV
* NumPy
* SciPy
* VTK
* ITK
* Visualization frameworks
* Cloud platforms
* Modern web application frameworks

Equivalent technologies are acceptable.

Responsibilities

* Evaluate technical approaches
* Recommend architecture decisions
* Build proof-of-concept solutions
* Assist with prototype development
* Document findings and recommendations
* Collaborate on long-term technical strategy

⸻

To Apply

Please include:

* Relevant project experience
* Technical background summary
* Examples of complex engineering work
* Hourly rate
* Availability

Confidentiality agreement required prior to project-specific discussions.

I want a compact AI solution that can watch a live camera feed, recognise people, vehicles and animals, then overlay on-screen the class label and an accurate distance reading for every object it sees. The system must work reliably indoors and outdoors without me having to switch profiles manually.

Here is what I expect:
• Real-time detection and tracking of the three classes mentioned above.
• A distance-estimation module (stereo, monocular depth, LiDAR fusion—whichever you judge most practical) that outputs metres or feet beside each bounding box.
• Clear text overlay on the video frame; no audible alerts are required.
• A single-command way to launch the application on a standard Windows or Linux laptop with an external or built-in camera.
• Source code (Python preferred), pre-trained weights, a short README for setup, and a calibration routine so I can adapt the model to new lenses.

Acceptance criteria
1. When an object is centred at 3 m, the displayed distance should be within ±10 %.
2. Frame rate should stay above 15 fps at 720p on a mid-range CPU/GPU.
3. Only the three specified classes appear; all else is ignored or labelled “other”.

Feel free to build on YOLOv8, OpenCV, PyTorch, depth-AI, or similar—just keep the install steps streamlined. Demo footage proving indoor and outdoor accuracy will help me verify results quickly.

Skills: C Programming, Python, C++ Programming, Arduino, OpenCV, Computer Vision, Deep Learning, YOLO

WHAT WE'RE SEEKING

We are seeking a skilled developer to build an offline, real-time assessment system that analyses a user through webcam and microphone input.

The system should assess visible communication signals such as posture, gaze/head position, facial cues, hand movement, body movement, and voice delivery cues such as pitch, pace, pauses, volume, and intonation.

This is not a cartoon avatar, game character, VR experience, or VFX project. The core deliverable is the local assessment engine. The realistic human-facing interface is a separate presentation layer and should be implemented using the simplest practical method that meets the agreed requirements.

THE MISSION

Build a local computer vision and voice analysis system that processes live webcam and microphone input in real time, converts those signals into assessment-ready features, applies configurable assessment logic, and produces real-time feedback through a realistic human-facing interface.

The human-facing interface may use pre-recorded human video states, a lightweight talking-head interface, a voice-led coach interface, visual overlays, or another local method proposed by the developer.

All execution must run locally. No cloud inference, telemetry, analytics, external callouts, or subscription runtime dependencies are permitted.

TARGET DEVICE

Primary target: Windows 11 consumer hardware.
Must be benchmarked on the agreed target machine.
GPU acceleration may be used where appropriate.
Must not require non-consumer cluster GPUs.
Kinect, depth cameras, or specialist hardware may be proposed only as optional enhancements, not default requirements.

IN SCOPE

- Real-time webcam capture.
- Real-time microphone capture.
- Webcam-based pose estimation / body landmark tracking.
- Face landmark detection.
- Hand landmark tracking where practical.
- Gaze or head-pose estimation where practical.
- Voice feature extraction, including pitch, pace, pauses, volume, energy, and intonation features.
- Feature extraction layer that converts raw landmarks/audio into assessment signals.
- Configurable assessment logic using local JSON/YAML-style configuration.
- Hot reload for assessment logic without restarting the application.
- Real-time feedback events based on the assessment logic.
- Realistic human-facing interface layer.
- Visual debug overlay showing extracted landmarks/features during development and demo.
- Local benchmarking of latency, FPS, CPU/GPU usage, RAM usage, and sustained runtime.
- Offline verification showing no external calls.
- Clear separation between capture, feature extraction, assessment logic, scoring, feedback events, configuration, human interface, and application/UI layers.
- Documented interfaces between major components.
- Setup documentation, run commands, architecture notes, benchmark notes, and known limitations.

OUT OF SCOPE

- Cloud computer vision APIs.
- Cloud speech or voice analysis APIs.
- Subscription-based runtime dependencies.
- Telemetry, analytics, or external callouts.
- Enterprise production-grade deployment.
- Full 3D character pipeline unless separately approved.
- Skeletal mesh / rigged character development unless separately approved.
- VFX-heavy digital human rendering unless separately approved.
- Kinect or depth-camera dependency as a default requirement.
- Deepfake-style synthesis unless explicitly approved in writing.
- Multilingual translation.
- Audio transcription beyond what is required for direct voice delivery analysis.
- Emotion recognition claims unless legally, technically, and contractually approved.
- Hardcoded assessment rules where configuration is practical.

IDEAL EXPERIENCE

Computer Vision

- Real-time pose estimation.
- Body landmark / skeletal landmark tracking.
- Face landmark detection.
- Hand tracking.
- Head-pose or gaze-related estimation.
- OpenCV, MediaPipe, ONNX Runtime, PyTorch, TensorRT, or equivalent local tooling.

Audio / Voice Analysis

- Real-time microphone handling.
- Pitch, tempo, pause, volume, energy, and intonation feature extraction.
- Local DSP/audio feature pipelines.
ffmpeg, PyAudio, sounddevice, librosa, torchaudio, or equivalent tooling.

Local ML / Runtime Optimisation

- Running models locally on consumer hardware.
- Optimising for latency and memory usage.
- Practical benchmarking and profiling.
- ONNX, PyTorch, TensorRT, or equivalent runtime choices.

Human Interface

- Video-based human presenter interfaces.
- Lightweight talking-head interfaces.
- Voice-led coaching interfaces.
- Real-time feedback UI.
- Ability to keep the presentation layer separate from the assessment engine.

Architecture

- Clean modular design.
- Testable component boundaries.
- Configuration-driven behaviour.
- Clear handover documentation.
- Practical trade-off decisions.
- Low technical debt MVP delivery.

NON-NEGOTIABLES

Offline Operation

- The system must run locally.
- No required internet connection.
- No cloud inference.
- No telemetry.
- No analytics.
- No external service calls.
- No subscription runtime dependency.

Performance

- Target end-to-end feedback latency: under 100ms where technically practical.
- Candidate must benchmark actual latency on the agreed hardware.
- Candidate must benchmark memory usage and sustained runtime.
- Candidate must identify any parts that cannot realistically meet the target and explain why.

Architecture Quality

- The assessment engine and human-facing interface must be separate.
- Webcam capture, audio capture, feature extraction, assessment logic, configuration, feedback events, and presentation must not be tightly coupled.
- Assessment rules must be configurable where practical.
- The MVP must be maintainable, modular, and suitable for clean handover.

Communication

- Explain technical decisions clearly.
- Flag unclear requirements early.
- Flag delivery risks at least one day before they affect delivery.
- Shared-screen review sessions may be required.
- Live walkthroughs of architecture, benchmarks, and code may be required.

Output Quality

- AI-assisted coding is permitted up to a maximum of 60%.
- The developer remains responsible for all code quality.
- Code must be lean, modular, testable, and documented.
- No unsupported implementation choices.
- No unnecessary complexity.
- No hidden dependencies.

Handover

- Hand over all source code, assets, configuration files, setup notes, benchmark results, and documentation.
- Provide clear run instructions.
- Provide dependency and licensing notes.
- Provide known limitations.
- Remove project files and assets from supplier infrastructure after handover unless written approval is given.

DEFINITION OF DONE

The project is complete when:

- The application runs locally on the agreed Windows 11 hardware.
- Webcam and microphone input are captured and processed in real time.
- The system extracts pose/body landmarks, face landmarks, and agreed voice delivery features.
- The system extracts hand, gaze/head-pose, or equivalent visible communication features where technically practical.
- The system converts raw landmarks and audio features into assessment-ready signals.
- The system applies configurable local assessment logic.
Configuration changes can be hot reloaded without restarting the application.
- The system produces real-time feedback events.
- The feedback events drive the agreed human-facing interface.
- The human-facing interface is separate from the assessment engine.
- The system includes a visual debug mode showing key extracted landmarks/features.
- Benchmark results show latency, FPS, CPU/GPU usage, RAM usage, and sustained runtime.
- Offline testing confirms no network calls, telemetry, analytics, or cloud dependencies.
- Source code is modular and documented.
- Handover package is complete.

ACCEPTANCE CRITERIA

- Live Demo
- Demonstrates webcam and microphone input being processed in real time.
- Shows extracted body/pose, face, and voice features.
- Shows real-time feedback being generated.
- Shows feedback driving the agreed human-facing interface.
- Configuration Demo
- Assessment logic is stored in local configuration files.
- A configuration value is changed during the demo.
- The system applies the changed logic without application restart.
- Offline Evidence
- Demo runs with network disabled.
- Logs or monitoring evidence show no external calls.
- No telemetry or analytics are present.
- Benchmark Evidence
- Benchmark report includes hardware used, model/runtime choices, FPS, latency, CPU/GPU usage, RAM usage, and sustained runtime.
- Any missed performance target is explained with evidence and mitigation options.
- Architecture Evidence
- Code review confirms separation between capture, feature extraction, assessment logic, configuration, feedback events, human interface, and application/UI layers.
- Interfaces between major components are documented.
- Architecture notes identify key trade-offs and known limitations.
- Handover Evidence
- Source code, assets, configuration files, setup instructions, run commands, dependency notes, licensing notes, benchmark results, and known limitations are provided.
- Supplier confirms deletion of retained project materials unless written approval is given.

• What similar real-time CV, pose estimation, body tracking, voice analysis, or human-interface work you have already completed
• Explain the simplest practical MVP approach you recommend.
• What tools/models/runtimes you propose and why.
• How you would prove offline operation. How you would benchmark latency and memory usage. What are the main technical risks.
• Whether you would use webcam-based pose estimation, depth-camera tracking, or another method.

BUILD A PORTABLE AI VISION & DESK ASSISTANT
Raspberry Pi 5 | Computer Vision | OpenAI | OCR | Python

Project Type: Fixed Price with Milestone Payments

Budget: $1500 - $2,000 FIRM — All hardware shipped to you. If any additional hardware items are needed, I will make sure you get those right away.

Timeline: 6 weeks required.

OVERVIEW

I need an experienced developer to build a standalone AI-powered vision and problem solving desk assistant on Raspberry Pi 5 hardware. This is an accessibility and productivity tool for my personal professional use — not a hobbyist project.

The device must operate completely independently with its own screen, camera, and AI pipeline. No host computer. I am not allowed do any software installation on client machines... so this needs to be stand alone just for me.

I want to auto focus camera (which I will place 5 to 10 feet behind me to focus on my computer screen, take a snap shot of my screen at the push of a button, and once it runs what I see through AI...I need it to give the answers on my 2.5 inch display screen siting on my desk.

*This device will only be used ethically and not in any academic setting. I am dyslexic and work in fast-paced environments where I need to read documents, analyze visuals, solve math problems (like liquid does conversation and physical length, hight, and width Conversions when dealing with American and European clients. When I'm work work video calls with 25 impatient people... I need to get AI-powered answers on demand — quickly and reliably.


WHAT IT NEEDS TO DO

- Capture images of documents, screens, diagrams, and drawings, math problems
- Extract and read text using OCR
- Analyze images and answer questions using OpenAI
- Display responses clearly on a built-in touchscreen
- Start fast and run reliably in real work environments


HARDWARE — I SHIP IT TO YOU

You will receive:
Raspberry Pi 5 8GB
Raspberry Pi 5 Power Supply-
Cooler
Arducam 64MP Autofocus Camera-
Small HDMI Display
Breadboard + Jumper Wire Kit-
Push Button Kit
DJI Mic Mini

If you need additional components (camera module, enclosure, etc.), include those costs in your proposal. Ideally within the $1500 - $2,000 budget.


SOFTWARE STACK

- Python (primary language)
- OpenCV (image processing)
- OCR engine — Tesseract or equivalent
- OpenAI API (primary AI engine — open to recommendations)
- Simple touchscreen UI with large, readable buttons


MILESTONE PAYMENT STRUCTURE

Milestone 1 — $300
Architecture plan and written technical spec. Approved before any build begins.

Milestone 2 — $400
Hardware assembled, camera functional, touchscreen UI framework running.

Milestone 3 — $500
OCR working, OpenAI integrated, full image-to-answer pipeline functional.

Milestone 4 — $800
Final testing, polish, documentation, device shipped back to me.

Total: $2,000. Payment released only when each milestone is demonstrably complete.

WHO I AM LOOKING FOR

You should have real, demonstrable experience with:
- Raspberry Pi hardware builds
- OpenAI API integration
- Computer vision with OpenCV
- OCR systems
- Python for embedded or AI projects

Please do not apply if you are learning on the job. I need someone who has built something like this before and can prove it.

HOW TO APPLY

Please answer all of the following — applications without answers will not be considered:

1. Describe a similar project you have personally built.
2. Share GitHub links, photos, or videos of relevant prior work.
3. What is your location and time zone?
4. How long will this take from hardware receipt to delivery?
5. Do you accept the $2,000 firm budget?
6. Any recommendations to improve the design? I'm all ears!

Thank you for your interest.

Adam Corn
Monterey, California

Title: Build Photo-to-Brick Mosaic Generator for Brickography

I am building a custom brick mosaic business called Brickography.

I need a developer to build an MVP that converts customer photos into custom brick mosaic designs similar to the user experience offered by Brick Me.

Input:

* Customer uploads JPG or PNG photo

Required Outputs:

* Mosaic preview image
* Fixed color palette conversion (16-20 colors)
* Brick count by color
* Parts list export (CSV)
* Printable PDF building instructions

Preferred Skills:

* Python
* OpenCV
* Computer Vision
* Image Processing
* PDF Generation
* Algorithm Development

Bonus Experience:

* Pixel art generators
* Mosaic generators
* Cross-stitch pattern generators
* Paint-by-number generators
* LEGO or brick-based projects

Project Scope (MVP):

1. Upload photo
2. Convert image to fixed color palette
3. Generate brick mosaic grid
4. Calculate brick counts
5. Generate parts list
6. Generate printable PDF instructions

Please provide examples of similar work you have completed.

This is a fixed-price MVP project. Future work may be available after successful completion.

We are seeking a skilled freelancer to develop a sorting program utilizing Facial Recognition and computer vision. The ideal candidate will have experience in C# and Windows App Development, with a strong understanding of OpenCV. The project requires an intermediate level of proficiency and involves creating a program that can efficiently sort images based on facial features and read name tags on people. The program should be user-friendly and capable of handling large datasets.

We are a small early-stage startup working on a medical procedure computer vision dataset project. We are looking for an experienced AI / computer vision engineer to help process a first test batch of approximately 100 hours of video and audio material.

The files are expected to be stored in AWS S3, and the initial task is to build or apply a practical pipeline to prepare these files for downstream AI / computer vision model training.

The project involves video and audio from real-world technical procedures. The material may contain sensitive or identifiable information, so the first priority is robust de-identification and media preparation.

We are working with a limited early-stage budget, so we would strongly prefer someone who can make intelligent use of existing open-source tools, libraries and models rather than building everything from scratch or relying on expensive proprietary services.

Initial scope of work:

Access and process large video/audio files from AWS S3
Detect and blur/redact visible identifying information in video frames
Blur or mask faces, names, labels, documents, screens, tattoos, or other identifying visual details where present
Crop or mask areas outside the relevant procedural field where appropriate
Redact, mute or bleep spoken identifiers in audio, such as names, addresses, dates of birth, locations or other personal details
Produce de-identified output files suitable for review and later AI model training
Preserve file organisation and metadata so that each procedure/session remains clearly grouped
Create a repeatable processing pipeline rather than a purely manual workflow
Provide clear logs/reports of what has been processed and any files requiring human review

Additional capabilities:

Audio-video synchronisation where separate audio and video files are provided
Handling multiple camera angles or multiple video files from the same procedure/session
Stitching, trimming or aligning related media files where needed
Using audio transcripts or time markers to create useful labels or annotations
Creating structured metadata or labels that could support future computer vision, robotics or AI model training
Experience with dataset preparation for machine learning pipelines
Experience with secure data handling, cloud storage and controlled access environments
Knowledge of federated learning or secure model-training environments would be useful for a later phase, but is not essential for the first task
Basic analytics/reporting on processing status, file quality, duration, redaction success and review flags

Likely tools / technologies:

We are open to your recommendations, but would expect relevant experience with tools such as:

Python
OpenCV
FFmpeg
Whisper or other speech-to-text tools
OCR/text detection in video frames
Face/object/text detection and blurring
Audio redaction pipelines
AWS S3 or similar cloud storage workflows
Open-source ML/computer vision libraries where appropriate

We are not looking for a general web developer. We are specifically looking for someone with practical experience in computer vision, video processing, audio transcription/redaction and dataset preparation.

Initial paid test project:

The first stage is a paid proof-of-concept using around 50 hours of video/audio. The goal is to see whether you can create a workable pipeline and demonstrate that the files can be de-identified and prepared reliably.

If the test is successful, there is linkely to be a larger ongoing project involving greater volumes of media and more advanced dataset preparation.

Important requirements:

You must be comfortable working with sensitive data under strict confidentiality
You must be willing to sign an NDA if required
You should be able to explain your proposed approach clearly
You should be able to work pragmatically and cost-effectively
You should prioritise open-source and low-cost tooling wherever possible
We are a small pre-funding startup, so we are looking for someone technically strong but realistic on budget and scope

Please include in your response:

Relevant experience with video/audio de-identification
Tools or libraries you would likely use
Which parts you would expect to handle with open-source tools
Whether you have worked with AWS S3
How you would approach processing 50 hours of video/audio
Any similar dataset preparation work you have done
Your estimated cost and timeline for the first paid test project
Whether you are working alone or as part of a team

Project Overview
==============

We are exploring a new SportsTech platform focused on football player development and talent visibility.

The platform will allow young football players to upload match or training videos, then receive AI-based performance insights, clips, progress tracking, and structured development reports.

Before building the full platform, we want to validate the AI/video analysis part through a technical feasibility study and small prototype.

What We Need in This Phase
==========================

We are looking for an experienced AI / Computer Vision / Sports Analytics expert to help us:

* Review the concept and suggest the best technical approach
* Analyze what can be automated using AI and what may require human review
* Define the required video recording standards
* Build a small prototype using sample football videos
* Detect or track players where possible
* Identify key football actions or clips where possible
* Suggest how to structure player performance metrics
* Recommend the best AI architecture for the MVP
* Provide a clear roadmap for the next development phase
* Estimate time, cost, risks, and technical limitations

Important Context
=================

We are specifically looking for someone with real experience in video AI, computer vision, sports analytics, or similar systems.
We do not expect to copy these platforms, but we want to understand what is realistic and how to build a focused MVP.

Ideal Experience
==============

* Computer Vision
* Sports video analytics
* Player tracking
* Object detection
* Action recognition
* Football/soccer analytics
* OpenCV
* YOLO
* DeepSORT / ByteTrack
* Pose estimation
* Video processing pipelines
* AI report generation
* Previous sports AI projects

Deliverables
============

1. Technical feasibility document
2. Recommended AI architecture
3. Prototype using sample football video
4. Clear list of what is possible now vs later
5. Required video recording guidelines
6. MVP roadmap
7. Estimated cost and timeline for the next phase

Screening Questions
=================

1. Have you built any sports video analysis or player tracking project before? Please share examples.
2. What approach would you use to analyze a football player from match footage?
3. What are the biggest technical challenges in football video analysis?
4. Can AI fully analyze a football match without human review? If not, where would you add human validation?
5. What video conditions would you require for accurate analysis?
6. Which models/tools would you consider using?
7. Can you build a small prototype before the full platform?

I need a complete system that can turn data written in the ancient Brahmi and Sharda scripts into a scannable, QR-style matrix and then read it back reliably. The work splits into two tightly linked parts:

1) Pattern engine
Build an algorithm that takes Brahmi or Sharda text (Unicode strings supplied by me) and outputs a square, high-contrast image resembling a QR code. Include error-correction logic so the pattern survives moderate camera tilt, blur, and 20 % visual noise. A lightweight CLI or library in Python, Java, or C++ is fine as long as I can call it from other projects later.

2) Dual-platform scanner
Create an app for both iOS and Android whose main task is to scan and decode these patterns. After scanning, the screen should show an informative read-out: the detected script, original text, romanised form, and any embedded metadata. Users won’t create codes inside the app for now—scanning and decoding is the priority.

Key capabilities
• Fast camera preview with live detection
• Automatic perspective correction, de-skew, and brightness adjustment (OpenCV, ML Kit, or similar)
• On-device decoding in under 500 ms for a 300×300 px pattern
• Clear feedback when a scan fails and suggestions to improve focus or lighting

Deliverables
• Source code for the generator module and mobile apps
• Build/run instructions plus a short video demo
• Sample patterns and a test report showing ≥95 % decode accuracy across 100 varied photos

If you are fluent in image processing, computer vision, and cross-platform mobile frameworks such as Flutter, React Native, or native Swift/Kotlin—and you’re excited by the idea of reviving ancient scripts in modern tech—I’d love to work with you.

Skills: Python, Mobile App Development, Android, C++ Programming, Image Processing, OpenCV, iOS Development, Computer Vision

# Python AI Developer Needed to Build Whatnot Live Sales Tracker

## Overview

We are looking for a Python developer with experience in OCR, AI automation, and dashboard development to build a custom application for our live selling business.

We sell products on Whatnot and want a system that can watch our screen during a live show and automatically record what items sold and for how much.

## Project Goal

Create a desktop application that monitors the Whatnot screen in real time and captures:

* Item number
* Item description
* Buyer username
* Final sale price
* Time sold
* Show name

The system should save the information into a database or Google Sheets and display a live dashboard during the show.

## Desired Features

### Phase 1

Monitor the Whatnot screen and detect:

* Item number
* Sold price
* Buyer name

Export information into Google Sheets.

### Phase 2

Connect to an inventory database containing:

* SKU
* Description
* Purchase cost
* Brand
* Category

Automatically calculate:

* Revenue
* Cost of goods sold
* Profit per item
* Average sale price

### Phase 3

Create a live dashboard showing:

* Total revenue
* Number of items sold
* Average sale price
* Gross profit
* Top buyers
* Best categories

### Phase 4

Generate reports after each show.

## Technical Skills Preferred

Python

OpenCV

OCR

Tesseract

Screenpipe

Google Sheets API

SQLite or PostgreSQL

Streamlit

ChatGPT API or Claude API

Experience with AI automation and computer vision is highly preferred.

## Deliverables

* Working desktop application
* Source code
* Installation instructions
* Documentation
* Ability to expand features in the future

## Budget

Open to fixed price or hourly.

## Bonus

Experience with:

* Whatnot
* eBay
* Shopify
* Poshmark
* Inventory systems
* Reseller software

## About Us

We are a growing live-selling business operating multiple weekly shows across Whatnot, Shopify, eBay, and Poshmark. We are looking for someone who can become a long-term technology partner and continue improving the platform over time.

We are seeking a high-level Computer Vision and Mathematical Modeling Engineer to completely overhaul and refactor the core tracking architecture of our sports performance platform, eTrack.

Our app analyzes athletic tests—specifically Sprints, Countermovement Jumps (CMJ), and Drop Jumps—from high-speed smartphone videos (up to 240fps).

The legacy backend relies on a primitive, rigid 2D pixel-grid comparison logic (comparing bounding box centers frame-by-frame). This approach is fundamentally broken as it fails under camera angle changes, lens parallax, and perspective distortion on the field. We need a professional who does not rely on pixel-matching shortcuts.

Key Responsibilities & Architectural Requirements:
1. 3D Spatial Calibration & Homography: Implement space calibration (Perspective transformation / Homography matrix mapping) using fixed environmental markers (e.g., cones, hurdles, track lines). The system must project 2D camera coordinates into a normalized 3D World Coordinates System (meters/seconds) to ensure pitch-invariant and angle-invariant accuracy.
2. Digital Signal Processing (DSP) & Jitter Filtering: Treat raw tracking outputs (MediaPipe/YOLO Pose) as a continuous signal. You must implement advanced filtering (e.g., Butterworth low-pass filters or Kalman filters) to eliminate high-frequency landmark jitter, ensuring raw mathematical precision down to the millisecond.
3. Finite State Machine (FSM): Drive a robust, production-ready Python state machine to precisely detect biomechanical phase transitions (e.g., ground contact times, flight times, exact gate-crossing frames).
4. API Integration: Package this mathematical logic into a clean, lightweight, and optimized FastAPI backend designed to process videos efficiently without server crashes.

Requirements:
- Degree or strong background in Applied Mathematics, Robotics, Physics, or Computer Vision.
- Proven track record of building human motion analysis or gait/running biomechanics software.
- Master level with OpenCV, MediaPipe, NumPy, SciPy, and signal processing libraries.
- Strictly individual freelancers or dedicated technical leads only. No generalist agencies, no front-men selling outsourced work.

• Link your GitHub/Colab with a real project where you personally implemented spatial calibration (Homography/Perspective projection) or advanced signal filtering (Butterworth/Kalman). (No copied forks or generic web portfolios).
• How would you process a 240fps diagonal video to get the exact millisecond an athlete crosses a sprint gate? Which mathematical approach will you use to normalize the perspective distortion and raw tracking jitter? Briefly explain.
• Describe your recent experience with similar projects

We need slight modifications for an image that will be printed on totes. The task is urgent and must be completed within the hour. The ideal candidate should have experience in graphic design and image editing, ensuring the final product is print-ready and meets our quality standards.

I am building FZYX, an offline AI business monitoring system for playgrounds, gyms, and pools.

I need a serious Computer Vision developer/team to build the first milestone using my own video file.

First milestone requirements:

* Detect adults vs children
* Track each person
* Avoid double counting
* Count entries/exits using line crossing
* Handle occlusions as much as possible
* Export structured JSON events
* Run locally/offline using Python/OpenCV/YOLO or similar tools

Later milestones:

* Live RTSP camera support
* Custom zones
* Dashboard
* Database
* WhatsApp reports
* Payment-behavior analysis using cashier-zone dwell time, drawer opening, and group linking

Important:

* Fixed-price milestone only
* Weekly demo required
* GitHub commits required
* Clear documentation required
* No full payment before working demo

Please apply only if you have experience with:
Python, OpenCV, YOLO/Ultralytics, RTSP, object tracking, ByteTrack/BoT-SORT, line crossing, and real-time video analytics.

• 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

We are looking for an experienced Backend / Computer Vision Developer to build an independent Image Quality Assessment Module for document verification workflows.

The goal of the module is to validate document images before they are sent to the downstream forensic or OCR processing pipeline. The service should determine whether an uploaded document image is suitable for processing, needs to be resubmitted by the user, or should be rejected due to fundamental quality or authenticity issues.

The module must operate as an independent backend quality gate with its own API endpoint, scoring logic, and decisioning mechanism.

**Main Scope of Work:**
Develop a backend image quality assessment service capable of analyzing uploaded document images and detecting quality-related issues such as:

* Invalid, corrupted, incomplete, or unsupported image files
* Missing document, wrong document type, selfie, screenshot, blank page, or unrelated image
* Cropped, partially captured, incomplete, or multiple documents in one image
* Incorrect orientation, rotation, tilt, and perspective distortion
* Low sharpness, poor brightness, low contrast, insufficient resolution
* Glare, reflections, shadows, uneven lighting, and color distortion
* Fingers, stickers, tape, physical obstructions, annotations, overlays, scribbles, or digital markings
* Screen recaptures, photocopies, printed reproductions, and heavy compression artifacts
* Field-level readability issues affecting critical document areas

**Required Functionality:**

1. **Image Intake & Validation**
The system should validate JPEG, PNG, and WebP files using proper file signature / magic byte checks, not only MIME type validation. It should detect corrupted, renamed, or truncated files before processing.

2. **Document Detection & Completeness**
The service should detect the presence of a document in the image, identify its boundaries and corners, and verify whether the full document is visible and properly captured.

3. **Document Type & Side Awareness**
The module should accept parameters such as document type, side, and language in each request. It should support different document types such as identity cards, passports, and legacy IDs, with document-specific thresholds and field region maps.

4. **Image Quality Metrics**
The system should calculate image quality indicators such as sharpness, brightness, contrast, resolution, tilt, perspective distortion, glare, shadow, and compression artifacts.

5. **Per-Field Quality Analysis**
The module should analyze critical document regions independently, such as document number, name, surname, date of birth, photo area, issue/expiry dates, MRZ zone, and other document-specific fields.

Each field should receive its own quality score and pass/fail assessment.

6. **OCR Readability Estimation**
The system should estimate whether text extraction would be successful for critical regions. This can be implemented using local OCR tools such as Tesseract OCR, without external cloud APIs or per-image costs.

7. **Decisioning & Output**
The API should return:

* Overall quality score from 0 to 100
* Final verdict: PASS, RESUBMIT, or REJECT
* Per-check breakdown
* Per-field breakdown
* Failed checks
* Primary failure reason
* User-facing feedback message
* Technical/developer-facing details
* Actionable guidance for the user

8. **Multilingual Feedback**
Initially, the module should support user-facing messages in English and Greek.

9. **Developer Playground / Testing Interface**
A simple developer playground or test interface is required, where sample images can be uploaded and the full quality breakdown can be reviewed interactively.

10. **Deployment & Handover**
The final delivery must include:

* Complete source code
* API documentation
* Deployment documentation
* Docker support
* Integration support
* Knowledge transfer session

**Preferred Technology Stack:**

* Python
* OpenCV
* NumPy
* SciPy
* scikit-image
* Pillow
* Tesseract OCR
* REST APIs
* Docker
* Helm charts, if applicable

**Important Technical Requirements:**

* All processing must run locally on the server.
* No external API calls.
* No cloud vision services.
* No AI model dependency unless clearly justified and approved.
* No per-image processing cost.
* The service should be suitable for integration into an existing KYC / document verification workflow.

**Expected Deliverables:**

* Fully functional backend Image Quality Assessment service
* REST API endpoint with documented request/response structure
* Quality scoring and PASS / RESUBMIT / REJECT decisioning
* Per-field quality analysis
* OCR readability estimation
* Greek and English feedback messages
* Dockerized deployment package
* Source code and technical documentation
* Testing and calibration support using sample images

**Ideal Candidate:**

We are looking for a developer with strong experience in:

* Computer vision
* Document image processing
* OpenCV
* OCR / Tesseract
* Backend API development
* Python
* Docker-based deployments
* Image quality assessment
* Document verification or KYC workflows

Experience with identity documents, passports, OCR pipelines, or fraud detection systems will be considered a strong advantage.

I want to build a simple yet reliable mobile application that lets my field-workers mark their attendance the moment they snap a photo. The app must run smoothly on both Android and iOS and use face-recognition to validate each selfie automatically. As soon as the match is confirmed, the system should time-stamp the record and tag the exact GPS coordinates so I can verify where the employee was standing when the photo was taken.

Core flow
1. Worker opens the app, the camera launches instantly.
2. They take a photo; the face-recognition engine checks it against a stored profile.
3. If the face matches, attendance is logged right away together with latitude, longitude and time.
4. All data syncs to a secure back-end; if the phone is offline it queues the record and uploads once a connection returns.

Deliverables
• Production-ready Android (Kotlin/Java) and iOS (Swift) builds.
• Shared codebase or separate projects—whichever you recommend for maintainability.
• Integrated facial recognition module (OpenCV, ML Kit, FaceID, or your preferred library) tuned for fast, on-device verification.
• Geo-location capture with accuracy within roughly 10 m.
• Simple admin API or lightweight dashboard where I can review daily logs and export them in CSV/JSON.
• All source code, build instructions, and a brief hand-over session.

Acceptance criteria
• Successful face match and GPS stamp recorded in under five seconds on a mid-range device.
• False-accept rate below 1 % in normal lighting.
• Works on Android 9+ and iOS 13+.

I’m open to your technical suggestions—as long as the worker simply takes a photo and their attendance appears instantly, we’re on the right track.
application work on also computer

Skills: PHP, Mobile App Development, iPhone, Android, Geolocation, Face Recognition, Kotlin, OpenCV, iOS Development, Computer Vision

# Senior Robotics Engineer Needed for Autonomous Construction-Site Rover — ROS2, 2D or 3D LiDAR

## Project Overview

We have already designed and built a mobile rover and are looking for an experienced robotics engineer or robotics team to develop and integrate its autonomous navigation system.

The rover will operate inside active construction sites and perform a predefined inspection route every day. During each mission, it must navigate autonomously, avoid workers and obstacles, capture photos and videos at selected locations, and return safely to its starting position.

The desired functionality is similar to LiDAR-based robotic vacuum cleaners, but adapted to the more challenging conditions of a construction site.

We are open to solutions using either:

* 2D LiDAR;
* 3D LiDAR;
* or a combination of LiDAR, cameras, IMU, wheel encoders, and other sensors.

Applicants should recommend the most appropriate sensor and software architecture based on reliability, cost, implementation time, and the operating environment.

## Main Mission

The rover should be able to:

* Map the construction site.
* Localize itself within the mapped environment.
* Follow a predefined daily inspection route.
* Navigate through a sequence of waypoints.
* Detect and avoid static and moving obstacles.
* Detect or safely react to workers moving around the rover.
* Stop, wait, or replan when its route is blocked.
* Capture photos and videos at predefined positions or intervals.
* Associate collected media with timestamps and, where possible, map coordinates.
* Complete the inspection mission autonomously.
* Return to its original starting position or docking area.
* Recover safely from common navigation failures.
* Allow manual remote control when necessary.
* Record logs for diagnostics and troubleshooting.

## Operating Environment

The rover will operate in active construction sites, where conditions may include:

* Workers and other moving people.
* Temporary obstacles.
* Construction materials and equipment.
* Frequently changing site layouts.
* Narrow passages.
* Dust.
* Changing lighting conditions.
* Indoor, semi-indoor, or GPS-denied areas.
* Uneven or unfinished surfaces.

The initial implementation may begin in a controlled section of a construction site before being expanded to more complex operating conditions.

## Technology and Sensor Approach

We have not made a final decision between 2D and 3D LiDAR.

Applicants are encouraged to propose one of the following:

* A cost-effective 2D LiDAR navigation solution.
* A 3D LiDAR solution for improved perception of uneven terrain and obstacles at different heights.
* A hybrid solution combining LiDAR, depth cameras, standard cameras, IMU, and wheel encoders.

Your proposal should explain:

* Whether you recommend 2D or 3D LiDAR.
* Why your proposed approach is appropriate for a construction site.
* The expected advantages and limitations.
* The required hardware.
* The approximate hardware cost.
* The expected implementation complexity.
* Whether the existing rover hardware is likely to be sufficient.

We are open to ROS2 and Nav2-based solutions, as well as other proven robotics frameworks, provided the complete source code and documentation are delivered to us.

## Possible Technical Scope

The project may include:

* Assessment of the existing rover hardware and electronics.
* ROS2 architecture and package development.
* Motor-controller integration.
* Wheel encoder and IMU integration.
* Velocity and PID motor control.
* Wheel odometry and sensor fusion.
* URDF and TF configuration.
* 2D or 3D LiDAR integration.
* SLAM and map generation.
* Localization using a saved map.
* Nav2 configuration and tuning.
* Global and local path planning.
* Waypoint-based mission execution.
* Dynamic obstacle avoidance.
* Human detection or safe human-aware navigation.
* Dynamic replanning.
* Behavior Trees and recovery actions.
* Camera integration.
* Automated photo and video capture.
* Mission scheduling.
* Return-to-start or return-to-dock functionality.
* ROS bag recording and diagnostic logging.
* Simulation before real-world deployment.
* Deployment on NVIDIA Jetson or another onboard computer.
* Remote monitoring and basic operator controls.
* Real-world testing and tuning.
* Documentation and knowledge transfer.

## Required Experience

We are looking for someone with proven hands-on experience in:

* ROS2.
* Nav2 or an equivalent autonomous-navigation framework.
* SLAM and localization.
* 2D and/or 3D LiDAR.
* Physical autonomous mobile robots.
* Differential-drive or skid-steer platforms.
* Wheel odometry and IMU sensor fusion.
* URDF and TF.
* Embedded motor-control systems.
* NVIDIA Jetson or similar onboard computers.
* Real-world robot testing and debugging.
* Obstacle avoidance and navigation recovery.

Experience with any of the following is valuable:

* slam_toolbox.
* AMCL.
* RTAB-Map.
* Cartographer.
* LIO-SAM or similar LiDAR-inertial systems.
* Robot Localization.
* Behavior Trees.
* OpenCV.
* Depth cameras.
* Person detection.
* Autonomous inspection robots.
* Construction or industrial robotics.
* Autonomous docking and charging.
* Cloud monitoring and telemetry.

## Expected Deliverables

The final deliverables should include:

1. Technical assessment of the existing rover.
2. Recommended 2D or 3D LiDAR architecture.
3. List of required sensors, components, and hardware changes.
4. Complete autonomy-system design.
5. Working ROS2 or equivalent software repository.
6. Manual teleoperation and emergency-stop functionality.
7. Reliable odometry and localization.
8. Mapping of the operating environment.
9. Autonomous route and waypoint navigation.
10. Obstacle and human avoidance.
11. Automated photo and video capture.
12. Return-to-start functionality.
13. Navigation recovery behaviours.
14. Mission and diagnostic logging.
15. Deployment on the physical rover.
16. Real-world construction-site testing.
17. Source-code handover.
18. Installation, operation, and troubleshooting documentation.
19. Final demonstration of the complete autonomous mission.
20. Technical handover and training.

## Target Acceptance Test

The rover should demonstrate that it can:

* Start from a defined location.
* Localize itself within the mapped construction site.
* Execute a predefined route without manual driving.
* Reach selected photo and video capture points.
* Safely react to people entering its path.
* Avoid or navigate around temporary obstacles.
* Replan when the original route is blocked.
* Stop safely when navigation cannot continue.
* Complete the inspection mission.
* Return to its original starting position.
* Produce logs that can be used to diagnose any failure.
* Repeat the mission reliably during multiple test runs.

The final quantitative acceptance criteria will be agreed upon with the selected engineer before implementation.

## Proposal Requirements

Please submit a detailed proposal containing:

1. Your recommended technical approach.
2. Whether you recommend 2D LiDAR, 3D LiDAR, or a hybrid solution.
3. The reasons for your sensor recommendation.
4. A proposed software and hardware architecture.
5. A list of any additional hardware required.
6. Estimated hardware costs.
7. Your implementation timeline.
8. The estimated time required for:

* Initial hardware assessment.
* First autonomous demonstration.
* Working MVP.
* Construction-site testing.
* Final stable delivery.
9. A milestone-based implementation plan.
10. Your financial offer for each milestone.
11. Your total estimated project cost.
12. Whether your offer is fixed-price or hourly.
13. Your weekly availability.
14. Any travel or on-site support requirements.
15. The level of remote support you can provide.
16. Examples of similar physical robots you have developed.
17. Videos, GitHub repositories, case studies, or technical documentation from previous projects.
18. A clear description of the parts you personally implemented.

Please identify any technical risks or unknowns that could affect the price or timeline.

## Suggested Milestones

Applicants may propose their own milestone structure. A possible structure is:

### Milestone 1 — Technical Assessment and Architecture

* Review the existing rover.
* Inspect motors, controllers, encoders, sensors, computing hardware, and communications.
* Recommend a 2D or 3D LiDAR solution.
* Produce the final implementation plan and hardware list.

### Milestone 2 — Base Robot Integration

* Motor control.
* Manual driving.
* Encoders and IMU.
* Odometry.
* URDF and TF.
* Emergency stop.
* Data recording.

### Milestone 3 — Mapping and Localization

* LiDAR integration.
* SLAM.
* Map creation.
* Localization.
* Initial testing in a controlled environment.

### Milestone 4 — Autonomous Navigation

* Route and waypoint execution.
* Obstacle avoidance.
* Dynamic replanning.
* Recovery behaviours.
* Return-to-start functionality.

### Milestone 5 — Inspection and Media Capture

* Camera integration.
* Automated photo and video capture.
* Timestamping and mission-data storage.
* Complete daily inspection workflow.

### Milestone 6 — Construction-Site Testing and Handover

* Real-world testing.
* System tuning.
* Reliability testing.
* Documentation.
* Source-code handover.
* Operator training.

## Important

This is a real-world robotics project, not a simulation-only assignment.

Please do not apply if your experience is limited to university projects, tutorials, or Gazebo simulations without deployment on physical autonomous robots.

We are looking for an engineer or team that can take responsibility for the complete implementation, testing, and delivery of a reliable autonomous rover.

The project should begin with a paid technical assessment. After the assessment, the selected applicant should confirm the final project price, milestones, hardware requirements, and implementation timeline.