Find OpenCV Projects on Upwork with Vollna

We are looking for an experienced Computer Vision Engineer to urgently audit a drive-by dataset collected for a vegetation and roadside-monitoring project.

This is the first phase of a larger computer-vision project. We are looking for someone who can start immediately and, if the audit is completed successfully, continue with us on a long-term basis for annotation, model fine-tuning, evaluation and implementation.

Project background

The dataset contains approximately 1 hour and 40 minutes of drive-by recordings.

The available data may include:

- RGB images or video frames;
- frame and chunk identifiers;
- GPS coordinates;
- timestamps;
- route information;
- LiDAR data or LiDAR-derived height statistics;
- YOLO-World object-detection output;
- SegFormer vegetation-segmentation output;
- JSON and GeoJSON files;
- previously identified false positives.

The purpose of the audit is to determine:

- what data is actually available;
- how much of the data is usable and unique;
- which classes are sufficiently represented;
- whether the existing model outputs are useful;
- whether GPS and LiDAR can be linked reliably;
- what is required for a representative annotation and model-training pilot.

Scope of the audit

1. File and dataset inventory

Identify and document:

- all available files and formats;
- total number of videos, chunks and frames;
- available RGB, GPS, LiDAR, JSON and GeoJSON data;
- missing, corrupted or unreadable files;
- links between frames, chunks, routes and sensor data.

2. Image-quality assessment

Assess the dataset for:

- motion blur;
- poor focus;
- compression issues;
- shadows and backlighting;
- distance from relevant objects and vegetation;
- visibility of roadsides, vegetation and fixed obstacles;
- unusable or low-quality frames.

This may be performed using scripts combined with a representative manual review. We do not expect every frame to be reviewed manually.

3. Duplicate and redundancy analysis

Determine:

- how many identical or near-identical frames are present;
- how much redundancy exists within and between chunks;
- whether locations or route sections were recorded repeatedly;
- how the dataset can be reduced to representative frames;
- which frame-selection method should be used instead of automatically selecting every fifth frame.

4. Location-based dataset structure

Review:

- GPS coordinates and timestamps;
- unique locations and routes;
- repeated locations and route overlap;
- whether training, validation and test data can be separated by location;
- how data leakage between near-identical frames and locations can be prevented.

5. Preliminary class distribution

Assess whether the data contains usable examples of the following categories.

Fixed mowing obstacles

- tree trunks;
- posts, bollards and lamp posts;
- traffic signs;
- fences, gates and guardrails;
- benches and picnic tables;
- utility cabinets, mailboxes and hydrants;
- large rocks or boulders;
- culverts and bridge structures;
- other permanent mowing obstacles.

People, animals and moving vehicles are outside the target scope.

Vegetation

- short or mown grass;
- tall roadside vegetation;
- reed or watercourse vegetation;
- woody vegetation;
- cut vegetation or temporary vegetation deposits;
- bare or recently mown ground;
- other or uncertain vegetation.

The audit should indicate:

- which classes occur;
- estimated example counts per class;
- which classes have insufficient data;
- which classes should initially be grouped;
- which classes are not visually distinguishable with the available image quality.

6. Existing model-output review

Review a representative sample of the available:

- YOLO-World detections;
- SegFormer segmentations;
- confidence scores;
- false positives;
- missed objects or vegetation regions.

Determine whether the existing outputs are suitable for automatic pre-annotation and whether correcting them is likely to be faster than annotating from scratch.

No model fine-tuning is required during this audit unless separately agreed.

7. GPS and LiDAR assessment

Determine:

- whether timestamps are consistent;
- whether LiDAR data can be linked to the correct frames, chunks and locations;
- whether the available calibration and sensor information is sufficient;
- whether LiDAR can support vegetation-height analysis;
- whether reliable use is possible at pixel, frame, chunk or location level;
- which technical limitations or missing information exist.

The audit does not include development of a complete RGB–LiDAR fusion pipeline unless separately agreed.

8. Pilot recommendation

Based on the audit, provide a clear recommendation for the next pilot phase, including:

- recommended number of pilot frames;
- frame-selection method;
- proposed final class structure;
- proposed annotation approach;
- location-based training, validation and test split;
- estimated annotation effort;
- expected technical risks;
- additional data that may be required;
- estimated scope and cost of the next phase.

Required deliverables

The final audit must include:

1. documented dataset inventory;
2. counts of available, usable, unusable and duplicate data;
3. overview of unique routes and locations;
4. image-quality findings;
5. preliminary class distribution;
6. review of existing YOLO-World and SegFormer outputs;
7. assessment of GPS and LiDAR usability;
8. recommended frame-selection strategy;
9. recommended pilot dataset;
10. proposed train, validation and test structure;
11. estimated annotation effort;
12. technical risks and missing information;
13. recommended next steps;
14. concise written audit report;
15. all scripts used to produce the audit results.

All findings must be reproducible and based on the supplied data.

Data-integrity requirement

We will independently verify:

- file and frame counts;
- duplicate percentages;
- class counts;
- GPS and route findings;
- model-output observations;
- samples used in the report;
- scripts and generated outputs.

Do not present invented, synthetic or estimated findings as measured results.

Every estimate must be clearly labelled as an estimate and must include the method, sample or assumption on which it is based.

Fabricated data, unverifiable metrics, manipulated screenshots or non-reproducible conclusions will result in immediate rejection of the work and termination of the contract.

Required experience

You should have demonstrable experience with:

- computer-vision datasets;
- Python;
- OpenCV;
- YOLO or comparable object-detection models;
- semantic segmentation;
- SegFormer or comparable segmentation models;
- dataset-quality audits;
- duplicate and near-duplicate image detection;
- train, validation and test dataset design;
- GPS or geospatial data;
- JSON and GeoJSON.

Experience with LiDAR, camera–LiDAR calibration or sensor fusion is strongly preferred.

Urgency and availability

This is an urgent assignment.

Please apply only if you can:

- start immediately or very soon;
- work directly with the supplied raw data;
- communicate progress clearly;
- provide reproducible findings;
- state your expected completion date before starting.

Long-term opportunity

This audit is the first part of a broader project.

A successful audit may lead to further work involving:

- annotation strategy and quality control;
- object-detection fine-tuning;
- vegetation segmentation;
- LiDAR-assisted height analysis;
- false-positive reduction;
- GPS and GeoJSON output;
- evaluation on unseen locations;
- production-pipeline development.

We are specifically looking for a reliable specialist for a long-term cooperation.

Application questions

Please answer the following questions:

1. Describe one dataset audit you completed for a computer-vision project.
2. How would you identify duplicate and near-duplicate frames in a long drive-by recording?
3. How would you prevent data leakage between training and test data?
4. What would you check before using LiDAR data together with RGB images?
5. How would you determine whether existing model output is suitable for pre-annotation?
6. How many hours do you estimate for this audit?
7. What fixed price do you propose?
8. When can you start?
9. What exactly will you deliver at the end of the audit?

