GeoRemover: Removing Objects and Their Causal Visual Artifacts

The paper tackles a somewhat niche problem.

Note: Dear Reviewer, we sincerely thank you for your time and effort in reviewing our work. Due to the official policy for this year’s rebuttal process, we are, unfortunately, unable to share the carefully prepared one-page document of additional visualizations. These include failure cases, intermediate results, and various edge case examples, which we found both interesting and thrilling to analyze, as they were inspired by the reviewers’ constructive comments. We also reached out to the AC to ask whether we could share this document in the same way as a code link, and the AC kindly consulted the program chairs on our behalf; however, we were informed that this is not allowed. Despite these constraints, we are making every effort to describe these visualizations in detail so that you can still obtain the corresponding information. These described figures are referred to using lettered indices (Case A–H). We will update our main submission with content from this document.

Our method indeed is not specifically designed to optimize texture inpainting or watermark removal. However, our model can also handle general inpainting tasks. In fact, it performs competitively on ordinary inpainting scenarios, while showing clear advantages in cases involving causal artifacts. To further demonstrate its applicability, we present a watermark removal example in Case H: a photo of a wooden dock where the watermark is uniformly distributed across both the lake surface and the dock planks. Our model successfully removed the watermark.

The method relies upon pre-trained diffusion models & How does the model depend on the diffusion backbone used for the image generation?

We appreciate the reviewer’s insightful question. Like many diffusion-based approaches, our method inevitably depends on the expressiveness of the underlying pre-trained diffusion backbone, as the quality of Stage 2 image generation is influenced by its ability to render realistic textures and details. However, this is a common setting in current state-of-the-art methods such as CLIPAway, OmniEraser, OmniPaint, and ObjectDrop, all of which also rely on the same family of pre-trained diffusion models. Moreover, to provide a fair reference, we already explicitly reported the baseline performance of the pre-trained diffusion model (FLUX.1-Fill) itself, allowing readers to clearly understand how much improvement our two-stage framework brings beyond the base model’s capability.

To quantify this dependency, we replaced the default Flux Fill backbone with SDXL Inpainting. As shown in the above table, Flux Fill only achieves slightly better performance on geometry-sensitive metrics, indicating that the overall performance of our method does not heavily rely on the specific diffusion backbone.

DreamSIM, SSIM, FLIP, DISTS and CLIP-IQA.

We appreciate the reviewer’s constructive suggestion. Following this advice, we added the suggested metrics for a more comprehensive evaluation. As shown in the above table, our method achieves the best performance on most of them across both RemovalBench and RORD-Val. Regarding CLIP-IQA, we note that, like the Aesthetics Score (AS), it primarily reflects overall image quality rather than object removal accuracy. While it may not strongly correlate with removal effectiveness, we include it for completeness.

On tables 1–3, for the appropriate metrics (e.g., LPIPS or PSNR), I think it would be useful to include confidence intervals.

Aesthetics Score.

We will replace AS with more relevant metrics, such as those you suggested (DreamSIM, SSIM, FLIP, DISTS).

Show the second-best results, as well as the worst results in red.

We appreciate the reviewer’s helpful suggestion. We will incorporate second-best and worst results in the revised version to improve clarity. However, due to the formatting restrictions of the OpenReview rebuttal system, we are unable to use colored fonts here.

More ablation study about L_flow.

Note: due to space limitations, we may refer to responses addressed to other reviewers; we hope for your kind understanding.

We appreciate the reviewer’s constructive suggestion. More detailed ablation study is provided in the response to Reviewer w1kx, Questions DPO needs better motivation and DPO lambda value.

The method is computationally very expensive.

We appreciate the reviewer’s comment on the computational cost. The detailed computation cost is provided in the response to Reviewer w1kx, Questions Computational Overhead & Inference clock time

Edge cases (transparency and translucency)

