NKMPV CAD

Project Overview

NKMPV CAD is a standalone desktop computer-aided design application purpose-built for the civil engineering, surveying, and infrastructure sectors. Where general-purpose CAD platforms leave engineers to bridge gaps with spreadsheets, third-party add-ins, and manual workflows, NKMPV CAD consolidates drafting, terrain analysis, survey processing, road geometry, pavement design, materials testing, and compliance reporting into a single cohesive environment.

The product was conceived to address a long-standing pain point in the Indian infrastructure market: the fragmentation of tools used across a typical civil project lifecycle. A practicing engineer often moves between a general CAD program for drafting, a separate survey processor for terrain data, a spreadsheet for earthwork calculations, a stand-alone application for pavement design, another for laboratory reporting, and yet another for producing PDF deliverables aligned to Indian Standard and Indian Roads Congress codes. Each handoff is a source of rework, errors, and wasted time.

NKMPV CAD eliminates that friction. It offers the familiar drafting experience engineers already know — AutoCAD-style commands, snapping, ribbons, and layer management — augmented with native modules for the calculations and deliverables that dominate the daily work of a civil practitioner. The result is a category-defining desktop application that positions itself not as a "CAD with plugins" but as an integrated engineering workstation. From a commercial perspective, it reduces tooling costs, shortens project turnaround, and standardises output quality — outcomes that directly move the needle for small-to-mid-sized engineering consultancies, public works departments, and infrastructure contractors.

Key Features & Functionality

The product delivers a comprehensive drafting and engineering feature set spread across several well-defined domains.

Drafting and editing. Users produce and modify technical drawings using a complete suite of 2D primitives — lines, circles, arcs, rectangles, polylines, ellipses, splines, hatches, text, and dimensions — alongside the editing tools engineers expect: move, copy, rotate, scale, mirror, offset, trim, extend, fillet, chamfer, array, stretch, break, join, and explode. Every command supports an unlimited undo/redo stack and is accessible through menus, ribbon tabs, toolbars, or a keyboard-driven command line.

Precision drafting aids. Object snap, orthogonal locking, polar tracking, grid snap, grips-based editing, and contextual command preview give the experience a feel indistinguishable from industry-standard CAD, lowering the learning curve for anyone migrating from established packages.

Survey and terrain. A dedicated survey module ingests point data from CSV exports, GPS NMEA streams, total-station downloads, and KML/KMZ files. From these inputs it produces topographic drawings, triangulated surfaces, contour maps, longitudinal and cross-sections, and terrain interpolations — the core deliverables of any surveyor or alignment engineer.

Road and pavement design. The platform computes horizontal and vertical alignments, circular and transition curves, summit and valley profiles, earthwork quantities by multiple established methods, pavement thicknesses, and roughness indices, all with the conventions and units expected on Indian infrastructure projects.

Materials testing and reports. Laboratory technicians and quality engineers generate branded, code-compliant PDF reports for California Bearing Ratio, Proctor compaction, sieve analysis, Atterberg limits, concrete cube strength, Marshall stability, bituminous mix design, pavement deflection, and earthwork quantity — each mapped to the relevant standard.

Intelligent assistance. An integrated AI assistant helps users draft commands, generate reports, check drawings against compliance rules, and auto-propose dimensioning or block recognition.

Interoperability. Drawings import and export via the industry-standard DXF format, ensuring the tool plugs cleanly into existing project workflows and deliverable chains.

Technology Stack

NKMPV CAD is built entirely in Python, leveraging a modern open-source desktop stack:

• PySide6 (Qt 6) for the cross-platform desktop UI, including windows, dockable panels, dialogs, ribbons, and the canvas.
• Qt Graphics View Framework for the high-performance drafting canvas.
• NumPy and SciPy for geometric computation, triangulation, interpolation, and numerical routines.
• ezdxf for reading and writing DXF drawing files.
• pyproj for coordinate-system and projection transforms used in surveying workflows.
• Matplotlib for chart generation inside reports.
• ReportLab for branded PDF report output.
• openpyxl and pandas for Excel-based data import and export.
• lxml for KML/KMZ parsing.
• Anthropic Claude for the built-in AI assistant.

Deployment targets Microsoft Windows through a native installer produced with PyInstaller and NSIS, allowing end users to install and run the product without any pre-existing Python environment. This deliberately open-source stack was chosen to give the product full control over its runtime, avoid licensing entanglements with third-party CAD platforms, and keep long-term maintenance and distribution within the product owner's hands.

Technical Complexity & Challenges

Building a CAD application from the ground up is a substantial undertaking, and NKMPV CAD addresses several categories of non-trivial technical work.

A custom geometry kernel. Rather than leaning on an off-the-shelf CAD engine, the product implements its own geometry layer covering points, lines, arcs, polylines, circles, rectangles, text, and dimensions, each with bounding-box, hit-testing, transformation, cloning, and serialisation behaviour. The decision to build this in pure Python keeps the stack portable and transparent while careful attention to data structures preserves interactive performance.

A professional input pipeline. Matching the feel of a mature CAD product requires a command loop that can blend mouse events, keyboard shortcuts, typed commands, coordinate parsing, modifier keys, contextual prompts, and transient overrides. NKMPV CAD implements a purpose-built input subsystem — command registry, dispatcher, coordinate parser, keymap, context-menu handler, and grip-session manager — that gives every tool a consistent, predictable interaction model.

