OVERKILL — Use OVERKILL to remove duplicate/overlapping objects (intro)

Historical Context & Motivation

From the earliest days of computer-aided design, the problem of duplicate geometry has plagued engineering teams. When designers copy objects, import external references, or merge drawings from multiple contributors, entities frequently stack on top of one another in the exact same location. These duplicates are often invisible to the naked eye yet they accumulate insidiously, inflating file sizes, causing lines to plot at incorrect weights, and producing unexpected selection behavior. Before Autodesk introduced a purpose-built solution, practitioners had to rely on tedious manual inspection or custom LISP routines to locate and purge redundant objects—a process that scaled poorly as project complexity grew.

The fundamental question OVERKILL addresses is deceptively simple: given a drawing that may contain thousands of entities, how can we efficiently identify and remove objects that are geometrically coincident while preserving intentional design elements? Answering this question requires understanding what constitutes a "duplicate" in the context of a CAD database, how tolerance values affect comparison, and which object properties should be considered during the matching process.

Core Principles & Definitions

At its core, OVERKILL is a cleanup command that scans a selection set of drawing entities, compares their geometric definitions and optionally their property attributes, and deletes those it determines to be duplicates or overlapping segments. Unlike a simple "select all and delete" operation, OVERKILL applies configurable matching criteria—tolerances, property filters, and object-type awareness—so that it can distinguish between genuinely redundant geometry and entities that merely appear similar. Understanding the principles below is essential before invoking the command on production drawings.

Visual Explanation — How OVERKILL Identifies Duplicates

The diagram above illustrates the two primary modes in which OVERKILL operates. Exact duplicate removal handles the case of Line A/A′ and Circle B/B′, where two entities share identical defining geometry within the tolerance. Partial overlap merging handles collinear segments like C and D that share a common subsegment; OVERKILL combines them into one entity that spans the union of both segments. This distinction is important because partial overlaps are more subtle—they do not present as stacked objects but rather as segments whose endpoints differ yet whose trajectories share a common region.

How OVERKILL Works — The Matching Algorithm

Although Autodesk does not publish the exact internal algorithm, the behavior of OVERKILL can be understood through the lens of spatial hashing and pairwise comparison with tolerance. Conceptually, the process involves three stages: selection filtering, geometric comparison, and property comparison. Each stage narrows the candidate set of duplicates before the final deletion pass.

Stage 1 — Entity Classification

OVERKILL first partitions the selection set by entity type. Lines are compared only with lines, circles with circles, arcs with arcs, and so on. This type-based bucketing reduces the comparison space from O(n²) over the entire selection to O(n²) within each type bucket, which is significantly smaller in practice because most drawings contain a heterogeneous mix of entity types.

Stage 2 — Geometric Comparison

For lines, OVERKILL compares start and end points (in both orderings, since a line from A→B is the same as B→A). For circles, it compares center points and radii. For arcs, it additionally checks start and end angles. The comparison uses the numeric tolerance value specified in the dialog, which defaults to 0.000001 drawing units. Setting a larger tolerance—say 0.01—allows OVERKILL to catch near-duplicates that result from floating-point rounding during coordinate transformations.

Stage 3 — Property Comparison

After geometric coincidence is established, OVERKILL optionally checks whether the candidate pair shares identical values for each enabled property: color, layer, linetype, linetype scale, lineweight, plot style, thickness, transparency, and material. If the "Ignore" checkbox for a property is checked, that property is excluded from the comparison, making the matching less strict. When all enabled properties match (or when all properties are ignored), one of the two entities is deleted and the other is retained.

OVERKILL Dialog Options — A Detailed Breakdown

When you invoke OVERKILL from the command line or the ribbon (Modify panel → Delete Duplicates), a dialog box appears with two sections: Object Comparison Settings and Object Modification Options. The following diagram and table map out each option and its effect on the deduplication logic.

Worked Example — Cleaning a Contaminated Floor Plan

You have received a floor-plan DWG from an external consultant. Selecting all entities in model space reports 14,322 objects. After visual inspection, you suspect many walls and column outlines have been duplicated during the copy-paste assembly of repeating units. Your goal is to remove all duplicate and overlapping geometry while preserving layer assignments and associated dimensions.

OVERKILL vs. Alternative Cleanup Methods

OVERKILL is not the only tool available for drawing cleanup. AutoCAD provides several other commands and utilities that address related but distinct problems. Understanding when to use each one prevents both under-cleaning (leaving duplicates) and over-cleaning (breaking valid geometry or associations). The table below compares OVERKILL with four commonly confused alternatives.

Scripting OVERKILL and Connection to Advanced Workflows

For Computer Science students, the real power of OVERKILL emerges when it is integrated into automated workflows. AutoCAD exposes OVERKILL through its command-line interface, which means it can be invoked from AutoLISP scripts, .NET plugins, or script files (.scr) for batch processing across hundreds of drawings. The system variable OVERKILLSETTINGS (a bit-coded integer) stores dialog preferences, enabling non-interactive execution.

In larger organizations, OVERKILL is often embedded in a CI/CD-like pipeline for CAD deliverables. A nightly job iterates over a directory of DWG files, opens each in a headless AutoCAD Core Console session, runs AUDIT → OVERKILL → PURGE, saves the file, and logs the deletion count. This mirrors the concept of static analysis in software engineering: just as a linter flags dead code and redundant imports, OVERKILL flags dead geometry and redundant entities. Future lessons will explore writing AutoLISP wrappers that expose OVERKILL with custom pre- and post-processing hooks.

Practice Problems

OVERKILL — Summary & Review