We appreciate the reviewer’s insightful question. The edge cases (Case B and Case C) for transparency and translucency can be found in our response to Reviewer Dwf1, Question How does the two-stage framework handle dynamic or translucent objects where depth maps are ambiguous?.

Is LoRA a limiting factor in the model results?

We appreciate the reviewer’s question. LoRA is not a limiting factor in our framework. In fact, LoRA can already effectively adapt the backbone to our two-stage pipeline, which indicates that full fine-tuning would likely yield even better performance if sufficient computational resources were available. However, when the available training data is significantly smaller than the data used for pre-training—as is common in most downstream tasks—LoRA is often a better choice than full fine-tuning, as it reduces the risk of overfitting while achieving competitive or even superior generalization. Therefore, LoRA should not be considered a limitation in this context.

How expressive is the reflection removal? Does it handle color bleeding well?

We appreciate the reviewer’s question. Our method can handle most reflections without overlapping components but currently struggles with overlapping color bleeding. Specifically, for non-overlapping reflections, the model achieves strong performance, as also illustrated in our paper’s Figure 5.

However, for complex reflections with overlapping components, such as color bleeding on highly reflective surfaces, our current model struggles. In Case C, a scene contains a large transparent water jug and five semi-transparent cups placed on a reflective table. The reflections of these cups overlap, causing noticeable color bleeding. When attempting to remove one of the semi-transparent cups, both the cup itself and its direct reflection was successfully removed. But the color bleeding in the reflections of the other cups, which was influenced by the removed cup, remains visible.

Edge cases (light-emitting objects)

Our current model cannot effectively handle light-emitting objects. Case D presents a challenging self-emitting object removal case. Two light bulbs lie on the floor, one casting red light and the other green. Stage1 handles the geometry perfectly—both bulbs and their shapes are accurately removed in the depth map. However, Stage2 behaves unexpectedly: instead of simply erasing the red illumination, it “imagines” a diffuse, amorphous red glow appearing in midair, as if a new red light source had been added to the scene. Although the removal result is unsatisfactory, this behavior reveals an intriguing aspect of Stage 2’s reasoning. It has implicitly learned a causal relationship between illumination and its source—“believing” that if there is red light in the scene, there must be a corresponding red light source to explain it. This over-reasoning causes hallucinated artifacts in this case, yet it also suggests that our rendering model is not merely filling textures arbitrarily; instead, it captures some meaningful light–source correlations, which, if guided properly, could be advantageous in more physically consistent rendering tasks.

Potential solution for all edge cases

This limitation mainly arises from the lack of paired data for all edge cases, which we plan to address by synthesizing targeted training data using text-to-video generation models in future work, using prompts like A hand removes a red light bulb from a table.

The method relies heavily on the depth estimation quality of the Depth Anything model.

We thank the reviewer for pointing out this important aspect. In our implementation, we use an off-the-shelf depth estimator solely to obtain a geometric representation. Strictly speaking, our method does not rely on any specific depth estimator; rather, it assumes that an accurate geometric representation is available. Our core hypothesis and contribution lie in showing that, given a reasonably accurate geometry, object removal and its causal artifacts (e.g., shadows and reflections) can be effectively eliminated through our two-stage pipeline. Depth Anything is simply a strong depth estimator that helps us obtain more accurate geometry in practice, but our approach is not inherently tied to it. Moreover, the availability of many high-quality off-the-shelf depth estimators today makes it easy to obtain such geometry in practice.

To further verify this, we replaced Depth Anything with a different depth estimator VGG-T (Wang, Jianyuan, et al. "Vggt: Visual geometry grounded transformer." Proceedings of the Computer Vision and Pattern Recognition Conference. 2025.). As shown in the below Table, although the performance with VGG-T slightly drops compared to Depth Anything, our pipeline still achieves consistent artifact removal, confirming that our method can generalize to other depth estimators.

Providing intermediate results from each stage for handling of reflective objects.