I have a date annotation task provided by Innodata, and I am offering a payment of around $1 to $2 on a monthly basis. The task requires attention to detail and familiarity with data annotation tools. If you have experience in data entry or similar tasks, I would love to hear from you.

I am looking for an experienced vending machine location finder to identify and secure high-traffic, high-footfall locations within a 10-mile radius. The ideal candidate will have a strong understanding of local markets and be able to analyze foot traffic patterns to suggest optimal placement for vending machines. This role requires excellent communication skills and the ability to negotiate with potential location owners.
I am looking for an experienced UK-based B2B sales professional to help grow my vending business, Staff Refuel.

We provide businesses with a completely free workplace vending solution:
✅ Free vending machine installation
✅ Free servicing and maintenance
✅ Free restocking
✅ No cost to the business

Our target customers are:

- Factories
- Warehouses
- Offices
- Gyms
- Car dealerships
- Apartment buildings
- Hospitals and large workplaces

Your role:

- Research suitable businesses in Greater Manchester
- Find the decision maker (owner, facilities manager, office manager)
- Cold call and introduce our service
- Handle objections
- Book site surveys/appointments
- Follow up with interested companies until agreements are secured

Ideal candidate:

- Native UK English speaker (British accent preferred)
- Proven B2B cold calling experience
- Experience booking appointments or closing business deals
- Confident speaking with business owners and managers
- Self-motivated and results driven

I will provide:

- Website
- Business email
- Company information
- Pitch details
- Photos of machines
- Target areas

Target area:
Bolton, Bury, Wigan, Manchester and surrounding areas.


This is a long-term opportunity for the right person. I am looking for someone who can become a valuable sales partner, not just make random calls.

Please include:

1. Your B2B sales experience
2. Examples of similar campaigns you have worked on
3. How you would approach getting our first 10 vending locations
4. Your expected hourly rate

We’re creating a professional, next-gen, cross-platform audio application using C++ and JUCE. The role involves building a high-performance, user-friendly interface for audio processing and analysis. The ideal candidate will have experience in developing cross-platform applications and a strong understanding of audio signal processing.

Format: Live pair programming only, via VS Code Live Share (screen share, both coding in real time).

Job Description:

If this budget isn't right for you, feel free to message with advice or pointers anyway — happy to hear from people with relevant experience.

I want to improve my C++ skills for low-latency/performance-critical work (HFT-adjacent), with an experienced mentor, hands-on. We build a simplified low-latency order matching engine in C++ together, from scratch, over 30 sessions, live in VS Code Live Share, using CMake and Google Benchmark to profile changes as we make them.

Topics to cover:

Core low-latency C++ — memory layout, cache-line alignment, false sharing, avoiding hot-path allocations, custom allocators, lock-free data structures, atomics and memory ordering
Order book / matching engine design — price level structures, order lifecycle (add/cancel/match), implementation trade-offs
Benchmarking & profiling — finding real bottlenecks, measuring latency properly
Testing — unit testing performance-critical code, correctness testing under concurrency

Format:

30 x 1-hour sessions, live pair programming (VS Code Live Share, screen share)
2-3x/week
Code review on work done between sessions

Ideal mentor:

Demonstrable experience with performance-critical, low-latency, quantitative, or real-time systems (trading, simulation, embedded, or similar)
Can explain trade-offs, not just write code
Can structure a multi-session build progressively

Apply with:

A GitHub repo or brief description of relevant past work (low-latency/real-time/performance-critical code)
Rough phase breakdown for how you'd structure the 30 sessions
Availability and timezone


Please don't apply with a generic C++ pitch — only responding to proposals referencing specific relevant experience.

Process: quick message exchange first to confirm fit, then first milestone is 2-3 sessions before committing to the full 30.

Suggested skills: C++, Low Latency, Multithreading, Lock-Free Programming, Performance Optimization, Benchmarking, Quantitative Finance, Real-Time Systems, Software Architecture

I need someone to help with programming and renders for a 13-Acre mixed-use civic entertainment district I'm planning to build. The project requires expertise in urban planning and design to ensure a cohesive and functional layout. The ideal candidate will have experience in architectural rendering and programming to bring the vision to life.

Role: Full-Stack Systems & Edge AI Engineer

We are a Singapore-based startup building cutting-edge computer vision solutions for the food industry. We are seeking a hands-on, end-to-end engineer to take ownership of our pipeline—from edge-side data capture to cloud-based model training and deployment.

What You’ll Do:

Edge Pipeline Development: Architect and maintain low-latency inference pipelines using YOLO, BoT-SORT, and OpenCV to run reliably on edge hardware.

Cloud Infrastructure: Manage data flows between edge devices and GCP using rClone and Google Cloud Storage.

Data Ops: Streamline our annotation workflow using Label Studio (Dockerized) and curate high-quality datasets with FiftyOne.

Model Lifecycle: Leverage SAM 2 for advanced segmentation tasks and manage the full cycle of training, evaluation, and edge deployment.

System Integration: Develop robust, asynchronous backend services using FastAPI to connect our edge systems to the cloud.

Who You Are:

A pragmatic problem-solver who enjoys moving from prototype to production.

Experienced in navigating the trade-offs between edge hardware constraints and model performance.

Passionate about building scalable AI systems that solve real-world problems in the food industry.

I need someone to convert a jpeg/png file into a ready to stitch, exp or exp+ file, suitable for a Bernina 770 Quilters Edition Plus. Ideally, this will be done using Embrilliance SttichArtist (level 2), so that I can see if this software will work for me? Thank you, Joanne

Summary
Description:
We’re looking for an experienced AI Engineer or "Next-Gen" Full-Stack Developer to lead a 1-hour guided conversation with a 15-year-old homeschooling student.

The session should provide an engaging, hands-on introduction to how modern AI is transforming software development — shifting from traditional programming to prompt-driven development and autonomous agentic workflows.

The goal is to demystify how apps are built today using AI, moving past basic chatbot interactions to show the real-world logic of how software is designed, tested, and deployed using advanced AI tools.

Suggested Topics to Cover:

- Advanced Prompt Engineering for Coding: How to shift from simple questions to structuring high-level logical instructions that guide an AI to generate clean, functional code.
- The Power of Agentic Workflows: What an AI "agent" is, how it differs from a standard LLM, and how agentic systems autonomously plan tasks, use development tools, read error logs, and debug their own code.
- Next-Gen Development Tools: A brief look or demonstration of how cutting-edge tools (e.g., Cursor, v0.dev, Bolt.new, Replit Agent) allow developers to build entire web or mobile applications using natural language.
- The Evolving Role of a Developer: How the day-to-day job of a software engineer is shifting from syntax writing to system architecture, logic design, and problem-solving.

(You’re welcome to adapt or expand these topics based on your background.)

Requirements:

* Professional experience as an AI Engineer, LLM Application Developer, or Full-Stack Developer utilizing advanced AI coding workflows.
* Deep familiarity with agentic frameworks and modern AI-assisted development tools.
* Strong communication skills, with the ability to explain abstract logic and software concepts to a younger audience.
* Comfortable leading an interactive, conversational session (ideally featuring a short, live visual demonstration of building a simple feature or app using AI).

