DXF and the classes

What each class becomes in a DXF file, what each entity of a file becomes when it is read, and how a frame, a layer and a version are kept.

Two sides: geometry and drawings

DXF is read and written by compiled code, src/__dxf__.cc, which needs nothing but Octave. It takes the objects themselves and builds them by their constructors, so there is no list of entities to handle in between. The package meets DXF from two sides:

Both sides write the same format, R2000 by default, and both read files from R12 to R2018, so a file written from one side can be read by the other.

Writing geom objects

Each geom class has a write method, and geom.write writes a cell array of any mix of them in one pass. The file name must end in .dxf.

Geom objects carry no layer, line type or colour of their own; the options give them, one value for every object or, in geom.write, a cell array of one per object:

R = geom.Region ([0, 0; 60, 0; 60, 40; 0, 40], {[20, 20, 1; 40, 20, 1]});
P = geom.Path ([0, 0, 0; 0, 0, 50; 30, 0, 80]);

write (R, 'plate.dxf', 'Layer', 'PLATE', 'Fill', true);
geom.write ({R, P}, 'parts.dxf', 'Layer', {'PLATE', 'ROUTE'});

A DXF file is not appended to. Adding to one rewrites its tables, its handles and its objects section, so a file is written whole, from every object it is to hold.

Reading geom objects

What is in the file

Without options, geom.read returns what is in the file: a row cell array with one geom object per entity, in the order of the file, nothing joined and nothing reclassified.

A group the package wrote comes back whole, so what was written is what is read: a region keeps its holes, a closed path stays a path, and the hatch written with 'Fill' is part of its region, never a second one. 'Layer' keeps only what lies on one layer, its name compared without regard to case, as CAD programs compare them.

C = geom.read ('plate.dxf')                     # one region, with its bore
C = geom.read ('parts.dxf')                     # a region and a path
C = geom.read ('parts.dxf', 'Layer', 'route')   # the path alone

Building one object from loose entities

A file from another program holds loose lines and arcs, not regions. 'Type' builds one object of a class from them:

Ends closer than 1e-4 mm are joined and snapped to one point, which is above the rounding of coordinates in a file and below anything that can be made. The package's own groups count as already built. Exactly one object must result: more than one is an error naming the layer, as is finding candidates on several layers with no 'Layer' given, and finding none. Separate parts belong on separate layers, and 'Layer' picks one.

Four separate lines, as a CAD program would leave them, become one region ready to extrude:

L = {geom.Polyline([0, 0; 50, 0]), geom.Polyline([50, 0; 50, 30]), ...
     geom.Polyline([50, 30; 0, 30]), geom.Polyline([0, 30; 0, 0])};
geom.write (L, 'lines.dxf', 'Layer', 'PROFILE');

C = geom.read ('lines.dxf');                    # four open polylines
R = geom.read ('lines.dxf', 'Type', 'region');  # one closed region
S = solid.extrude (R, 10);

Whatever is skipped, and with 'Type' whatever is left over, is reported in one warning per read, counted by entity type.

Frames

Every geom object lies in a geom.UCS, and DXF has no place for one, so the package keeps it as extended data under the registered application DRAFTING: the origin in group 1011 and the x axis in group 1013, and for a path, a spline or a region the normal in a second 1013, since a flat entity keeps its normal in group 210. On a group, the same data names the class, geom.Path or geom.Region, in group 1000.

geom.read restores the frame, for a flat object only when the stored normal still matches the entity's and the origin still lies in its plane. The coordinates of the entities stay authoritative, so a frame left stale by an edit elsewhere can never move the geometry.

## A region in the plane x = 5, written and read back in the same frame
T = geom.Region ([0, 0; 30, 0; 30, 20; 0, 20]);
T.UCS = geom.UCS ([1, 0, 0], [5, 0, 0]);
write (T, 'tilted.dxf');
B = geom.read ('tilted.dxf', 'Type', 'region');
B.UCS == T.UCS

A file without that data is read in any plane. An entity whose normal is the world z axis is moved to its height. One whose normal points down the z axis is mirrored into the plane facing up first, as 2-D CAD programs treat it. Any other is read in DXF's own frame for its plane. Paths and splines are read in world coordinates.

Drawings

write (D, FILE) writes a draw.Drawing with its layer table and every entity on its layer. Each entity is written as itself:

A drawing writes no frames, since everything in it lies in z = 0: its path and region groups carry only their class name.

Layers

A drawing keeps a layer table, as a DXF file does, and the two map one to one:

An entity drawn 'byLayer', as entities are unless told otherwise, is written by layer: no line type, colour or weight of its own, so a CAD program that changes a layer changes everything on it. An entity with a colour, line type or weight of its own is written with it. Read back, the table returns whole and by-layer entities stay by layer.

draw.read gives the drawing back as a draw.Drawing named 'imported', with the file's layer table and each entity on its layer. Dimensions return as dimensions, rebuilt from their definition points as the method that would have made them, so they measure the geometry again rather than repeating a number. Blocks return with their inserts, nested blocks included, hatches over their regions, and a path or region the package wrote as that path or region. A hatch pattern the package does not define is drawn as 'ANSI31', and an MTEXT returns as one line of text, its formatting removed.

R = geom.Region ([0, 0; 60, 0; 60, 40; 0, 40], {[20, 20, 1; 40, 20, 1]});

D = draw.Drawing ('plate');
D.Layer = 'OUTLINE';
D = D.region (R);
D.Layer = 'DIMENSIONS';
D = D.dim ([0, 0], [60, 0], -10, 'horizontal');
D = D.diam ([30, 20], 10);
write (D, 'drawing.dxf');

E = draw.read ('drawing.dxf');                  # the region and two dimensions
layers (E)                                      # DIMENSIONS and OUTLINE

write (D, 'exploded.dxf', 'Dimensions', 'explode');

A drawing lies in the plane z = 0, so draw.read mirrors an entity facing down into the plane facing up and drops heights. An entity on any other plane, a mesh, a solid, an entity in paper space and an insert of a block the file does not define are skipped and reported. A geom object can go into a drawing only if it lies in the xy plane; one in another plane is written with geom.write instead.

Versions, units and text

• Written: R2000 (AC1015) by default, which holds what the package draws as itself: LWPOLYLINE with its bulges, SPLINE, ELLIPSE, HATCH, groups and extended data. R12 (AC1009) on request, for lines and arcs only.
• Read: ASCII DXF from R12 (AC1009) to R2018 (AC1032). A binary DXF is an error.
• Units: the writer declares millimetres. The reader converts coordinates to millimetres from the units the file declares in $INSUNITS, and reads a file declaring none as millimetres.
• Text: written with every character outside ASCII escaped as \U+XXXX, so it reads the same whatever the reader's code page. Read from the code page the header names before R2007, and as UTF-8 from R2007 on.