We thank the reviewer for this valuable comment and apologize for not making this clearer in the paper. The intermediate reflections can actually be observed in Figure3(a) (rightmost boat example) in the paper. For instance, the boat’s reflection is estimated as having the same depth as the lake surface rather than a new boat-like geometry. Therefore, reflection artifacts are not present in the depth domain. After Stage1 removes the boat geometry, Stage2 leverages this updated geometry to simultaneously remove the boat and its corresponding reflection artifacts. In summary, the initial depth estimation and depth inpainting stage provide guidance on which objects need to be removed, while the final image generation stage removes the objects and their corresponding reflection artifacts.

Note: Dear Reviewer, we sincerely thank you for your time and effort in reviewing our work. Due to the official policy for this year’s rebuttal process, we are, unfortunately, unable to share the carefully prepared one-page document of additional visualizations. These include failure cases, intermediate results, and various edge case examples, which we found both interesting and thrilling to analyze, as they were inspired by the reviewers’ constructive comments. We also reached out to the AC to ask whether we could share this document in the same way as a code link, and the AC kindly consulted the program chairs on our behalf; however, we were informed that this is not allowed. Despite these constraints, we are making every effort to describe these visualizations in detail so that you can still obtain the corresponding information. These described figures are referred to using lettered indices (Case A–H). We will update our main submission with content from this document.

We further demonstrate the robustness of our pipeline to depth estimation errors in Case G. The reflection of a duck on the lake surface is incorrectly estimated by the depth estimator as having a duck-like shape rather than the lake’s flat depth. Nevertheless, the final removal is still correct because the actual object depth (the duck itself) is accurate, enabling Stage2 to identify it as removable and also remove its reflection. This robustness arises because Stage 2 is trained on depth maps produced by Depth Anything, which naturally contain some depth estimation errors. According to our statistics, in approximately 85% of cases where reflection depths are estimated incorrectly, the final removal remains correct.

Lack of failure case analysis.

We appreciate the reviewer’s suggestion to elaborate on the failure cases. For Stage 2, we provide two representative failure cases in Case C and Case D.

The Case C shows a semi-transparent case with a large water jug and five semi-transparent cups on a reflective table. The reflections of these cups overlap, causing noticeable color bleeding. When removing one of the cups, the model successfully removes both the cup itself and its direct reflection. However, the color bleeding in the reflections of the other cups, which was influenced by the removed cup, remains visible. This reveals a limitation of our current approach in handling reflective surfaces with complex, overlapping color interactions.

The Case D presents a challenging self-emitting object removal case. Two light bulbs lie on the floor, one casting red light and the other green. Stage1 handles the geometry perfectly—both bulbs and their shapes are accurately removed in the depth map. However, Stage2 behaves unexpectedly: instead of simply erasing the red illumination, it “imagines” a diffuse, amorphous red glow appearing in midair, as if a new red light source had been added to the scene. Although the removal result is unsatisfactory, this behavior reveals an intriguing aspect of Stage 2’s reasoning. It has implicitly learned a causal relationship between illumination and its source—“believing” that if there is red light in the scene, there must be a corresponding red light source to explain it. This over-reasoning causes hallucinated artifacts in this case, yet it also suggests that our rendering model is not merely filling textures arbitrarily; instead, it captures some meaningful light–source correlations, which, if guided properly, could be advantageous in more physically consistent rendering tasks.

To the best of our knowledge, no existing inpainting or object removal method can effectively handle such cases either, mainly due to the lack of paired data to provide explicit guidance. To address these limitations, we plan to leverage text-to-video generation models to synthesize paired data for such challenging edge cases, which we expect will improve the model’s robustness in future work.

