Cut Area from PDF — Smart Lasso

Rectangular cropping doesn't always fit: a stamp is round, a logo is oddly shaped, a part on a drawing has a complex outline. The Lasso tool (Cutter) in pdfredX cuts out an area of any shape — you outline the object with clicks, and the app peels it off into a separate layer you can move, mirror, and save. All in the browser, the file is never uploaded.

Step 01. Load the Document

Open pdfredX and drag a PDF or image into the upload zone. The page is rendered to Canvas locally through PDF.js — not a single byte goes to a server. Click 🖌 on the card of the page you need to open the editor.

Step 02. Pick the 🔪 Cutter Tool

In the editor, choose 🔪 Cutter (Lasso) — the cursor turns into a crosshair. This isn't freehand drawing but building a polygon point by point: the outline comes out clean instead of shaky.

Step 03. Outline the Object With Clicks

Click along the object's edge, point by point — a "rubber-band" line stretches between clicks to preview the next side. Trace the outline however suits you: the more points on the curves, the more precise the cut. Made a mistake? ESC or a right-click cancels the current outline without switching the tool off, and you can start over.

Step 04. Close the Outline

Finish the outline with a double-click or a click near the first point (within ~22 px) — the contour closes, and the area inside the polygon is peeled off into a separate fabric.Image layer. Everything outside the outline is left out.

Step 05. Reposition and Save

The #FAB_CUTTER_PANEL panel appears: Mirror H/V, Delete, OK. Drag the cut fragment where you need it, mirror it if you like. Click OK, then 💾 Save and Create PDF — the final file is assembled by jsPDF and downloaded straight from the browser. Free, no sign-up.

How It Works Under the Hood

At the core is fabric.Polygon from Fabric.js 5.3.1. Each click adds a vertex, the polygon rebuilds in real time along with the rubber-band line to the cursor. On close (fabCutterFinish), the polygon becomes a clipPath — a dynamic mask on a fabric.Image element: only the area inside the outline stays visible, the rest is clipped away. The cut fragment is exported through the Canvas API, with no server render.

Known Limitations

Precision is in the number of points. On smooth curves, place more vertices: the polygon joins adjacent points with straight segments, so with sparse points a curve comes out faceted.

Cut along contrast. A sharp object edge against the background is easy to trace; an object that blends into the background takes more care — there's no automatic edge detection.

Rasterized output. The cut fragment is an image, not a vector. Selectable text inside it becomes part of the picture after saving.

If your goal isn't to cut out an object but to remove it and rebuild the background in its place (so no trace is left), that's the Remove Object from PDF tool.

Try it now — pdfredx.com, no sign-up, your file stays with you.

You need one element out of a document — a stamp, a signature, a section of a drawing, a piece of a layout. A small task, but the document is often whole: a contract, technical documentation, a mockup under NDA. And to cut out one fragment, an ordinary online service asks you to upload the entire file to its server. Let's look at why that's an unnecessary risk and how to cut along a contour locally, in the browser.

Where the Document Goes on Server-Side Cutters

When you upload a PDF to a typical online editor, the whole file travels to a remote machine. What happens next depends on the service's policy — the one few people read:

• the file is written to a contractor's temporary storage (AWS, GCP, Azure);
• it's processed on someone else's server;
• it's retained anywhere from hours to days "for reliability";
• it's logged along with metadata — IP, timestamp, file name and size.

The paradox: to pull out one stamp, you hand over the whole original — with that stamp and all the rest of the content — to a machine you don't control. For drawings under NDA, contracts, and mockups, that's a direct leak of intellectual property.

Full Browser Isolation: How pdfredX Cuts Along a Contour

pdfredX does not upload your file to any server. It's a property of the architecture you can verify.

The file is read locally. PDF.js opens the document in the tab through FileReader and draws the page to Canvas. There's no network request carrying your file.

The cut is computed in the tab's memory. The lasso builds a polygon and applies a clipPath to the image — all pixel operations on an already-loaded page. Nothing is sent.

The finished file is assembled on the client. The cut fragment and the final PDF are composed by jsPDF right in the tab and handed to the browser for download — to your Downloads folder, not to a server and back.

Works offline. Open the tool, disconnect from the internet, and cut out the area you need — everything keeps working. The network is only needed to load the app once.

Step by Step, With No Server Upload

01. Load the document. Drag the PDF into the upload zone at pdfredx.com. FileReader reads the file locally — it never leaves the device.

02. Outline the fragment. Click 🖌 on the page, pick 🔪 Cutter, outline the object with clicks along the contour, and close it with a double-click.

