Specific object deletion tool (delete unnecessary items and text from photos) | ZeroTools

This tool repairs images directly in your web browser using the HTML5 Canvas API. When you select an image file, it is loaded into the browser and scaled proportionally so that its longest edge does not exceed 800 pixels.

Processing large images at their native pixel dimensions would cause computational load and memory usage to escalate rapidly, potentially freezing the interface.

The scaled image is mapped across the display Canvas, the reference image buffer used for inpainting calculations, and an internal mask canvas that tracks areas marked for erasure.

Maintaining identical coordinate systems across the display and mask layers ensures that brush strokes drawn on screen match the underlying pixels.

This design prioritizes rapid in-browser repairs over full-resolution image editing.

Drawing the original file onto a Canvas discards container-level metadata, including Exif properties, GPS tags, camera settings, and custom color profiles.

Even if the input file contains several thousand pixels, output exports are limited to the working resolution of at most 800 pixels on the longest edge.

For projects requiring native resolution or strict color profile management, dedicated desktop software should be used instead.

The file picker provides a format hint to streamline file selection, relying on the browser's decoding engine without performing explicit MIME validation or decoding error alerts.

Files with unsupported codecs or corrupt data will fail to display properly. If neither dimension exceeds 800 pixels, the working Canvas retains the original dimensions; 800 pixels represents an upper boundary for the internal working Canvas rather than the original input file.

Handling very large image files will consume significant browser memory during decoding.

The display Canvas renders visual brush strokes and repaired imagery for the user, the processing ImageData buffer supplies RGB pixel values for patch matching, and the mask Canvas tracks remaining unfilled regions.

While all three share identical coordinate dimensions, their roles remain distinct. Exported PNG files capture the display Canvas directly, meaning any active paint overlay present during export will be included; always verify that inpainting has finished and the mask has cleared before saving.

Unwanted objects are specified using an in-browser brush interface operated by mouse dragging. Clicking and dragging the mouse draws a semi-transparent stroke onto the display Canvas and marks the corresponding coordinates on the internal mask Canvas using the selected brush thickness.

Brush sizes can be adjusted between 5 and 80 pixels in increments of 2 pixels.

The brush stroke does not automatically detect object contours. Because every painted pixel is treated as part of the mask, optimal results require covering the target object and its immediate boundary without painting unnecessarily far into surrounding background details that should be preserved.

Use narrow brush sizes for thin elements like power lines and smaller settings for dust spots.

Before each stroke, the current ImageData buffer is recorded in an undo stack so that accidental marks can be reversed. Because ImageData arrays contain four bytes per pixel, storing multiple steps increases browser memory usage.

The interface provides an undo action without redo support, and history is lost upon refreshing the page. Painting again after completing an erasure resets the finished status to indicate an active editing session.

Because responsive CSS can scale the display Canvas differently from its internal pixel dimensions, mouse event coordinates are converted using the ratio between internal dimensions and rendered CSS dimensions.

The undo stack stores display, mask, and original image buffers during the current page session, but extensive stroke histories will increase memory usage without guaranteeing unlimited state retention.

Clicking "Erase the traced part" initiates patch-based inpainting along the outer boundary of the masked region. The algorithm places 7x7 pixel exemplar patches centered on boundary pixels and searches nearby unmasked areas for candidate patches that minimize the Sum of Squared Differences (SSD) across corresponding RGB color channels.

Because the target patch contains unfilled mask pixels, similarity scoring is calculated solely across known, unmasked pixels. Candidates with lower SSD scores represent similar local colors and textures.

Matching pixel values are copied into the target area, advancing the fill boundary progressively inward.

Scanning every candidate across the entire image at single-pixel increments would be computationally prohibitive. The search radius is restricted to within 80 pixels of the target center in steps of 2 pixels, and execution is capped at a maximum of 200 iteration loops.

