• Installation
• Quick Start
• Command Line Arguments
• Example Commands
• Batch Inference
• Evaluation
• Dataset
• Default Configuration
• Citation

Official implementation of Fill My Mirror.

This repository contains the code for generating consistent reflections in mirrors by combining geometry estimation, projection, and dual-mask diffusion-based inpainting.

The following instructions were tested on Linux with Python 3.10.

Clone the repository with submodules to also download the MoGe and MASt3R dependencies.

git clone --recurse-submodules https://github.com/OfekBasson/Fill-My-Mirror.git
cd Fill-My-Mirror

If you already cloned without submodules, run:

git submodule update --init --recursive

Create a clean environment to avoid dependency conflicts.

conda create -n fill-my-mirror python=3.10
conda activate fill-my-mirror

pip install -r requirements.txt
pip install -e third_party/MoGe
pip install -e .

This project requires Blender for scene rendering (and for evaluation on the Blender dataset).

Run the provided installation script:

bash scripts/install_blender.sh

This downloads and extracts Blender to:

external/blender/

Required only if you plan to run evaluation with the Reflection Consistency Score (RCS) masking on real images.

MASt3R is not a pip-installable package — install its dependencies directly:

pip install -r third_party/MASt3R/requirements.txt
pip install -r third_party/MASt3R/dust3r/requirements.txt

Required only if you plan to use a depth-anything/* geometry model (e.g. depth-anything/DA3-LARGE-1.1).

pip install xformers "torch>=2" torchvision
pip install git+https://github.com/ByteDance-Seed/Depth-Anything-3.git

Note: Depth Anything 3 does not yet support multi-mirror scenes. Use MoGe-V2 (Ruicheng/moge-2-vitl-normal) for images with more than one mirror.

Run the example script:

scripts/run_example.sh

Or run directly with your own image and mask:

python -m fill_my_mirror --image /path/to/image.png --mask /path/to/mask.png

Or use a sample from the HuggingFace dataset by index:

python -m fill_my_mirror --hf-index 0

Option A — local files (--image and --mask must be provided together):

Option B — HuggingFace dataset sample:

The file paths below are illustrative — replace them with the actual paths to your image and mask files.

Basic example with local files:

python -m fill_my_mirror \
  --image /path/to/image.png \
  --mask /path/to/mask.png \
  --prompt "A standing mirror reflects a bed with a dotted cover in a cozy bedroom."

Example using a HuggingFace dataset sample (no local files needed):

python -m fill_my_mirror --hf-index 5

Example with a custom output path:

python -m fill_my_mirror \
  --image /path/to/image.png \
  --mask /path/to/mask.png \
  --output_path outputs/result.png

Example with a custom prompt:

python -m fill_my_mirror \
  --image /path/to/image.png \
  --mask /path/to/mask.png \
  --prompt "Generate a realistic mirror reflection consistent with the scene geometry and lighting."

Run the pipeline on every sample in the HuggingFace dataset with scripts/run_batch.py. Results are saved as {output_dir}/seed_{seed}/{index}.png, ready for use with the batch evaluation command.

python scripts/run_batch.py --dataset real --output-dir outputs/batch_real/

Required:

Optional:

All standard pipeline arguments (--prompt, --strength, --num-inference-steps, --guidance-scale, --seed, --n, --t-prime, etc.) are accepted and forwarded to the pipeline unchanged — see Command Line Arguments for their descriptions and defaults.

Metrics are reported for two regions of the mirror and the full image:

Evaluate a single locally provided image (no dataset required):

python scripts/evaluate.py local \
  --generated /path/to/generated.png \
  --gt /path/to/gt_image.png \
  --mask /path/to/mask.png \
  --save-dir eval/sample_0/ \
  --prompt "A standing mirror reflects a bed with a dotted cover in a cozy bedroom."

local arguments — required:

local arguments — optional:

Evaluate a batch of results against the real-images HuggingFace dataset:

python scripts/evaluate.py batch \
  --results-dir outputs/my_run/ \
  --dataset real \
  --output-dir outputs/eval/real/

Evaluate against the Blender dataset:

python scripts/evaluate.py batch \
  --results-dir outputs/blender_run/ \
  --dataset blender \
  --output-dir outputs/eval/blender/

batch arguments — required:

batch arguments — optional:

The constrained mask isolates mirror pixels whose appearance is geometrically determined by the visible scene — enabling a more faithful evaluation of reflection correctness than metrics over the full mirror region.

Real images (HF dataset or local) — computed via the Reflection Consistency Score (RCS): MASt3R finds dense correspondences between the scene view and a flipped mirror view; matched mirror pixels are dilated and intersected with the mirror mask.

Blender dataset — derived from ground-truth 3D geometry: the projection pipeline is run with GT point cloud and intrinsics; pixels covered by the projection are the constrained region.

Two datasets are provided:

Contains 50 real-world mirror scenes with the following columns per sample:

Contains 15 rendered Blender scenes with mirrors, including ground-truth mirror masks, geometry, and manually assigned prompts.

A large-scale synthetic benchmark from MirrorVerse (CVPR'25) containing 207K rendered scenes. The HDF5 files are distributed as tar archives on HuggingFace and must be downloaded and extracted before use. The split CSV (test.csv) is downloaded automatically.

Setup:

Run the provided download script to fetch and extract all archives:

python scripts/download_mirrorbench_v2.py

To download and extract a single batch only:

python scripts/download_mirrorbench_v2.py --batch 1

Note: batch indices start at 1 (there is no batch_0.tar); valid values are 1-35.

After extraction the directory should look like:

data/mirrorbench_v2/
    hf-objaverse-v4/
        000-010/
            8014aa16057a495795f7bf8a02a3ebe0/
                0.hdf5  1.hdf5  2.hdf5
        ...
    abo_v4/
        ...

Geometry is derived from the HDF5 depth map and camera intrinsics — no MoGe inference is run.

Run a single sample:

python -m fill_my_mirror --use-mirrorbench-data --hf-index 0

Run batch inference:

python scripts/run_batch.py --dataset mirrorbench_v2 --output-dir outputs/batch_mirrorbench/

The default configuration is stored in configs/config.yaml:

prompt: "Complete the mirror reflection realistically and consistently with the scene geometry."
default_output_path: "outputs/result.png"
blender_path: "external/blender/blender-4.4.3-linux-x64/blender"
geometry_model_name: "Ruicheng/moge-2-vitl-normal"
inpainting_model_name: "black-forest-labs/FLUX.1-Fill-dev"
mast3r_model_name: "naver/MASt3R_ViTLarge_BaseDecoder_512_catmlpdpt_metric"

geometry_model_name selects the geometry estimator used for real images (Blender samples always use ground-truth geometry).

To switch, edit configs/config.yaml:

geometry_model_name: "depth-anything/DA3-LARGE-1.1"

Note: Depth Anything 3 does not yet support multi-mirror scenes. Use MoGe-V2 for images with more than one mirror.

inpainting_model_name selects the dual-mask backend.

To switch, edit configs/config.yaml:

inpainting_model_name: "black-forest-labs/FLUX.1-Fill-dev"

Both backends use the same dual-mask noise interpolation parameters n and t_prime. When an argument is unsupported by the selected backend, Fill My Mirror logs a warning and silently ignores it.

If you use this code in your research, please cite:

@article{fillmymirror2026,
  title   = {Fill My Mirror: Geometry-Constrained Mirror Inpainting},
  author  = {Basson, Ofek and Vainer, Shimon and Hel-Or, Yacov and Fried, Ohad},
  journal = {arXiv preprint arXiv:2609.03740},
  year    = {2026},
}