Logistics:

* Date: Friday, June 5 or Monday, June 8
* Time: 9am Pacific Time, US
* Duration: 1 hour
* Platform: Google Meet
* Budget: $40

Application Instructions:
If you’re excited about sharing your knowledge and experiences with an eager young learner, please apply with:

* A short summary of your professional background and the AI development tools you use daily.
* Your availability for the session.
* A brief idea of a simple, visual concept or mini-app workflow you could demonstrate during the session.

We run a free online image vectorizer (turns raster images like PNG/JPG into clean SVG vector files). We tested our output against a competitor and it was dramatically different — 29x larger files, jagged edges, thousands of unnecessary points where the competitor drew a simple clean shape. The core problem: our tool doesn't recognize basic shapes like circles and rectangles, so it clumsily traces around them instead of drawing them properly.
We need someone to fix this using classical computer vision (no AI/machine learning needed) — teach the tool to recognize shapes and simplify messy output into clean, minimal paths.
We also need three output modes for different customers: a "cutting" mode for Cricut/laser/embroidery machines (super clean, minimal points, exports to DXF), a "print" mode for products like t-shirts (solid colors, checks how big it can print), and an "edit" mode for designers (organized, easy to tweak).
You'd be building this as a standalone service — image goes in, files and quality stats come out. Someone else handles the website around it.
We have a real benchmark image and clear pass/fail criteria ready, so this is well-defined, testable work.

The long-term vision is to create something similar to Clutch Sports, where a fixed camera mounted behind the court automatically records matches and provides AI-powered analysis for players and clubs.

For the MVP, I'd like to focus on:

* Detecting and calibrating the court from a fixed camera
* Detecting and tracking all four players throughout the match
* Detecting and tracking the ball throughout rallies
* Automatically identifying the start and end of rallies
* Generating highlight clips from the match
* Building a backend REST API to process uploaded match videos

Over time, I'd like to expand the platform with more advanced features such as:

* Multi-object tracking for all players and the ball
* Player pose estimation and body joint tracking (shoulders, elbows, wrists, hips, knees, ankles, etc.)
* Shot recognition (volleys, bandejas, viboras, smashes, lobs, forehands, backhands)
* Estimating where the ball contacts the racket
* Detecting bounce locations and glass-wall rebounds
* Player movement analytics, distance covered, speed, and court positioning
* Heatmaps showing player positioning over time
* Automatic detection of winners, forced/unforced errors, and rally statistics
* Match summaries and AI-generated coaching insights
* Eventually, live processing rather than only post-match analysis

My plan is to start with a proof of concept using publicly available videos to validate the pipeline and architecture. Once the concept is working, I'll invest in dedicated hardware and install fixed cameras at clubs to collect my own footage and further improve and fine-tune the models for real-world deployment.

I'm looking for someone with strong experience in computer vision and video analytics, ideally with technologies such as PyTorch, OpenCV, YOLO, pose estimation, multi-object tracking (ByteTrack, DeepSORT, BoT-SORT, etc.), and sports analytics or fixed-camera systems.

I'm looking to hire someone who can design the technical architecture, recommend the best approach, and lead the development of the computer vision side of the project. I'd also value your input on what features are realistic for an initial MVP, how you would phase the development, and any hardware recommendations for a fixed-camera setup.

If this sounds like something you'd be interested in, I'd love to hear about your experience with similar projects and discuss how we could work together.

Expert iOS ARKit/LiDAR Engineer to Fix 3D Scanning and Measurement Drift
Project summary

We are looking for an expert native iOS developer with strong practical experience in ARKit, iPhone LiDAR, 3D reconstruction, computer vision and photogrammetry.

We have an existing iOS application that scans apartments using an iPhone or iPad equipped with LiDAR. The application currently generates:

A colored point cloud
A 3D mesh
A 2D apartment floor plan
Wall and room measurements
Individual room areas
Total apartment area
An interactive 3D viewer

The application is functional, but it currently has accuracy, reconstruction quality, drift and 3D-viewer problems.

We need an expert to audit the existing code, identify the root causes and implement measurable improvements. This is a technical 3D computer-vision assignment, not a general iOS UI-development project.

Current problems

The main problems include:

Accumulated measurement drift while scanning multiple rooms
Misalignment when returning to an area that was scanned earlier
Duplicate or overlapping walls
Inaccurate wall dimensions
Incorrect room and apartment-area calculations
2D floor plans that do not always match the 3D scan
Noisy or incomplete point clouds
Rough, unoptimized architectural meshes
Uneven walls, floors and ceilings
Poorly reconstructed corners, doors, windows and openings
Low-quality furniture reconstruction
Chairs and thin furniture appearing melted, damaged or incomplete
Blurry, stretched or incorrectly aligned textures
Bugs in model loading, camera controls and 3D navigation
Performance problems with larger apartment models
Crashes or excessive memory consumption in the 3D viewer
Project objective

The objective is to repair and improve the existing application so that it produces two aligned models.

Measurement model

The measurement model must contain clean and dimensionally reliable:

Walls
Floors
Ceilings
Doors
Windows
Openings
Room boundaries
Closed room polygons
Wall measurements
Room areas
Total apartment area

All measurements must be calculated from the optimized architectural geometry, not from a decorative visual mesh.

Visual model

The visual model must provide:

Clean architectural geometry
Attractive wall, floor and ceiling surfaces
High-quality textures
Improved furniture presentation
Consistent lighting and materials
Smooth and stable viewing performance

The measurement model, point cloud, visual mesh and 2D floor plan must remain aligned in the same coordinate system and metric scale.

Scope of work
1. Audit the existing application

The first task is to build and investigate the existing Xcode project.

The developer must:

Build and run the current application.
Reproduce the reported problems.
Review the ARKit session configuration.
Review camera, RGB, depth, IMU and timestamp synchronization.
Review coordinate systems and transformation matrices.
Confirm that metric units are used consistently.
Review how LiDAR depth is converted into world-space points.
Review the current point-cloud fusion method.
Review the current mesh-generation method.
Review wall, room and opening detection.
Review the 3D-to-2D floor-plan conversion.
Review room-area calculations.
Review RGB texture generation.
Review the 3D viewer and rendering architecture.
Profile CPU, GPU and memory usage.
Identify crash conditions and memory leaks.
Determine whether the current image-frame pipeline is true photogrammetry, RGB texturing or only tracking support.
Preserve existing failed scans as regression tests.

The audit must result in a written technical report explaining:

Problems reproduced
Root causes identified
Components that can remain
Components that require correction
Components that may require refactoring
Proposed implementation approach
Expected technical limitations
Proposed testing procedure
Realistic delivery schedule

Major development should begin only after the audit findings are reviewed.

2. Correct tracking and measurement drift

The developer must repair or implement a reliable capture and tracking pipeline using:

ARKit camera poses
LiDAR depth
Depth-confidence information
RGB camera frames
Camera intrinsics and calibration data
IMU/device-motion information
Accurate timestamps
Device orientation
ARKit tracking-quality information

The solution should include:

Monitoring of ARKit tracking quality
User warnings when tracking becomes unreliable
Pausing or limiting data integration during poor tracking
Guidance to maintain sufficient scan overlap
Selection and storage of useful keyframes
Detection of previously scanned areas
Relocalization
Loop-closure detection
Pose-graph optimization or an equivalent correction method
Rejection of incorrect loop closures
Geometric registration where appropriate
Rebuilding or reintegrating the point cloud after pose correction
Rebuilding the mesh after pose correction
Detection and merging of duplicated walls
Preservation of correct metric scale

The developer may recommend additional accuracy controls such as:

Printed coded targets
Known-distance measurements
Wall-to-wall constraints
Floor and ceiling constraints
Manual control points for difficult scans

If the current application modifies or replaces ARKit camera poses incorrectly, that behavior must be removed or corrected.

3. Improve point-cloud reconstruction

The point-cloud pipeline should be reviewed and improved using appropriate methods such as:

Depth-confidence filtering
Distance filtering
Temporal filtering
Statistical outlier removal
Radius outlier removal
Voxel downsampling
Correct world-coordinate transformations
RGB and depth alignment
Normal estimation
Multi-frame fusion
Duplicate-point removal
Registration-quality scoring
Preservation of architectural edges

The developer must evaluate whether the project should use:

TSDF fusion
Surfel fusion
Voxel-based fusion
A hybrid method
Another justified reconstruction approach

The final point cloud must:

Use the correct metric scale.
Remain aligned with the floor plan and mesh.
Avoid obvious duplicate walls.
Avoid severe floating noise.
Preserve useful architectural detail.
Remain manageable on the supported iPhone.
Export successfully in at least one agreed point-cloud format.
4. Correct 3D-to-2D floor-plan generation

The floor plan must be generated from optimized architectural geometry rather than from the raw mesh outline.

The developer must implement or repair:

Floor-plane detection
Ceiling-plane detection
Wall-plane detection
Grouping of observations belonging to the same wall
Stable plane fitting
Wall-intersection calculation
Corner generation
Door detection
Window detection
Opening detection
Multi-room alignment
Closed room-polygon construction
Invalid or incomplete room detection
Wall-length calculation
Room-dimension calculation
Individual room-area calculation
Total apartment-area calculation
Measurement-confidence reporting

Net room area should be calculated from the finished internal wall faces unless another measurement convention is agreed upon.

The application should automatically identify incomplete or low-confidence rooms rather than silently reporting inaccurate results.

A limited manual correction tool may be proposed for cases where full automation cannot produce a reliable result.

5. Generate a clean architectural mesh

The final mesh should look deliberately modeled rather than like an untreated LiDAR scan.

The developer must implement or improve:

Removal of floating triangles
Removal of duplicated geometry
Removal of severe spikes
Planar correction of walls
Planar correction of floors and ceilings
Clean wall intersections
Clean floor and ceiling connections
Clean door and window openings
Mesh-normal correction
Removal of inverted surfaces
Controlled hole filling
Mesh simplification
Level-of-detail generation
Mobile performance optimization

Mesh cleanup and simplification must not change the dimensions of the metric architectural model.

Before applying the final visual treatment to an entire apartment, the developer must provide one completed sample room for visual approval.

6. Produce high-quality textures and materials

The visual pipeline should include:

Selection of sharp RGB keyframes
Correct projection of RGB images onto optimized geometry
UV generation
Texture-atlas generation
Texture seam reduction
Exposure correction
Color correction
Reduction of stretched textures
Reduction of blurry textures
Appropriate wall, floor and ceiling materials
Mobile-optimized texture sizes
Suitable lighting and shadows
Ambient-occlusion support where practical

The visual textures must stay aligned after geometry and pose optimization.

7. Improve chairs and other furniture

Raw iPhone LiDAR often produces poor geometry for chairs, thin legs and complex furniture. The developer should not attempt to solve this only by smoothing the damaged raw mesh.

The preferred workflow is:

Detect or classify the furniture category.
Estimate its position, rotation and dimensions.
Remove or hide the damaged raw furniture geometry.
Select an appropriate high-quality model from an approved asset library.
Scale the model to match the detected dimensions.
Position and orient it correctly.
Allow the user to select another replacement model when necessary.

Initial furniture categories should include:

Chairs
Sofas
Tables
Beds
Desks
Cabinets
Wardrobes
Televisions
Kitchen units
Toilets
Sinks

Replacement furniture will be used for attractive visualization. It must not affect room measurements or apartment-area calculations.

Any third-party models, materials or software dependencies must be properly licensed for commercial use and disclosed before integration.

If exact reconstruction of a particular furniture item is required, the developer may propose a separate guided photogrammetry or object-capture workflow.

8. Confirm and improve photogrammetry functionality

The application may already save RGB frames during scanning. The selected expert must determine how these frames are currently used.

If photogrammetry is proposed or claimed, the developer must explain the implementation of:

Image quality and keyframe selection
Feature detection and matching
Camera-pose estimation
Structure-from-Motion
Bundle adjustment
Multi-view reconstruction
LiDAR and photogrammetry fusion
Texture generation

Simply extracting frames from a video does not constitute a complete photogrammetry pipeline.

The developer should recommend whether apartment-scale photogrammetry should run:

On the iPhone
On a Mac
On a backend processing service
As an optional high-quality mode
Not at all, if it does not provide sufficient benefit

Any backend or paid processing service requires approval before implementation.

9. Repair the 3D viewer

The developer must diagnose and fix reproducible viewer problems involving:

Crashes
Memory leaks
Excessive CPU usage
Excessive GPU usage
Slow loading
Incorrect scale
Incorrect orientation
Missing textures
Black surfaces
Incorrect normals
Z-fighting
Camera clipping
Orbit controls
Pan controls
Zoom controls
Models appearing outside the camera view
Freezing when switching models
Large apartment models

The final viewer should provide:

Orbit
Pan
Zoom
Reset camera
Fit model to screen
Top view
Perspective view
Room selection
Point-cloud visibility control
Measurement-model visibility control
Visual-model visibility control
Basic measurement inspection

The expected minimum performance target is stable interactive viewing at approximately 30 FPS on the agreed test device for the largest agreed apartment model.

10. Testing and validation

Testing will use three real apartments with different layouts.

Each apartment should be scanned multiple times using the same documented procedure.

Ground-truth measurements will be collected using a suitable laser distance meter.

The developer must provide:

A repeatable testing procedure
Baseline results from the current application
Final results after repairs
Measurement-error tables
Area-error results
Loop-closure results
Repeatability results
CPU, GPU and memory results
Before-and-after screenshots or videos
A list of remaining limitations
Target acceptance criteria

The following are proposed MVP acceptance targets. Any necessary changes must be explained and agreed during the audit milestone.