As for failure cases where Stage 1 struggles to remove the target geometry, they mainly occur when the user-provided mask is incomplete. In Case F, three semi-transparent glass bottles sit snugly inside a cardboard box. We attempt to remove the largest bottle on the left under two conditions: one with a complete mask fully covering the bottle, and another with an incomplete mask covering only about 70% of it. The difference is striking—when given the complete mask, Stage 1 neatly erases the bottle as expected. But with the partial mask, the model gets “confused” and hallucinates an extra bottle, as if trying to “fill in what it thinks should still be there.” This behavior, while undesirable for removal, actually reveals that the model has learned a non-trivial understanding of geometric structures: rather than blindly removing masked regions, it attempts to infer plausible object shapes based on surrounding geometry. Such behavior can be easily avoided in practice by applying simple mask dilation operations or using advanced segmentation models like SAM2 to provide complete masks.

Limitations: The method relies on the Depth Anything model for depth estimation, which may limit performance in certain challenging scenarios, especially where depth prediction is inherently ambiguous.

We thank the reviewer for pointing out this important aspect. As discussed above, our model is not restricted to any single depth estimator. Furthermore, recent progress in depth estimation has significantly improved robustness in challenging scenarios. For example, Choi et al. ("Self-supervised Monocular Depth Estimation Robust to Reflective Surface Leveraged by Triplet Mining," ICLR 2025) explicitly address reflective and complex surfaces. With such rapid advances, obtaining reliable geometry is becoming increasingly feasible, which we believe will further enhance the applicability and robustness of our proposed method.

Note: due to space limitations, we may refer to responses addressed to other reviewers; we hope for your kind understanding.

Additionally, when depth estimation is imperfect, our pipeline includes mechanisms to compensate for such inaccuracies. A detailed example (Case A) is provided in our response to Reviewer Dwf1 Question How does the two-stage framework handle dynamic or translucent objects where depth maps are ambiguous?.

As stated in my Final Justification, the analysis of the failure cases sufficiently addressed my concerns. Consequently, I have adjusted my score to Borderline Accept. Thank you for your detailed response.

Limitations need more explanation & Failure cases for each stage

Note: Dear Reviewer, we sincerely thank you for your time and effort in reviewing our work. Due to the official policy for this year’s rebuttal process, we are, unfortunately, unable to share the carefully prepared one-page document of additional visualizations. These include failure cases, intermediate results, and various edge case examples, which we found both interesting and thrilling to analyze, as they were inspired by the reviewers’ constructive comments. We also reached out to the AC to ask whether we could share this document in the same way as a code link, and the AC kindly consulted the program chairs on our behalf; however, we were informed that this is not allowed. Despite these constraints, we are making every effort to describe these visualizations in detail so that you can still obtain the corresponding information. These described figures are referred to using lettered indices (Case A–H). We will update our main submission with content from this document.

We appreciate the reviewer’s suggestion to elaborate on the failure cases of both stages. For Stage 2, we provide two representative failure cases in Case C and Case D.

The Case C shows a semi-transparent case with a large water jug and five semi-transparent cups on a reflective table. The reflections of these cups overlap, causing noticeable color bleeding. When removing one of the cups, the model successfully removes both the cup itself and its direct reflection. However, the color bleeding in the reflections of the other cups, which was influenced by the removed cup, remains visible. This reveals a limitation of our current approach in handling reflective surfaces with complex, overlapping color interactions.

The Case D presents a challenging self-emitting object removal case. Two light bulbs lie on the floor, one casting red light and the other green. Stage1 handles the geometry perfectly—both bulbs and their shapes are accurately removed in the depth map. However, Stage2 behaves unexpectedly: instead of simply erasing the red illumination, it “imagines” a diffuse, amorphous red glow appearing in midair, as if a new red light source had been added to the scene. Although the removal result is unsatisfactory, this behavior reveals an intriguing aspect of Stage 2’s reasoning. It has implicitly learned a causal relationship between illumination and its source—“believing” that if there is red light in the scene, there must be a corresponding red light source to explain it. This over-reasoning causes hallucinated artifacts in this case, yet it also suggests that our rendering model is not merely filling textures arbitrarily; instead, it captures some meaningful light–source correlations, which, if guided properly, could be advantageous in more physically consistent rendering tasks.

