Virtual try-on is getting incredibly good at answering one question:
“What would I look like wearing this?”
But while experimenting with generative fashion, I became more interested in a different question:
What happens when AI changes something you never asked it to touch?
A virtual try-on can successfully change a shirt, jacket, or accessory while also modifying a tattoo, a watch, an assistive device, an object beside you, your posture, or even the geometry of the scene.
The requested transformation may succeed.
But the representation of the person may not.
So I built DrapeProof.
DrapeProof is a preservation layer for generative fashion try-on.
Instead of only telling AI what should change, DrapeProof lets the user define what should remain unchanged.
🌐 Live: https://drapeproof-access.vercel.app
💻 Source: https://github.com/jpablortiz96/drapeproof-access
🎥 Demo: https://youtu.be/P6Ux31PAzVc
The basic idea
A normal virtual try-on pipeline looks roughly like this:
Photo
↓
Fashion generation
↓
Result
DrapeProof adds another layer around that generation:
Photo
↓
Choose the fashion item
↓
Select what AI should NOT change
↓
YouCam generation
↓
Global Continuity Gate
↓
Protected Region Verification
↓
Preserve Mode — when eligible
↓
Re-verification
↓
DrapeProof Passport
The principle behind the product is simple:
AI should change what I asked it to change — and leave the rest of me alone.
1. The user chooses what matters
Before generating the new look, DrapeProof asks:
What should AI never change?
The user can mark protected regions directly on their image.
These could represent:
- an assistive-device control
- part of a wheelchair
- a tattoo
- jewelry
- a watch
- a scar
- a personal accessory
- another visual detail the user considers important
The important part is that DrapeProof does not decide what matters on behalf of the user.
The user does.
2. YouCam generates the fashion transformation
The actual fashion transformation is powered by Perfect Corp's YouCam API.
DrapeProof currently integrates:
- YouCam Clothes Virtual Try-On V4
- YouCam Bag Virtual Try-On V2
- YouCam Skin Analysis V2.1 as an optional visual-appearance signal
YouCam is the generation engine.
DrapeProof focuses on a different question:
What happened to everything around the requested transformation?
3. Provider success is not the same as preservation
This became one of the biggest lessons while building the project.
During one experiment, a fashion API task completed successfully.
From the provider's perspective:
SUCCESS
But the generated image had changed the scene enough that comparing small protected regions against the original would no longer have been defensible.
That led to one of the most important pieces of DrapeProof:
The Global Continuity Gate
Before making local preservation claims, DrapeProof evaluates whether the original and generated scenes are still comparable.
It checks independent signals including:
- frame geometry
- body pose
- classical visual feature correspondence
- protected-region mappability
If that continuity fails, DrapeProof stops.
It doesn't pretend the local comparison is trustworthy.
That distinction turned out to be fundamental:
A generation can succeed while preservation verification should still refuse to proceed.
4. Protected Region Verification
If global continuity passes, DrapeProof evaluates the areas selected by the user.
The verification layer uses deterministic image measurements such as:
- Mean Absolute Difference
- Changed Pixel Ratio
- Structural Similarity
- Edge Difference
I deliberately avoided creating one mysterious “AI trust score.”
Instead, the underlying signals remain independent and inspectable.
The consumer gets simple states:
PRESERVED
NEEDS REVIEW
CHANGED
while technical evidence remains available separately.
But detecting a change wasn't enough
At this point DrapeProof could tell you that something changed.
The obvious next question was:
Can it help restore it?
That's how Preserve Mode started.
5. Preserve Mode
If a protected area needs attention, DrapeProof evaluates whether restoration is actually appropriate.
When eligible, the user can explicitly choose:
Restore from original
DrapeProof then creates a separate preserved derivative.
The original AI output is never overwritten.
The workflow is:
Changed / Review
↓
Repair Eligibility
↓
Source → Result Mapping
↓
Restore from Original
↓
Bounded Blending
↓
Non-Degradation Check
↓
Re-Verify
And here's an important detail:
Preserve Mode does not call another generative model to recreate the object.
The protected content is derived from the user's original image using deterministic image processing.
Then the verifier runs again.
6. Sometimes the correct action is to do nothing
This was probably my favorite engineering lesson from the whole project.
My first restoration eligibility rule actually failed one of my own controlled tests.
A protected region overlapped the part of the image that AI was intentionally supposed to modify.
The restoration engine could have copied original pixels back into that area...
…but doing so could partially erase the new fashion result.
The easy solution would have been to tweak a threshold until the experiment passed.
I didn't.
I kept the failed result and redesigned the gate.
DrapeProof now builds a conservative transformation exclusion zone and can refuse restoration when:
- global continuity failed
- region mapping is unreliable
- the protected area intersects the intended fashion transformation
- the restoration footprint is too close to it
- there isn't enough surrounding visual context
This changed the question from:
“Can I copy these pixels back?”
to:
“Should I?”
That became a much more interesting product problem.
7. The DrapeProof Passport
Every result can finish with a DrapeProof Passport.
It separates three things that are often mixed together in generative applications:
AI Generation
What the fashion provider generated.
DrapeProof Verification
What DrapeProof inspected.
DrapeProof Preservation
What DrapeProof restored from the original, if anything.
The Passport isn't a certification.
It doesn't claim physical fit, accessibility compatibility, medical validity, or identity verification.
It's simply a readable provenance layer for the transformation.
Architecture
DrapeProof is deployed as an actual production web application.
The stack includes:
Next.js + React + TypeScript
│
▼
Vercel Functions
│
┌──────┼─────────┐
│ │ │
▼ ▼ ▼
Neon Private YouCam API
Vercel
Blob
│
▼
Secured Python CV Worker
│
▼
MediaPipe + OpenCV
│
▼
Continuity / Verification
│
▼
Preserve Mode
│
▼
DrapeProof Passport
The project uses:
- Next.js
- React
- TypeScript
- Python
- MediaPipe
- OpenCV
- Neon Postgres
- Private Vercel Blob
- Vercel Functions
- Perfect Corp. YouCam APIs
The production wall I didn't expect
The computer vision pipeline worked locally.
Then I deployed it.
And it broke.
The Node.js serverless function attempted to launch:
python
Locally, that was fine.
Inside the deployed Vercel Node runtime, there was no Python executable available on PATH.
Instead of removing verification from production, I separated the architecture.
Node.js now handles:
- orchestration
- authorization
- persistence
- private media
- provider communication
while a secured Python CV worker handles:
- MediaPipe
- image geometry
- feature correspondence
- deterministic verification
- preservation processing
It was one of those failures that makes the final architecture significantly better than the original design.
Privacy mattered too
Fashion try-on involves personal images, so DrapeProof uses an anonymous-first model.
The current beta includes:
- no account required
- private image storage
- owner-authorized media access
- server-only provider credentials
- short-lived sessions
- deletion support
- rate limiting
- provider idempotency
- global generation budget controls
- privacy-minimized analytics
The goal is to make trying the product easy without turning the image pipeline into unnecessary permanent user storage.
What I learned
Building DrapeProof changed how I think about generative interfaces.
Most AI products start with:
What should the model create?
But there's another useful instruction:
What should the model not change?
Generation describes the transformation.
Protection describes the user's visual constants.
That idea could extend much further than fashion.
Imagine future systems where users can define persistent visual constants such as:
- an accessory
- a tattoo
- an assistive device
- a watch
- a culturally important item
- another personal detail
and ask generative systems to preserve them across transformations.
DrapeProof isn't another VTO model
That's intentional.
YouCam already provides strong fashion generation capabilities.
DrapeProof explores the layer that can sit around generative commerce:
Protect → Generate → Verify → Preserve → Explain
And sometimes:
Refuse.
Because a responsible system shouldn't only know how to change an image.
It should also know when the evidence isn't strong enough to claim that something stayed the same.
Try it
🌐 Live product
https://drapeproof-access.vercel.app
💻 Open-source repository
https://github.com/jpablortiz96/drapeproof-access
🎥 Product demo
https://youtu.be/P6Ux31PAzVc
The repository is available under Apache License 2.0.
One final thought
Generative AI keeps getting better at changing images.
I think the next interesting problem is teaching these systems to respect what should remain unchanged.
That's what I'm exploring with DrapeProof.
Top comments (0)