Measurement accuracy
At least 90% of tested wall measurements below 5 metres must be within ±3 cm of ground truth.
At least 90% of tested wall measurements from 5–10 metres must be within ±5 cm.
Individual room-area error must be within ±3%.
Total net apartment-area error must be within ±2%.
Repeated scans of the same apartment must produce total areas within 2% of one another.
Drift
Returning to the starting area should result in no more than 5 cm of closure error in the agreed test case.
Previously scanned rooms must not create visibly duplicated copies.
There should be no clearly visible duplicate architectural wall more than 3 cm from the corresponding wall.
Incorrect loop closures must not seriously deform the apartment.
Floor plan
Completed rooms must form valid closed polygons.
Connected rooms must use consistent walls and openings.
Measurements must remain consistent after saving and reopening.
Low-confidence results must be visibly identified.
Visual model
Walls should look straight and clean.
Floors and ceilings should look flat.
Corners and openings should be properly formed.
There should be no major spikes, double walls or inverted surfaces.
Textures should not be widely black, stretched or incorrectly projected.
Supported furniture categories should use clean visual representations.
Viewer
The viewer must complete a continuous 30-minute test without crashing.
All agreed camera controls must work.
Repeatedly opening and closing models must not cause uncontrolled memory growth.
The largest agreed model must remain usable on the test device.
Deliverables

The developer must deliver:

Complete updated source code
Working Xcode project
All new Swift, Objective-C++, C++, Metal and shader source files
Dependency and license list
Audit report
Architecture documentation
Coordinate-system and unit documentation
Reconstruction-pipeline documentation
Measurement-pipeline documentation
Test procedure
Baseline and final test results
Regression-test instructions
Reproducible build instructions
Deployment instructions
Known-limitations list
Thirty days of defect correction for work included in this contract

No undisclosed proprietary SDK, paid cloud service or restrictive software dependency may be added without approval.

Milestones
Milestone 1 — Technical audit: $500

Completed when:

The existing project builds.
Main problems are reproduced.
A root-cause report is delivered.
The repair plan is approved.
Milestone 2 — Tracking and drift correction: $1,750

Completed when:

Tracking-quality handling is implemented.
Loop closure or an equivalent correction is demonstrated.
Revisited-room duplication is corrected.
Agreed drift and repeatability tests pass.
Milestone 3 — Measurements and 3D quality: $1,500

Completed when:

Wall and room extraction is corrected.
Measurement and area tests pass.
A clean architectural mesh is generated.
The furniture-visualization workflow is demonstrated.
The sample-room visual target is approved.
Milestone 4 — Viewer, performance and exports: $750

Completed when:

Reproducible viewer bugs are fixed.
Performance and stability tests pass.
Agreed export formats work at the correct scale.
Milestone 5 — Final handover: $500

Completed when:

Complete source code is delivered.
The Xcode build is reproducible.
Documentation and test results are delivered.
Final acceptance testing is completed.
Required experience

Applicants must have demonstrated professional experience with:

Native iOS and Swift
ARKit and iPhone LiDAR
3D computer vision
Point-cloud and mesh processing
SLAM, relocalization or loop closure
3D rendering and performance optimization
Photogrammetry or RGB texture reconstruction

Experience with the following is highly desirable:

RoomPlan
RealityKit
SceneKit
Metal
OpenCV
Open3D or PCL
GTSAM or Ceres
C++ integration with Swift
TSDF or surfel fusion
ICP and point-cloud registration
USD/USDZ, GLB, OBJ or PLY
Working arrangement

The selected developer will work independently on the existing codebase and communicate progress through Upwork.

We will provide:

Access to the existing source code after the contract begins
Existing problem scans
Reproduction information
Test-device information
Ground-truth apartment measurements
Feedback on the sample visual model

We need the selected expert to provide technical guidance regarding the best reconstruction, loop-closure, furniture and texture approaches.

All communication and payments will remain on Upwork in accordance with Upwork’s rules.

I need a Python developer to build a real-time trading signal detector that runs on a Chromebook through the Linux development environment.

The system must open Chromium using Playwright, read the visible market price using OpenCV and OCR/Tesseract, and record price data every 0.2–0.5 seconds.

The detector will identify signals based on a custom strategy using:

* Price movement over the previous 90 seconds
* A short pullback during the final 5 seconds
* Exact 30-second candle timing
* HIGHER, LOWER, or NO TRADE alerts

The first version must only generate signals. It must not automatically execute real-money trades.

**Required features**

* Compatible with Chromebook and ChromeOS Linux
* Python-based application
* Chromium browser controlled through Playwright
* Real-time price extraction using OpenCV and Tesseract OCR
* Adjustable screen coordinates and OCR calibration
* HIGHER and LOWER visual and sound alerts
* CSV logging of prices, signals, timestamps, entry prices, expiration prices, and results
* Automatic calculation of win rate and performance statistics
* Demo-account testing
* Emergency stop function
* Simple user interface or clear terminal controls
* Reliable operation for at least two continuous hours

**Required experience**

* Python
* Playwright or Selenium
* OpenCV
* Tesseract OCR
* Linux
* ChromeOS or Chromebook development
* Real-time screen or browser automation
* Data logging and strategy backtesting

**Deliverables**

* Complete source code
* Installation and setup on my Chromebook
* Written setup instructions
* Explanation of how to change the strategy parameters
* Remote installation assistance
* Testing and debugging
* Full ownership of the code
* No hidden subscriptions or external dependencies requiring ongoing payment

**Suggested project milestones**

1. Correct real-time price reading
2. Reliable 30-second candle synchronization
3. Strategy signal detection
4. Alerts and CSV data logging
5. Automatic result tracking
6. Two-hour continuous demo test
7. Final Chromebook installation and documentation

Please include examples of similar Python, OCR, Playwright, or browser-automation projects you have completed. Do not apply unless you can provide the complete source code and install the finished system on a Chromebook.

We are looking for an experienced AI trainer who has successfully completed **Handshake AI "Hedgehog" assessments** and has hands-on experience managing AI training tasks on the platform.

This project involves **AI data annotation and evaluation work**, so applicants must have previous experience with:

* Handshake AI projects
* Hedgehog assessment and task completion
* AI training data annotation
* Data labeling and quality evaluation
* Following detailed AI task guidelines

**Requirements:**

* Must have successfully passed the Handshake AI Hedgehog assessment.
* Must have completed actual Hedgehog tasks on the platform.
* Must understand the workflow of Handshake AI projects.
* Must be reliable, detail-oriented, and able to maintain high-quality output.
* Availability during CST hours is preferred.

**Important:**
Please do **not apply** if you have no experience completing Hedgehog tasks or passing the Hedgehog assessment.

**When applying, please provide:**

1. A screenshot showing that you passed the Hedgehog assessment.
2. A screenshot or proof of completed Hedgehog task work (without sharing confidential project information).
3. The date when you passed your latest Hedgehog assessment.
4. The date when you completed your latest Hedgehog task.
5. A brief description of your Handshake AI experience.