To the best of our knowledge, no existing inpainting or object removal method can effectively handle such cases either, mainly due to the lack of paired data to provide explicit guidance. To address these limitations, we plan to leverage text-to-video generation models to synthesize paired data for such challenging edge cases, which we expect will improve the model’s robustness in future work.

As for failure cases where Stage 1 struggles to remove the target geometry, they mainly occur when the user-provided mask is incomplete. In Case F, three semi-transparent glass bottles sit snugly inside a cardboard box. We attempt to remove the largest bottle on the left under two conditions: one with a complete mask fully covering the bottle, and another with an incomplete mask covering only about 70% of it. The difference is striking—when given the complete mask, Stage 1 neatly erases the bottle as expected. But with the partial mask, the model gets “confused” and hallucinates an extra bottle, as if trying to “fill in what it thinks should still be there.” This behavior, while undesirable for removal, actually reveals that the model has learned a non-trivial understanding of geometric structures: rather than blindly removing masked regions, it attempts to infer plausible object shapes based on surrounding geometry. Such behavior can be easily avoided in practice by applying simple mask dilation operations or using advanced segmentation models like SAM2 to provide complete masks.

DPO needs better motivation

We appreciate the reviewer’s insightful question regarding the motivation for adopting a DPO-inspired objective. Total variation (TV) loss encourages local smoothness, which is effective for reducing depth noise but does not explicitly distinguish between correct geometry completion and implausible insertions. In contrast, DPO optimizes pairwise preferences between correct and hallucinated samples, directly aligning the model’s output with the desired global geometry. This is particularly important in ambiguous regions, where local smoothness may over-smooth fine structures or even propagate incorrect geometry, while DPO explicitly suppresses hallucinated insertions by learning from ranked preferences. Quantitatively, replacing DPO with a TV loss results in degraded performance, as shown in the above Table, confirming its effectiveness in maintaining geometric consistency.

Computational Overhead & Inference clock time

We appreciate the reviewer’s comment on the computational cost. To further clarify this point, we provide a comparison of the inference clock time in Table above, which explicitly shows the runtime overhead of our two-stage pipeline relative to one-stage methods. In terms of runtime for editing a 512 × 512 image, our current implementation takes approximately 1 s for depth estimation, 7 s for geometry removal (Stage 1), and 20 s for appearance rendering (Stage 2) per image on a single H100 GPU. In practical deployment scenarios, various acceleration strategies—such as model distillation and architectural pruning—can be applied to significantly reduce inference time. Therefore, although the current runtime introduces some overhead, it does not pose a significant obstacle to practical applications. Moreover, although this cost is indeed higher than that of one-stage methods, Figure4 and Table2 in the paper provide experimental evidence supporting the necessity of the two-stage design, as it significantly improves both object removal quality and artifact suppression.

How robust is both stages of the pipeline with respect to the possible incorrect depth maps?

Note: due to space limitations, we may refer to responses addressed to other reviewers; we hope for your kind understanding.

We appreciate that the reviewer precisely identified the issue and suggested improvement direction. Our Stage2 relies on comparing the input and geometry-removed depth maps from Stage1 to locate the regions to be removed; thus, severe depth estimation errors in Stage1 can indeed limit the overall performance. Moreover, we adopt an inference-time strategy similar to adding depth noise to mitigate this issue. A detailed example (Case A) is provided in our response to Reviewer Dwf1 Question How does the two-stage framework handle dynamic or translucent objects where depth maps are ambiguous?.

Increasing resolution

REMOVE metric

DPO lambda value