This algorithm does not employ generative AI or semantic scene understanding; it performs purely mathematical comparisons against existing local pixels and cannot recreate complex occluded structures like faces or architecture.

In each iteration loop, the algorithm selects up to 12 boundary pixels and evaluates 7x7 candidate patches within an 80-pixel radius sampled at 2-pixel intervals.

While candidate selection checks that the source patch center is unmasked, it does not verify that all surrounding patch pixels are known.

Reaching the 200-loop ceiling terminates the patch phase even if unfilled areas remain, making visual inspection of the result essential.

If exemplar matching fails to locate suitable patches nearby or exhausts its 200-loop limit, remaining masked regions undergo a fallback pass.

This fallback calculates the average RGB values of neighboring processed pixels across eight directions and propagates that color inward to soften remaining gaps.

Averaging colors does not reconstruct sharp patterns or fine textures. Larger masked patches filled via this method tend to appear blurred or flat, and linear structures cannot be reconstructed.

Because the fallback pass is also capped at 60 passes, complete mask clearance is not guaranteed for every shape. Always inspect the visual output and consider undoing to tackle complex marks in smaller sections.

Combining patch copying with neighbor averaging provides quick approximations for small blemishes on relatively uniform backgrounds without relying on remote generative models.

Understanding these algorithmic boundaries ensures expectations align with the tool's heuristic design.

The fallback process gathers known pixels from eight neighboring directions along the mask border and assigns their average RGB values to target pixels.

Capped at 60 passes, the routine attempts to fill remaining masked regions. Because the interface clears the mask and marks processing as complete even if unfilled areas persist after the 200 patch passes and 60 fallback passes, inspect the visual output closely, tackle complex marks in smaller sections, and use undo if needed.

This tool performs best on images featuring uniform or stochastic textures, such as clear skies, solid walls, defocused backgrounds, sand, or lawn grass where surrounding colors are readily available.

Small imperfections like sensor dust, tiny leaves, or distant figures offer ample reference pixels relative to the size of the mark.

Conversely, it struggles with structured subjects requiring continuous lines or semantic coherence, including faces, text, window frames, road markings, and tile grout.

Large masked patches, areas bordering image edges, and objects surrounded by conflicting patterns frequently lack suitable reference pixels, resulting in duplicated motifs or mismatched seams.

Rather than painting large sections at once, working in small increments with a moderately sized brush and evaluating each step yields superior results.

If an edit appears distorted, use undo to adjust the brush size, coverage, or sequence. Keep backups of important images and avoid overwriting original files with the exported PNG.

Begin by painting slightly past the target boundary to cover edge transitions. Run the erasure on a small section and inspect the Canvas for repetitive artifacts or unnatural blurring before proceeding.

If artifacts appear, revert using available undo steps and adjust your stroke area. Elongated objects like power lines should be removed in segments divided by background transitions.

Saving your work downloads the Canvas buffer as a PNG file, regardless of whether the original input was JPEG or WebP. While PNG provides lossless pixel compression, it cannot recover pre-compression detail or resolution lost during the initial downscaling step.

As a result, the output PNG file may occasionally be larger in byte size than the input JPEG.

Exporting a newly generated Canvas image strips embedded metadata such as Exif tags and GPS coordinates. While this removes location metadata incidentally, the tool is not a certified privacy scrubbing utility; verify file contents independently before publication.

Color rendering and transparency handling also reflect browser-specific Canvas implementations.

File parsing, brush rendering, patch search, neighborhood averaging, and PNG generation execute client-side via JavaScript on the main thread.

However, component-scoped local processing does not guarantee that the surrounding webpage, third-party analytics, or browser extensions are entirely free of network activity.

Adhere to organizational security protocols when handling sensitive media.

Downloaded files represent newly exported PNG copies of the working Canvas rather than modifications to your original image file.

Input files are neither overwritten nor restored to their native resolutions. Always retain source backups and independently verify exported dimensions, visual quality, and metadata prior to distribution.