DOCSEARCHbyAlgolia
Submit Docs

dxf-viewer

repository·master·Indexed 20 days ago

https://github.com/vagran/dxf-viewer

A high-performance 2D DXF viewer built with JavaScript and WebGL (three.js). It features geometry batching, instanced rendering, and web-worker compatibility to efficiently handle large CAD files. The library includes a specialized parser fork of dxf-parser that supports stream parsing and result filtering to minimize memory consumption.

Tokens
7.4K
Snippets
24
Records
34
Agent score
69%

What's inside dxf-viewer

  1. Overview of dxf-viewer features

    master

    The dxf-viewer is a JavaScript-based 2D DXF viewer that uses WebGL (via three.js) for high-performance rendering of large real-world files.

    Key architectural features include:

    • Web-Worker Compatibility: File fetching, parsing, and preparation are decoupled, allowing you to off-load heavy processing to a web worker to keep the UI responsive.
    • Geometry Batching: Minimizes draw calls by creating a minimal number of rendering batches during file processing.
    • Instanced Rendering: Uses WebGL instancing for entities rendered multiple times with different transforms (e.g., DXF block instances) to optimize performance.
    • Layer Support: Rendering batches respect DXF layers, allowing them to be easily hidden or shown.
    • Font Support: Supports multiple fonts, including raw TTF files, which are lazy-loaded as needed based on character requirements.

  2. Overview of dxf-viewer parser improvements

    master

    The dxf-viewer parser is a fork of dxf-parser designed to handle large DXF files more efficiently and support more complex DXF features. Key improvements include:

    • Stream Parsing: Parses text as it is fetched without buffering, allowing for the processing of huge files with limited memory consumption.
    • Result Filtering: Filters data on-the-fly to exclude unnecessary information, further minimizing memory usage during processing.
    • Expanded DXF Support: Supports additional DXF groups and features like hatching that may be missing in the original implementation.

  4. Understand RenderBatch and geometry batching

    master

    A RenderBatch is a collection of geometry that shares the same BatchingKey (layer, block name, geometry type, color, etc.). This allows the renderer to draw multiple entities in a single call.

    Batch types include:

    • Indexed: Uses IndexedChunk objects to store vertices and indices. This is used for INDEXED_LINES and INDEXED_TRIANGLES.
    • Block Instance: Stores Matrix3 transforms in a DynamicBuffer for instanced rendering of blocks.
    • Unindexed: Stores raw vertices in a DynamicBuffer (e.g., for POINTS or simple LINES).

    Methods:

    • PushVertex(v): Adds a 2D vertex to the batch.
    • PushChunk(verticesCount): Reserves space for a specific number of vertices in an indexed chunk.
    • PushInstanceTransform(matrix): Adds a 3x3 transform matrix for instanced block rendering.
    class RenderBatch {
    constructor(key) {
        this.key = key
        if (key.IsIndexed()) {
            this.chunks = []
        } else if (key.geometryType === BatchingKey.GeometryType.BLOCK_INSTANCE) {
            this.transforms = new DynamicBuffer(NativeType.FLOAT32)
        } else {
            this.vertices = new DynamicBuffer(NativeType.FLOAT32)
        }
    }
}

  5. How PolyfaceMesh entities are decomposed

    master

    PolyfaceMesh entities are decomposed into either triangles or a wireframe, depending on the viewer's configuration.

    • Triangulation (Default): The mesh is decomposed into Entity objects of type TRIANGLES. Faces with 3 or 4 indices are converted into triangles.
    • Wireframe Mode: If options.wireframeMesh is enabled, the system renders the edges of the faces as LINE_SEGMENTS or POLYLINE entities instead of solid triangles.
    • Index Handling: The system handles 16-bit complement indices (common in some DWG-to-DXF converters) by converting negative indices to their positive counterparts.

  6. How Block (INSERT) entities are processed

    master

    When the viewer encounters an INSERT entity, it processes the referenced block to render its contents.

    • Nested Blocks: The system supports nested blocks by recursively calling _ProcessDxfEntity within a NestedBlockContext.
    • Transformation: Each block instance is assigned a transformation matrix (via GetInsertionTransform) which is applied to all entities within the block.
    • Flattening vs. Instancing:
      • Flattening: If the block is marked as flatten, its geometry is merged directly into the appropriate rendering batches.
      • Instancing: If not flattened, the block is treated as an instance, and its transformation matrix is stored in a batch for efficient rendering.
    • Layer and Color Inheritance: The INSERT entity's layer and color can override the properties defined within the block itself.

  7. How BlockContext manages transformations

    master

    A BlockContext is used to manage the coordinate system and transformations when rendering blocks (and nested blocks). It handles three types of contexts:

    • DEFINITION: Rendering the actual geometry inside a block definition.
    • NESTED_DEFINITION: Rendering a block that is inside another block definition.
    • INSTANTIATION: Rendering a specific instance of a block in the scene.

    Key behaviors:

    • Vertex Transformation: TransformVertex(v) applies the block's internal transformation and calculates the vertex position relative to the block's origin (offset).
    • Insertion Transform: GetInsertionTransform(entity) calculates the Matrix3 required to place a block instance at a specific position, rotation, and scale, including handling for negative extrusionDirection.z (which mirrors the X axis).
    BlockContext.Type = Object.freeze({
    DEFINITION: 0,
    NESTED_DEFINITION: 1,
    INSTANTIATION: 2
})

  8. Understand the Entity abstraction

    master

    The Entity class is an internal representation used to decompose complex DXF features into simpler geometry types that can be rendered.

    An Entity is defined by:

    • type: One of Entity.Type (POINTS, LINE_SEGMENTS, POLYLINE, or TRIANGLES).
    • vertices: An array of {x, y} coordinates.
    • indices: (Optional) An array of indices for indexed geometry.
    • layer: The name of the layer the entity belongs to.
    • color: The color value.
    • lineType: The type of line.
    • shape: A boolean indicating if the shape is closed.

    Entities can be iterated in chunks (specifically for lines) using the *_IterateLineChunks() generator to respect vertex limits.

    export class Entity {
    constructor({type, vertices, indices = null, layer = null, color, lineType = 0, shape = false}) {
        this.type = type
        this.vertices = vertices
        this.indices = indices
        this.layer = layer
        this.color = color
        this.lineType = lineType
        this.shape = shape
    }
}

  9. How Polyline entities are decomposed

    master

    Polylines are decomposed into one or more renderable Entity objects. The decomposition process accounts for several factors:

    • Vertex Types: The system distinguishes between "plain lines" and "shaped polylines" (segments with width/thickness).
    • Bulges: Vertices with a non-zero bulge property are converted into curved segments using _GenerateBulgeVertices.
    • Line Types: If a polyline contains segments with different lineType values, the polyline is split into multiple Entity objects to preserve the correct rendering.
    • Closed Shapes: The shape property of the resulting Entity is set to true if the polyline is closed.
    • Extrusion/Mirroring: If the entity has an extrusionDirection with a negative Z value, the vertices are mirrored across the X-axis via _MirrorEntityVertices before decomposition.

  10. How Spline entities are decomposed

    master

    Splines are decomposed into POLYLINE entities by interpolating points along the curve.

    • Interpolation: The system uses the _InterpolateSpline method, which implements B-spline interpolation.
    • Subdivision: The number of vertices generated is determined by the number of control points multiplied by a constant SPLINE_SUBDIVISION factor.
    • Requirements: The entity must provide controlPoints for decomposition to proceed.

  11. How Hatch entities are decomposed

    master

    Hatch entities in a DXF file are decomposed into renderable entities based on their style and geometry.

    • Solid Hatches: If an entity is marked as isSolid, it is decomposed into a single Entity of type TRIANGLES using the earcut library to triangulate the boundary loops and holes.
    • Patterned Hatches: If not solid, the system uses a HatchCalculator and a Pattern (e.g., ANSI31) to generate a series of LINE_SEGMENTS or POINTS that represent the hatch pattern within the boundary loops.
    • Boundary Loops: The system supports various boundary types including Polylines, Line segments, Circular arcs, Elliptic arcs, and Splines. These are converted into a series of Vector2 vertices.

    Key Hatch Styles supported:

    • HatchStyle.THROUGH_ENTIRE_AREA: Only the external loop is used.
    • HatchStyle.OUTERMOST: Only the external and outermost loops are used.
    • Fallback: If no specific style filtering is applied, all boundary loops are used.

  12. Configure DxfScene options

    master

    When instantiating DxfScene, you can provide a sceneOptions object to customize the scene construction.

    Note: The Build method also utilizes internal settings for arc tessellation and subdivision, which are derived from these options. While the full schema is not explicitly exported in this segment, the Build logic references:

    • arcTessellationAngle: Controls the density of vertices for arcs.
    • minArcTessellationSubdivisions: Minimum number of segments for an arc.
    • suppressPaperSpace: If true, entities in Paper Space are filtered out.