We set λ = 0.1 in our final implementation. We also experimented with higher values (e.g., λ = 0.5 and λ = 1), but both led the model to converge to an “easy” solution, where the masked regions were overly smoothed and simply filled with uniform depth values, rather than preserving geometric details. The lower value of 0.1 provides a better balance between enforcing geometric consistency and maintaining fine structural details.

Thank you for your responses, which have addressed my concerns. I will raise my score to a 5 and hope for acceptance. I would also like to thank the authors for their effort for trying to provide explanations with caption of images and tables as this year they are unable to provide visualizations.

Computational cost & High resource usage.

We appreciate the reviewer’s comment on the computational cost. In terms of runtime, our current implementation takes approximately 1 s for depth estimation, 7 s for geometry removal (Stage 1), and 20 s for appearance rendering (Stage 2) per image (512 * 512) on a single H100 GPU. We would like to emphasize that our implementation has not yet been optimized for latency. In practical deployment scenarios, various acceleration strategies—such as model distillation and architectural pruning—can be applied to significantly reduce inference time. Therefore, although the current runtime introduces some overhead, it does not pose a significant obstacle to practical applications. Regarding memory usage, the overall peak memory consumption is 34GB, which poses no practical limitation for deployment on current GPU hardware.

Reliance on depth estimation & Depth estimator dependency.

We appreciate the reviewer’s insightful comment regarding the reliance on depth estimation. Our method indeed assumes accurate geometry as a prerequisite, and performance may degrade if the depth estimation fails in complex scenes. Nevertheless, recent progress in this field has significantly improved robustness in such scenarios. For example, Choi et al ("Self-supervised Monocular Depth Estimation Robust to Reflective Surface Leveraged by Triplet Mining." ICLR. 2025.) explicitly address reflective and complex surfaces. With such rapid advances, obtaining reliable geometry is becoming increasingly feasible, which we believe will further strengthen the applicability of our method.

Paired data requirement.

We appreciate the reviewer’s valuable comment on the paired data requirement. While collecting perfectly paired data can be challenging in some real-world scenarios, recent works have shown that such data can be efficiently extracted from videos (e.g., RORD and OmniEraser), and most state-of-the-art object removal methods also rely on paired supervision. Moreover, with the rapid progress in text-to-video generation, creating paired data is becoming increasingly practical. For example, a simple prompt such as “A red apple sits on a table; a hand enters the frame and takes the apple away” can generate frames with and without the object, naturally forming paired training samples.

How does the two-stage framework handle dynamic or translucent objects where depth maps are ambiguous?

Note: Dear Reviewer, we sincerely thank you for your time and effort in reviewing our work. Due to the official policy for this year’s rebuttal process, we are, unfortunately, unable to share the carefully prepared one-page document of additional visualizations. These include failure cases, intermediate results, and various edge case examples, which we found both interesting and thrilling to analyze, as they were inspired by the reviewers’ constructive comments. We also reached out to the AC to ask whether we could share this document in the same way as a code link, and the AC kindly consulted the program chairs on our behalf; however, we were informed that this is not allowed. Despite these constraints, we are making every effort to describe these visualizations in detail so that you can still obtain the corresponding information. These described figures are referred to using lettered indices (Case A–H). We will update our main submission with content from this document.

We appreciate the reviewer’s insightful question. Our Stage 2 model determines which regions to remove by comparing the difference between the original and the geometry-removed depth maps. For dynamic or translucent objects, depth estimation can be incomplete, resulting in little or no difference between the two depth maps and thus limiting Stage 2’s effectiveness.

In Case A, three individuals are running, and motion blur caused by high-speed movement leads to erroneous depth estimation by Depth Anything. Specifically, the depth of one runner’s foot is completely misestimated as part of the background. Consequently, during Stage 1 geometry removal, this foot region lacks valid depth information, and the Stage 1 output becomes almost identical to the input depth map.

Since Stage 2 relies on comparing the input and output depth maps from Stage 1 to identify the regions requiring removal, no removal occurs when both maps are nearly identical. In this case, the absence of reliable geometric guidance prevents Stage 2 from performing effective object removal.