We are looking for someone with proven experience who can start quickly and perform AI training tasks professionally.

We are looking for a senior AI software engineer to take over and complete an existing real-time AI project.

The system is designed to work as a live cohost during online broadcasts. It listens to the host, watches the video feed, identifies collectible cards, checks recent market prices, monitors chat, and responds through an AI-generated voice.

The project has already been started, but it needs an experienced engineer to review the current code, fix incomplete or unreliable parts, improve performance, and bring the system to production.

Main responsibilities:

- Review the existing codebase and current architecture
- Identify what is complete, what needs improvement, and what needs to be rebuilt
- Complete the real-time audio and video processing pipeline
- Improve speech recognition, response timing, and voice output
- Build natural turn-taking so the AI does not interrupt the host
- Improve card identification using computer vision
- Connect and manage market-price data sources
- Add chat monitoring, moderation, and engagement features
- Build short-term and long-term memory for conversations
- Improve system speed, reliability, logging, and error handling
- Add testing, deployment, monitoring, and technical documentation
- Support live testing and final production deployment

Required experience:

- Strong Python development skills
- FastAPI or similar backend framework
- Real-time audio, video, or streaming systems
- Speech-to-text and text-to-speech services
- WebSockets and asynchronous programming
- Computer vision, OpenCV, YOLO, or object detection
- PostgreSQL and Redis
- AWS deployment and infrastructure
- Experience working with AI APIs and production AI systems
- Strong debugging and performance optimization skills

Preferred experience:

- Node.js and TypeScript
- Next.js
- OBS or live-streaming integrations
- Deepgram, ElevenLabs, Cartesia, Anthropic, or OpenAI
- Live chat systems
- A/B testing and analytics
- Collectible-card recognition

This is not a prompt-engineering role. We need a senior engineer who can take ownership of a complex, partially completed system and deliver a reliable production solution.

When applying, please include:

- Examples of similar AI, voice, computer vision, or streaming projects
- Your experience taking over an existing codebase
- How you would review and stabilize the current system
- Your approach to reducing conversational response time
- Your availability

I need an AI video analytics software that specializes in face detection, person detection, and object detection.

Key functionalities required:
- **Face Detection:**
- Identifying individual faces
- Counting number of faces
- Emotional analysis

- **Person Detection**
- **Object Detection**

Ideal Skills and Experience:
- Proficiency in AI and machine learning
- Experience with video analytics and computer vision
- Strong programming skills (Python, TensorFlow, OpenCV)
- Knowledge in emotion recognition technologies

Please provide a portfolio showcasing similar projects.

Skills: Python, Software Architecture, Machine Learning (ML), C++ Programming, Face Recognition, OpenCV, Computer Vision, Object Detection

Hi,

I run a swiss AI consulting firm. One of my clients, an electrical planning office, marks up floor plans by hand — I want to automate this.

THE TASK

The client receives floor plans as PDFs (CAD exports). The tool should read such a PDF and return the same PDF with markings added on a separate layer:

- an X in the center of every room (drill/anchor point)
- a power outlet symbol in every room corner

I have a Python prototype (PyMuPDF + OpenCV) that shows the approach, but it does not work reliably yet. You can use it as a reference or start fresh — your call. What matters is a solution that works correctly on real plans.

REQUIREMENTS

- Runs locally or on cloud
- Handles typical variations (different CAD exports, multi-page PDFs)
- Simple to use for a non-technical client (command line is fine to start; a small upload UI could be phase 2)

I will provide the prototype code and several real sample plans (after NDA).

Interested? Send me a short note with your relevant experience, a rough estimate (effort and price) and timeline, plus any open questions.

Best regards,
Niven

Job Title: Experienced Prompt Engineer / Data Annotation Specialist
We are looking for reliable and experienced professionals to perform AI training projects.
1. Preferred Background
Prompt Engineering
Data Annotation
Data Labeling
Image Evaluation
Video Evaluation
AI Response Evaluation
Quality Assurance for AI Training Data
2. Requirements
Previous experience working on AI training or data annotation task
Strong attention to detail and ability to follow project guidelines.
Experience completing AI-related assessments or qualification tests.
Excellent written English and communication skills.
Responsible, trustworthy, and committed to delivering high-quality work.
Must be available during Central Standard Time (CST) working hours for communication and project coordination.
Able to meet deadlines and maintain confidentiality.
3. Preferred Qualifications
Experience with prompt engineering or evaluating AI model responses.
Familiarity with image, video, or text annotation tasks.
Experience working on AI training projects for major annotation platforms is a plus.
4. How to Apply
Please include:
A brief summary of your AI training or data annotation experience.
The AI platforms you have worked on.
Your area(s) of expertise (prompt engineering, image evaluation, video evaluation, data labeling, response evaluation, etc.).
screenshot of any relevant assessments, or completed projects.
We are seeking dependable, detail-oriented professionals who can consistently deliver high-quality work and collaborate effectively within CST business hours.

We are seeking an experienced Senior C++ Developer to help build a high-performance desktop companion overlay for an MMORPG-inspired gameplay experience. The ideal candidate will have a strong background in C++ and experience with building desktop applications. The project requires a high level of expertise to ensure the overlay is efficient and reliable.

We're building a ROS2-based robotics platform that uses an Intel RealSense D405 depth camera for close-range perception and object measurement ("sizing" — estimating real-world dimensions of objects from depth data). We need an experienced RealSense/depth-vision engineer to improve the accuracy, density, and repeatability of our depth output so downstream sizing calculations are reliable.

Current setup:

Python 3, ROS2 (rclpy), pyrealsense2, OpenCV/NumPy, running on Jetson hardware
D405 configured with visual_preset "High Density," gain 16, HDR disabled, emitter always on, 1280x720@30
All of librealsense's built-in post-processing filters (spatial, temporal, hole-filling, decimation) are currently disabled in production; a custom Python node does a simple per-pixel temporal accumulation instead
A separate tool deprojects two clicked pixels to 3D and reports the Euclidean distance between them (our current "measurement" path) via rs2_deproject_pixel_to_point
We've noticed the depth image is quite sparse at close range (a small fraction of pixels return valid depth per frame), and there are some inconsistencies in how depth units/scale are handled that we'd like audited and fixed
Scope of work:

Audit our current RealSense camera configuration, filter pipeline, and depth-to-metric conversion for correctness and best practice (including the depth-units inconsistency noted above).
Recommend and implement an optimal filter/preset/tuning strategy for the D405 specifically for short-range, high-accuracy sizing use cases (spatial/temporal/hole-filling filters, disparity domain processing, exposure/gain tuning, etc.).
Improve depth density and noise characteristics — replace or augment our naive temporal accumulator with a more principled approach (e.g., proper multi-frame fusion, edge-aware filtering, or hybrid depth completion), balancing latency vs. accuracy.
Validate accuracy quantitatively: design and run repeatable tests against known-size reference objects/calibration targets at multiple distances, and report measurement error (e.g., ± mm at given ranges).
Deliver tuned configuration + updated pipeline code, with before/after accuracy benchmarks.
Document the calibration/tuning procedure so our team can maintain it going forward.
Requirements:

Proven hands-on experience with Intel RealSense SDK (librealsense / pyrealsense2), ideally with D400-series (D405/D415/D435) cameras
Solid understanding of stereo depth principles, camera intrinsics/extrinsics, disparity, and depth filtering algorithms
Strong Python skills; comfort with ROS2 (rclpy) a strong plus
Experience designing accuracy/repeatability validation tests for depth or measurement systems
Nice to have: experience with depth completion/sensor fusion (e.g., combining stereo depth with monocular depth models), point cloud processing, or photogrammetry/dimensioning systems
Nice to have: embedded/Jetson deployment experience
Deliverables:

Updated camera config + depth processing code (PR-ready, with clear documentation of changes)
Test scripts/data demonstrating measurement accuracy improvement across a specified working distance range
Short write-up of findings, chosen approach, and remaining limitations/trade-offs

Join our team to develop a Solar Powered AI CCTV Tower. You'll work on hardware, edge AI, and cloud integration, ensuring seamless communication and data processing.

I’m looking for an experienced engineer to help design the hardware and software architecture for a reliable, production-ready system.

Scope
• 3–4 IP cameras in a custom 360° crown
• Edge AI (human & vehicle detection)
• Radar integration
• 4G LTE connectivity
• Solar + LiFePO₄ battery system
• Local video/event storage
• Halo warning light, siren & audio
• Health monitoring & self-healing
• Cloud management portal & OTA updates
• Required Experience
• Embedded Linux / ARM platforms
• Industrial IoT systems
• ONVIF/IP cameras
• Edge AI (OpenCV, YOLO or similar)
• Solar & battery-powered systems
• LTE communications
• Hardware/system architecture

Deliverables
• Complete system architecture
• Hardware recommendations
• Power system design
• Software architecture
• Component selection
• Development roadmap
• Ongoing technical guidance through prototype development

To Apply
Please include:
• Similar projects you’ve completed.
• Your recommended edge computing platform.
• Your recommended battery architecture (12V vs 24V) and why.
• Examples of products you’ve designed for outdoor or industrial environments.

This is a long-term project with the goal of developing a commercial product, so I’m looking for someone who can become a technical partner rather than just complete a one-off task.

bina is a fast-growing digital school and the systems and automation layer underneath it all needs an owner. If you're a software architect who thinks in distributed, event-driven systems, runs agentic workflows as a daily habit (not a curiosity), and treats long-term maintainability as part of the definition of "done" — read on.

---

🌟 What is bina?

bina is a globally distributed, fully synchronous digital school serving families in 50+ countries. We operate tiny classrooms of up to 12 students, led by exceptional teachers, and go far beyond academics — integrating social-emotional learning, cultural awareness, adventures, and real-world, biome-inspired curricula.

With Cambridge accreditation, ~87 NPS, and $2.9M cARR, growing 20%+ QoQ, bina is positioned to reach 10k+ students in the next 4–5 years.

Our vision? To build the highest quality school to scale. We use researched, backed, and newly possible methodologies, to craft accessible play-based education to millions of students globally. We're re-imagining how school works.

---

What does bina's R&D Developer do?

You'll own architecture and end-to-end delivery for the systems that turn bina's growth strategy into operational reality — distributed, event-driven services and data-analytics workloads that power a globally distributed school. You'll work directly with Dima (R&D), drive work through a disciplined, agentic SDLC, and ship software that's still healthy a year after you wrote it.

The actual code is increasingly written by AI. Your real job is defining problems precisely, orchestrating agents, and maintaining quality across parallel workflows. We hire for that — not for declared expertise.

Key Responsibilities

- Design and own distributed, event-driven systems and real-time, high-concurrency data workloads end-to-end — from requirements and architecture through implementation, QA, and deploy.
- Build and operate the data layer (PostgreSQL, key-value stores, caching) that bina's growth depends on.
- Design clean, versioned service boundaries and APIs; integrate third-party systems with deliberate attention to contracts, failure modes, idempotency, rate limits, and backward compatibility.
- Drive delivery through structured agentic workflows — running 2–3 in parallel — across the full SDLC (requirements → architecture → task decomposition → implementation → QA → demo/deploy).
- Uphold an explicit engineering quality bar: automated testing, code review, CI/CD, observability (logging, metrics, tracing), and security-by-default.
- Own secure handling of sensitive data and lead incident response when needed.

---
✅ You'll be a great fit if you have…

Must-haves