03. Save and close. Drag the cut piece where you need it, click OK → 💾 Save → Create PDF. Once you close the tab, the file data is gone from memory.

What We Cannot Guarantee — An Honest Disclaimer

Client-side processing protects the document from being sent to external servers, but it isn't a shield against every threat, and claiming otherwise would be dishonest.

Malware or a keylogger already on your device. If the machine is compromised, software can read files from disk outside the browser.

Browser extensions with broad permissions. An extension with "read data on all sites" access can, in theory, see tab content. For sensitive documents, work in a profile with no third-party extensions or in a private window.

The saved file stays on your disk. If the device isn't protected by encryption, confidential files can be read by third parties with physical access.

We provide isolation at the browser-tab level. The rest is on the user's side.

Cut the fragment you need out of a document with no server upload — pdfredx.com, free, no registration.

Cutting out a rectangle is easy. Cutting out a shape with any contour — a stamp, a part on a drawing, an irregular object — is more interesting: you need a polygon built from points, a rubber-band line trailing the cursor, a clean close, and a mask that clips away everything else. Here's how the lasso tool (cutter) in pdfredX is built: fabric.Polygon + clipPath, entirely on the client, with no server render.

The Architectural Challenge and the Choice of Approach

Why a polygon, not freehand. Freehand drawing produces a shaky contour and thousands of points. Building a polygon from clicks means deliberate vertices: the outline is clean, cheaper to compute, and the user controls every side. For contour cutting, that's the right balance between precision and convenience.

Why clipPath, not manual pixel cutting. You could zero out everything outside the contour pixel by pixel via getImageData. But Fabric.js provides a ready mechanism: clipPath — a mask bound to an object. The engine handles rendering only the inner area, hardware-accelerated, with no manual pixel loops.

Why on Canvas, not over the PDF structure. The page is already rasterized by PDF.js into an image. We work on pixels through Canvas 2D and Fabric.js, with no parsing of the binary PDF structure. And with no server: the file never leaves the tab.

Implementation Breakdown

Building the Polygon From Points

Each click adds a vertex to the point array, the polygon rebuilds, and a "rubber-band" line stretches to the cursor — a preview of the next side:

cutterPoints.push({ x, y });
// temporary preview polygon (dashed — a helper, not content)
cutterPreview = new fabric.Polygon(cutterPoints, {
  fill: 'rgba(124,92,252,.12)',
  stroke: '#7c5cfc', strokeDashArray: [5, 4],
  selectable: false, evented: false,
});

The dashed outline marks a helper object: on save, such objects are removed so the dashes don't get "baked" into the result.

Closing the Contour

The outline finishes on a double-click or a click near the first point. The proximity threshold is about 22 pixels:

const dx = x - cutterPoints[0].x, dy = y - cutterPoints[0].y;
if (Math.hypot(dx, dy) < 22) fabCutterFinish();

A 22 px threshold is a balance: smaller and it's hard to hit the first point, larger and you get accidental closes on dense contours.

Clipping via clipPath

On close, the polygon becomes an image mask:

const clip = new fabric.Polygon(cutterPoints, { absolutePositioned: true });
const cut = new fabric.Image(sourceEl, { clipPath: clip });
fabCanvas.add(cut);

Only the area inside the polygon stays visible — the rest is clipped by the mask. The fragment becomes a separate fabric.Image object you can drag and mirror.

The Trap: a Synchronous Render Before Export

The key point that's easy to get wrong. Before you grab the pixels of the cut fragment via drawImage(lowerCanvasEl), you have to synchronously remove the dashed preview polyline and force a repaint:

fabCanvas.remove(cutterPreview);
fabCanvas.renderAll();              // synchronously, BEFORE drawImage
ctx.drawImage(fabCanvas.lowerCanvasEl, ...);

Without an explicit renderAll(), Fabric repaints the canvas asynchronously, on the next frame — and the helper dashes make it into the cut fragment (this was a real bug: purple dashes "inked" along the cut edge). A synchronous render guarantees a clean result.

Tradeoffs and Limitations

Faceting on curves. The polygon joins vertices with straight lines. On smooth arcs you need more points, or the contour comes out jagged. That's the price of simplicity and predictability over splines.

No edge auto-detection. The tool cuts strictly along your points, not by the object's contrast. An edge that blends into the background takes more careful tracing.

Rasterized output. The cut is a masked image, not a vector. A text layer inside becomes part of the picture after saving.

Self-intersections. A contour with complex self-intersections is filled by Fabric according to the fill rule — the result may differ from what you expected. For a clean cut, trace the contour without loops.

If you want to check it — load a drawing or scan at pdfredx.com and cut out a fragment of any shape. No sign-up, no file uploads to any server.