Fortunately, this issue can be easily addressed by filling the missing depth values within the masked region using the maximum depth value from its local neighborhood (e.g., a 10×10 pixel window). Surprisingly, simply propagating the maximum depth value from nearby pixels—“borrowing depth from neighbors”—almost magically restores the missing foot geometry, enabling Stage 2 to confidently erase the leg. In addition, missing depth values can be detected by checking whether the depth within the masked region remains almost unchanged before and after geometry removal.

After applying this Local Max Depth Fill-in strategy, the previously missing foot depth is filled with the maximum depth values from its local neighborhood, producing a pseudo-complete depth map and significantly enhancing the depth contrast between the masked region and its surroundings. Stage 2 can thus accurately identify the foot region as an object to be removed, resulting in the correct elimination of the runner’s leg and a visually consistent reconstruction of the ground surface. This demonstrates that even a simple geometric completion strategy can substantially improve the robustness of our two-stage framework under challenging dynamic conditions.

We also provide transparent and semi-transparent examples in Case B and Case C. The Case B shows a fully transparent glass sphere placed on grass. The distorted, magnified grass patch is particularly interesting, as it appears as though the grass “jumps forward” in depth, confusing the estimator. However, as long as the depth of the grass exists, our model can still remove the magnified grass behind the glass sphere. The Case C shows a large transparent water jug and five semi-transparent cups on a reflective table. What is fascinating here is that despite the complex light interactions on the reflective table, the model precisely identifies and removes the cups with its reflection. These results demonstrate that our model is reasonably robust to both transparent and semi-transparent objects. We will include these findings and discussions in the final version of the paper.

What are the trade-offs between the strict mask alignment in Stage 1 and the flexibility of loose alignment in prior work?

There is an inherent trade-off between strict and loose mask alignment. During training, strict mask alignment provides clear geometric guidance, explicitly indicating which regions should be modified and which should remain unchanged. However, its limitation becomes evident during inference: if the user provides an imperfect mask—e.g., failing to fully cover a cup—the uncovered parts will not be removed. In contrast, loose mask training improves robustness to low-quality masks by allowing the model to modify regions outside the given mask, reducing its reliance on precise mask inputs. The downside, as illustrated in Figure 1 of the paper, is that it often alters unintended regions, causing uncontrolled geometry modifications.

We therefore do not adopt loose mask training, as our strict alignment framework combined with mask-level augmentation can already reduce the dependence on high-quality masks during inference while avoiding unintended geometry modifications. Instead, following SmartEraser, we introduce mask-level data augmentation under the strict alignment framework, including mask dilation, boundary perturbation, and slight morphological expansion. This augmentation exposes the model to imperfect masks during training, enabling it to tolerate minor mask inaccuracies while retaining the structural precision guaranteed by strict mask alignment. In practice, we observe that as long as the mask covers approximately 95% of the target object, our method can still achieve reliable geometry removal, demonstrating robustness to small inaccuracies in mask coverage.

Artifact scope.

We appreciate the reviewer’s question. Motion blur is indeed a causal artifact induced by object motion and thus, in principle, fits within the scope of our geometry-driven framework. However, our current training lacks paired data that explicitly provides motion blur supervision, which limits its performance in such scenarios. We observed in Case A, after the runner’s leg is removed, the model does not attempt to erase the motion blur associated with the leg. Instead, it interprets the occluded region as if it originally contained motion blur and “faithfully completes” that blurred streak, treating it as part of the static background rather than as an artifact to be removed. This limitation is common to all existing object removal methods, as paired supervision for motion blur removal is rarely available. As more paired datasets or video-based supervision become available, our two-stage design should naturally generalize to handle motion blur due to its reliance on geometric priors rather than artifact-specific heuristics. We are very interested in exploring this further as our next step.