A transactional document model. Every edit passes through a command object that can be inverted, enabling unbounded undo/redo across every operation in the product. This discipline, enforced at the architectural level, is what allows hundreds of individual tools to behave cohesively.

Snap and hit detection at scale. A drafting canvas must resolve snap candidates, proximity queries, and cursor-under-entity decisions in real time while drawings grow to thousands of objects. The canvas implementation combines spatial reasoning with Qt's scene graph to keep interaction responsive under load.

Engineering calculations with regulatory fidelity. Because the output of the calculation modules feeds real-world infrastructure deliverables, each engine must reproduce the results that engineers would compute by hand under the relevant published standard. Translating public standards into reliable, testable software — and keeping them aligned with occasional revisions — is a distinct engineering discipline in its own right.

A cohesive end-to-end experience. Stitching drafting, 3D, survey, calculations, reports, and AI into a single product required careful decisions around module boundaries, shared services, and a consistent interaction model. Each module had to be buildable and testable on its own while still feeling like part of a single application.

Design & User Experience

The user-experience philosophy behind NKMPV CAD is straightforward: meet engineers where they already are.

Draftspeople in the target market have years of muscle memory built around a small set of command aliases, a command line that accepts two-letter shortcuts, a status bar that toggles snap and ortho with single keys, and a ribbon that groups related tools visually. The product honours every one of those conventions. Typing a single letter starts the expected tool; the space bar repeats the last command and acts as an Enter equivalent; familiar function keys toggle drafting modes — all as experienced users would expect.

Visually, the application adopts a modern dark theme optimised for long drafting sessions and high-resolution displays. Dockable panels for properties, layers, and the command history can be rearranged and saved, giving each user a layout tuned to their workflow. The splash screen, iconography, and window chrome carry the product's own identity rather than inheriting a generic look.

Crucially, the experience is tuned for productivity rather than novelty. There are no unnecessary animations, no forced tutorials, and no friction between a user's intent and the drawing on screen. Dialogs for layer management, drafting settings, hatch patterns, and options are laid out in a way that mirrors the panels engineers already know, so moving to NKMPV CAD does not require unlearning habits.

Scale & Scope

The codebase is substantial for a single-product desktop application:

• Over 37,000 lines of Python across the main package and test suite.
• Roughly sixty source modules distributed across ten top-level domains: core geometry, 3D primitives, UI, commands, input, calculations, parsers, AI, reports, and templates.
• More than ten calculation engines covering surveying, earthwork, contour generation, traverse adjustment, road geometry, pavement, mix design, deflection, roughness, quantities, and interpolation.
• Six data parsers covering survey CSV, GPS NMEA, total-station exports, KML/KMZ, Excel lab sheets, and roughness-sensor output.
• Ten PDF report templates each mapped to a specific industry standard.
• Thirteen automated test modules totalling roughly 4,500 lines, providing coverage for calculations, parsers, command tiers, 3D work, reports, express tools, and the input subsystem.
• A native Windows installer produced through a dedicated build pipeline.

The result is a codebase with the breadth of a commercial CAD product and the structural discipline needed to keep that breadth maintainable.

Business Impact & Use Case

The product's target users sit at the operational heart of Indian infrastructure delivery:

• Civil and highway engineering consultancies preparing alignment drawings, earthwork estimates, and tender deliverables.
• Surveying firms processing field data into topographic drawings and cross-sections.
• Public works and roads departments standardising on a single tool across project offices.
• Materials testing laboratories issuing compliance-grade reports for clients.
• Construction contractors reconciling as-built data against design drawings.

For each of these audiences, the commercial case is compelling. A single seat of NKMPV CAD displaces a mix of imported CAD licences, spreadsheet templates, hand-maintained macros, and stand-alone reporting utilities. It reduces training overhead because its drafting experience mirrors the market standard, while its calculation and reporting modules remove the bespoke tooling each firm otherwise maintains at its own cost. Beyond direct savings, the product helps firms deliver faster and with fewer errors: one tool, one data model, one set of units, one consistent output style. For a consultancy competing on turnaround and quality, those are the attributes that win repeat work.

Development Approach

The project is structured around a staged, module-by-module delivery model. Each domain — drafting, modify tools, dimensions, calculations, parsers, reports, AI, express tools, polish — is built, exercised, tested, and stabilised before the next is begun. This discipline keeps the application runnable and demonstrable at every point in its evolution and lets individual modules ship with confidence rather than waiting on a distant release milestone.

Quality is enforced through a comprehensive automated test suite. Calculations are verified against expected reference outputs. Parsers are exercised against representative sample data shipped alongside the project. Command tiers, grips, reports, 3D primitives, and the input system each have dedicated test modules. The test folder is a first-class citizen of the codebase rather than an afterthought.

Architecturally, the product favours clear module boundaries: geometry knows nothing about the UI, the UI knows nothing about the persistence format, calculations run headless and produce results independent of the canvas, and reports consume calculation outputs through well-defined interfaces. This separation makes it straightforward to evolve any one layer without destabilising the others, and also makes the calculation engines reusable in future contexts — for instance, web or mobile companion tools.

Finally, the product is engineered for ownership and portability. It ships as a self-contained Windows application with no runtime dependency on third-party CAD software, puts all intellectual property squarely in the product owner's hands, and runs on a stack that can be maintained by any competent Python engineering team. This combination of breadth, quality discipline, and clean ownership is what separates a serious desktop product from a prototype — and is what makes NKMPV CAD a credible showcase of end-to-end product engineering.