- Architecture ownership — a proven track record as a software architect, or a strong senior engineer who independently owns end-to-end system design (architect-level preferred).
- 6+ years of professional software engineering, or an equivalent demonstrable track record at architect/senior level.
- Production-grade proficiency in Python and Go.
- Distributed, event-driven systems experience — including real-time / high-concurrency domains — with the ability to talk specifics: scale, failure modes, trade-offs.
- Strong data-layer fundamentals — PostgreSQL, key-value stores, and caching strategies.
- Hands-on AI engineering — currently operates 2–3 parallel agentic workflows in practice; in-depth, up-to-date knowledge of LLMs and modern agent harnesses (consumer chatbot use alone doesn't qualify).
- Structured (agentic) SDLC discipline — operates within a clear delivery process, not ad-hoc "vibe coding."
- API and integration design — clean, versioned service boundaries with thoughtful handling of contracts, idempotency, and backward compatibility.
- Delivery ownership — plans, drives, and ships work end-to-end; accountable for outcomes, not only code.
- Engineering rigor and maintainability — automated testing, code review, CI/CD, observability, security-by-default; carries software through its full lifecycle.
- Infrastructure literacy — comfortable operating and maintaining Linux-based infrastructure.
- Security and data stewardship — owns secure handling of sensitive data and responds to incidents.
- Autonomous async/remote collaboration — self-manages and communicates effectively in writing across a distributed CET/ET team with minimal oversight.
- Analytical rigor — structured, evidence-based problem solving.
- Clear, warm, professional communication in writing and conversation.
- Organization — balances long-horizon projects against day-to-day urgencies without dropping either.

Nice-to-haves

- Rust and/or TypeScript proficiency (in addition to the required Python/Go).
- Has built their own agent harness or internal tooling.
- Works across multiple LLM providers; deeply engaged in workflow design and understands *how* workflows behave, not just how to call them.
- Self-directed task decomposition — breaks ambiguous problems into a structured plan unprompted.
- Management / ownership mindset.
- Solid front-end capability.
- OpenCV; audio/video processing.
- Education-sector background.
- Fast-paced / start-up environment experience.

---

🥑 What we offer

- Compensation: $5000 USD per month
- Fully remote role with a globally distributed team, built for deep work and high trust
- True ownership and impact — you'll architect bina's systems and automation layer from the ground up
- A position at the forefront of global education innovation
- Direct collaboration with R&D leadership on the technical foundation of a fast-scaling school
- Start date: as soon as possible

---

Application

- To apply, please reach out with your CV and answer the screening questions.
- As a safeguarding measure, all applicants are required to complete a KYC check through iDenfy. This is a safeguarding measure as your work in bina involves personal data of minors. We are not collecting nor processing your personal data.
- Process: shortlisted candidates will be invited to a 30 to 45-min live problem-solving session. If passed, a second call covering experience and fit. Bring whatever AI tooling you trust.

Job Description

We are looking for a **Computer Vision / Video Streaming Engineer** to help improve our real-time webcam background removal solution.

Responsibilities
* Track a person in a live webcam stream.
* Improve the accuracy of background removal.
* Troubleshoot and fix issues in the existing implementation.
* Optimize the solution for real-time performance.

Required Skills
* Experience with computer vision and video streaming.
* Strong knowledge of OpenCV.
* Experience with person tracking or image segmentation.
* Familiarity with Python and real-time video processing.
* Ability to debug and improve existing code.

Project Details
* Short-term project.
* Existing implementation is available; the focus is on resolving the final-stage issues.

I'm looking for someone with Python and computer vision experience to help me build an MVP of a real estate tech app. The ideal candidate will have a strong understanding of Django and OpenCV, and be able to integrate machine learning models into the application. This project requires intermediate proficiency and offers a part-time engagement over 1 to 3 months.

I have already prepared the full CoppeliaSim scene (.ttt) with the mobile platform, vision sensor and the coloured paths laid out. What I still need is the Python side: a clean, well-commented script that connects through the CoppeliaSim remote API, reads the vision stream, identifies the target colours and drives the robot along each line using a PID controller.

Primary task
The robot’s job is straightforward line following. Because the scene contains several coloured tracks, it must be able to hop from one to another whenever the target colour changes, staying centred on whichever line it is tracking.

Colours to detect
• red
• green

Skills: Python, Data Processing, Software Architecture, C++ Programming, Robotics, Arduino, OpenCV, Computer Vision, Simulation, Automation

I want a desktop game that runs on Windows and uses nothing but a webcam and my hand gestures to play rock-paper-scissors against the computer. The entire flow must be written in Python. When I show rock, paper, or scissors in front of the camera, the program should instantly recognise the gesture, display it on screen beside the computer’s randomly chosen move, decide the winner for that round, update the scores, and add the result to a running match history panel.

The interface needs to stream the live camera feed so I can see myself while playing. Below or beside that feed, show my detected move, the computer’s move, the round outcome, current score tally, and a scrollable list of previous rounds. To keep play fair, include a short delay and validation logic so it doesn’t count the same gesture multiple times or accept ambiguous hand positions.

Python libraries such as OpenCV and MediaPipe (or an equally accurate landmark-tracking solution) are fine; choose whichever yields stable, real-time detection at 30 fps or better. The GUI toolkit is up to you, provided the window looks clean and responsive on standard Windows resolutions.

Deliverables:
• Complete Python source code and any supporting assets
• A requirements.txt or environment.yml for easy setup
• Simple step-by-step instructions to install, launch, and play

Acceptance will be based on consistent gesture recognition, smooth frame rate, an intuitive GUI, correct score keeping, and error-free execution on Windows.

Skills: Python, Software Architecture, Machine Learning (ML), Software Development, Game Development, Image Processing, Computer Science, OpenCV, Computer Vision, Desktop Application

Tablet App for Surgical Instrument Tray Management (Veterinary Hospital)

We are looking for an experienced developer (or small team) to build a modern tablet application for managing surgical instrument trays in busy veterinary referral hospitals.

The goal is to simplify instrument reassembly after cleaning while minimizing missing instruments and human errors.

Core features
Works on Android tablets and iPads
Offline functionality with cloud synchronization
User-friendly, clean interface
High-resolution images with smooth zooming and true to scale option
Easy addition of further instrument sets by user
Each instrument tray should include:
Overview photo of the complete tray showing the correct arrangement
High-resolution reference image of every individual instrument
Ability to zoom to actual size for visual comparison (using calibrated reference images)
Interactive checklist to mark each instrument as it is placed back into the tray
Clearly highlight any missing instruments before the tray is completed
Nice-to-have features
Search function
Instrument database
User login
Activity history
Export reports
Future AI-based instrument recognition using the tablet camera
Technology

We are open to your recommendations. The app should be scalable and easy to extend with additional features in the future.

About us

I respresent the VUK (Verbund unabhängiger Kleintierkliniken), an organization of owner-operated hospitals in Germany and Austria.


When applying, please include:

Similar projects or portfolio
Recommended technology stack
Estimated timeline
Fixed-price estimate for an MVP
Suggestions for improving the workflow

We value clean code, excellent communication, and proactive ideas. We are looking for a long-term development partner rather than someone who simply follows specifications.

I will provide my davidski G25 coordinates and I want some professional to provide me with the possible best fit qpadm models including Steppe_MLBA, A. The job requires an intermediate level of proficiency in genetic genealogy and qpadm modeling.

We are seeking an experienced AI engineer and mentor to develop AI websites and personal AI ecosystems. The role involves creating AI-driven websites, integrating AI tools, and mentoring on AI adoption. The ideal candidate will have a strong background in AI engineering and a passion for mentoring. This is a part-time role with a project scale of small to medium, expected to last 1 to 3 months.

Project Overview
I am looking for an experienced Python developer to build a robust and scalable automation system for an Android game running inside LDPlayer on Windows.
The automation must support both single-instance and multi-instance operation. It should be capable of managing multiple LDPlayer instances simultaneously, allowing them to work independently or in a coordinated manner when required.
The software should be designed using a State Machine architecture, where each emulator instance maintains its own independent state, makes decisions based on its current situation, automatically detects and recovers from errors, and continues operating without affecting other running instances.
The automation should rely primarily on OpenCV and computer vision for detecting game states and user interface elements. Experience with YOLO or other modern computer vision techniques is considered an advantage, but strong OpenCV experience is required.
I am looking for a reliable, modular, maintainable, and long-term solution rather than a simple automation script.
If this project is completed successfully, I would like to continue working with the same developer for future updates, maintenance, and new features, since the game receives updates over time.

I am looking for an experienced AI Full-Stack Developer (or a small team) to build an AI-powered Virtual Fabric Try-On feature for our online fabric store.

Our website is built on the Zid platform.

The main goal is to allow customers to:

• Select a fabric from our catalog.
• Upload their own photo or use their mobile camera.
• Instantly see a realistic preview of how the selected fabric would look on their clothing.
• Switch between fabrics without uploading the photo again.
• Continue directly to purchase the selected fabric.

This is Phase 1 of a larger project that will later include live camera try-on, AI body measurements, and mobile applications.

Before our meeting, I would like to know:

* Have you built any AI Computer Vision or Virtual Try-On projects?
* Which technologies would you recommend?
* Have you integrated AI features into Zid, Shopify, or similar e-commerce platforms?
* Can you share similar projects or demos?

Looking forward to discussing the project with you.