abstract-3d 2.7.32 → 2.8.0

package/src/renderers/dxf/dxf-encoding/dxf-color.ts

@@ -5,51 +5,51 @@ export type DxfColor = DxfDynamicColor | string;
 
 export function dxfColor(color: DxfColor): string {
   return typeof color === "number"
-      ? `62\n7`
-      : `62
+    ? `62\n7`
+    : `62
   256
   420
   ${dxfBitShiftColor(color)}`;
 }
 
 export function dxfApproximateAciFromRealColor(colorNormal: string | undefined): number {
-    const ERROR_COLOR = 6; //magenta
-    const ACI_COLOR_COUNT = 256;
-    if(DXF_ACI_COLOR_TABLE.length !== ACI_COLOR_COUNT  || colorNormal === undefined) {
-      return ERROR_COLOR; //magenta 
-    }
-  
-    const originalColor = colorNormalToVec3Color(colorNormal);
-    let closestColor = 0;
-    let smallestDistance = Number.POSITIVE_INFINITY;
-    for(let i = 0; i < ACI_COLOR_COUNT; i++) {
-      const color = DXF_ACI_COLOR_TABLE[i];
-      if(color !== undefined) {
-        const distance = vec3DistSquared(originalColor, color);
-        if(distance < smallestDistance) {
-          smallestDistance = distance;
-          closestColor = i;
-        }
+  const ERROR_COLOR = 6; //magenta
+  const ACI_COLOR_COUNT = 256;
+  if (DXF_ACI_COLOR_TABLE.length !== ACI_COLOR_COUNT || colorNormal === undefined) {
+    return ERROR_COLOR; //magenta
+  }
+
+  const originalColor = colorNormalToVec3Color(colorNormal);
+  let closestColor = 0;
+  let smallestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < ACI_COLOR_COUNT; i++) {
+    const color = DXF_ACI_COLOR_TABLE[i];
+    if (color !== undefined) {
+      const distance = vec3DistSquared(originalColor, color);
+      if (distance < smallestDistance) {
+        smallestDistance = distance;
+        closestColor = i;
       }
     }
-    return closestColor;
+  }
+  return closestColor;
 }
 
 function colorNormalToVec3Color(colorNormal: string): Vec3 {
   const errorColor = vec3(255, 0, 255); // #ff00ff, magenta
   const paranthesisRegex = /(?<=\().+?(?=\))/;
   const inside = paranthesisRegex.exec(colorNormal);
-  if(inside === null || inside.length < 1) {
+  if (inside === null || inside.length < 1) {
     return errorColor;
   }
   const values = inside[0].replaceAll(" ", "").split(",");
-  if(values.length < 3) {
+  if (values.length < 3) {
     return errorColor;
-  } 
+  }
   const r = parseInt(values[0] ?? "", 10);
   const g = parseInt(values[1] ?? "", 10);
   const b = parseInt(values[2] ?? "", 10);
-  if(Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
     return errorColor;
   }
   return vec3(r % 256, g % 256, b % 256);
@@ -58,8 +58,9 @@ function colorNormalToVec3Color(colorNormal: string): Vec3 {
 function dxfBitShiftColor(color: string): number {
   const originalColor = colorNormalToVec3Color(color);
 
+  // oxlint-disable-next-line no-bitwise
   const colorAsInt = (originalColor.x << 16) + (originalColor.y << 8) + originalColor.z;
-  if(Number.isNaN(colorAsInt)) {
+  if (Number.isNaN(colorAsInt)) {
     return 0;
   }
   return colorAsInt;
@@ -321,5 +322,5 @@ const DXF_ACI_COLOR_TABLE: ReadonlyArray<Vec3> = [
   vec3(128, 128, 128),
   vec3(64, 64, 64),
   vec3(0, 0, 0),
-  vec3(0, 0, 0)
+  vec3(0, 0, 0),
 ];

package/src/renderers/dxf/dxf-encoding/dxf-common.ts

@@ -1,8 +1,4 @@
-import { generateUUID } from "three/src/math/MathUtils.js";
-import { vec3, vec3Cross, vec3Normalize, type Bounds3, type Vec3 } from "../../../abstract-3d.js";
-import type { DxfDimensionDefinition } from "./dxf-dimension.js";
-import { dxfEncFooter } from "./dxf-footer.js";
-import { dxfEncHeader } from "./dxf-header.js";
+import { vec3, vec3Cross, vec3Normalize, type Vec3 } from "../../../abstract-3d.js";
 
 export const DEFAULT_CIRCLE_SIDE_COUNT = 16;
 export const DXF_FONT_SIZE_RATIO: number = 11.0 / 20.0;
@@ -28,11 +24,6 @@ export function dxfRound(n: number): number {
   return Math.round((n + Number.EPSILON) * 10 ** d) / 10 ** d;
 }
 
-export function dxfBuild(groups: string, dimensions: DxfDimensionDefinition, bounds: Bounds3, size: Vec3, center: Vec3): string {
-  const id = generateUUID();
-  return dxfEncHeader(bounds, center, id, size, dimensions.block, dimensions.blockRecord) + groups + dimensions.entity + dxfEncFooter(id);
-}
-
 /*
   given an extrusion vector(normal; tags 210/220/230),
   calculate the dxf OCS x and y axises used to project
@@ -42,13 +33,14 @@ export function dxfOCSXYAxis(normalizedExtrusionVector: Vec3): {
   readonly xAxis: Vec3;
   readonly yAxis: Vec3;
 } {
-  const THRESHOLD = (1.0 / 64.0); //dxf spec
-  const xAxis = (Math.abs(normalizedExtrusionVector.x) < THRESHOLD && Math.abs(normalizedExtrusionVector.y) < THRESHOLD)
-    ? vec3Normalize(vec3Cross(vec3(0.0, 1.0, 0.0), normalizedExtrusionVector))
-    : vec3Normalize(vec3Cross(vec3(0.0, 0.0, 1.0), normalizedExtrusionVector));
+  const THRESHOLD = 1.0 / 64.0; //dxf spec
+  const xAxis =
+    Math.abs(normalizedExtrusionVector.x) < THRESHOLD && Math.abs(normalizedExtrusionVector.y) < THRESHOLD
+      ? vec3Normalize(vec3Cross(vec3(0.0, 1.0, 0.0), normalizedExtrusionVector))
+      : vec3Normalize(vec3Cross(vec3(0.0, 0.0, 1.0), normalizedExtrusionVector));
 
   return {
     xAxis,
-    yAxis: vec3Normalize(vec3Cross(normalizedExtrusionVector, xAxis))
-  }
-}
+    yAxis: vec3Normalize(vec3Cross(normalizedExtrusionVector, xAxis)),
+  };
+}

package/src/renderers/dxf/dxf-encoding/dxf-dimension.ts

@@ -1,13 +1,7 @@
 import { dimensionMeshifyAlignedDimension } from "../../../abstract-3d.js";
 import type { DimensionAligned, View, Material, Vec3 } from "../../../abstract-3d.js";
 import { type DxfColor, dxfColor } from "./dxf-color.js";
-import {
-  DXF_BLOCK_RECORD_TABLE_HANDLE,
-  DXF_MODEL_SPACE_HANDLE,
-  dxfHandleNext,
-  dxfRound,
-  type Handle,
-} from "./dxf-common.js";
+import { DXF_BLOCK_RECORD_TABLE_HANDLE, DXF_MODEL_SPACE_HANDLE, dxfHandleNext, dxfRound, type Handle } from "./dxf-common.js";
 import { dxfEncLine } from "./dxf-line.js";
 import { DxfMTextAttachment, dxfEncMText, encodeDxfFormattedText } from "./dxf-mtext.js";
 import { dxfEncSolidTriangle } from "./dxf-triangle.js";
@@ -207,25 +201,8 @@ function dxfEncodeDimensionGeometry(
   const onCreateLine = (start: Vec3, end: Vec3, _norm: Vec3, _thickness: number, _mat: Material): void => {
     entities += dxfEncLine(start, end, col, handleRef, blockRecordHandle);
   };
-  const onCreateText = (
-    pos: Vec3,
-    measurement: string,
-    fontSize: number,
-    _mat: Material,
-    _rot: Vec3,
-    dir: Vec3,
-    norm: Vec3
-  ): void => {
-    entities += dxfEncMText(
-      pos,
-      measurement,
-      dir,
-      norm,
-      fontSize,
-      handleRef,
-      DxfMTextAttachment.MiddleCenter,
-      blockRecordHandle
-    );
+  const onCreateText = (pos: Vec3, measurement: string, fontSize: number, _mat: Material, _rot: Vec3, dir: Vec3, norm: Vec3): void => {
+    entities += dxfEncMText(pos, measurement, dir, norm, fontSize, handleRef, DxfMTextAttachment.MiddleCenter, blockRecordHandle);
   };
   const onCreatePolygon = (p1: Vec3, p2: Vec3, p3: Vec3, _mat: Material): void => {
     entities += dxfEncSolidTriangle(p1, p2, p3, col, handleRef, blockRecordHandle);

package/src/renderers/dxf/dxf-encoding/dxf-footer.ts

@@ -1,6 +1,6 @@
 import { DXF_MODEL_SPACE_HANDLE } from "./dxf-common.js";
 
-/* eslint-disable max-lines */
+/* oxlint-disable max-lines */
 export const dxfEncFooter = (blockId: string): string => `  0
 ENDBLK
 5
@@ -16648,4 +16648,4 @@ RTVSPost2010PropOp57
   0
 ENDSEC
   0
-EOF`;
+EOF`;

package/src/renderers/dxf/dxf-encoding/dxf-header.ts

@@ -1,11 +1,21 @@
-/* eslint-disable max-lines */
+/* oxlint-disable max-lines */
 import type { Bounds3, Vec3 } from "../../../abstract-3d.js";
 import { DXF_BLOCK_RECORD_TABLE_HANDLE, DXF_MODEL_SPACE_HANDLE } from "./dxf-common.js";
 
 const DXF_MAKER = "DXF Generated from Divid Abstract 3D";
 const DXF_STANDARD = "AC1015";
 
-export const dxfEncHeader = (bounds: Bounds3, center: Vec3, blockId: string, size: Vec3, dimBlocks: string, dimBlockRecords: string, dimScale: number = 44.0, dimArrowSize: number = 1.0, dimTextHeight: number = 1.0): string =>
+export const dxfEncHeader = (
+  bounds: Bounds3,
+  center: Vec3,
+  blockId: string,
+  size: Vec3,
+  dimBlocks: string,
+  dimBlockRecords: string,
+  dimScale: number = 44.0,
+  dimArrowSize: number = 1.0,
+  dimTextHeight: number = 1.0
+): string =>
   ` 999
 ${DXF_MAKER}
 0
@@ -1093,7 +1103,7 @@ AcDbViewportTableRecord
  12
 ${-size.x / 2}
  22     
-${0}
+0
  13
 0.0
  23
@@ -1654,4 +1664,4 @@ ${blockId}
 ${blockId}
   1
 
-`;
+`;

package/src/renderers/dxf/dxf-encoding/dxf-line.ts

@@ -2,13 +2,7 @@ import type { Vec3 } from "../../../abstract-3d.js";
 import { type DxfColor, dxfColor } from "./dxf-color.js";
 import { DXF_MODEL_SPACE_HANDLE, dxfHandleNext, dxfRound, type Handle } from "./dxf-common.js";
 
-export function dxfEncLine(
-  vecStart: Vec3,
-  vecEnd: Vec3,
-  col: DxfColor,
-  handleRef: Handle,
-  blockRefHandle?: string
-): string {
+export function dxfEncLine(vecStart: Vec3, vecEnd: Vec3, col: DxfColor, handleRef: Handle, blockRefHandle?: string): string {
   return `  0
 LINE
 5
@@ -33,4 +27,4 @@ ${dxfRound(vecEnd.y)}
 31
 ${dxfRound(vecEnd.z)}
 `;
-}
+}

package/src/renderers/dxf/dxf-encoding/dxf-lwpolyline.ts

@@ -28,18 +28,15 @@ export function dxfEncLwPolyline(
     return undefined;
   }
 
-  if(points.length === 2) {
+  if (points.length === 2) {
     const a = points[0];
     const b = points[1];
-    if(a === undefined || b === undefined) {
+    if (a === undefined || b === undefined) {
       return undefined;
     }
 
     const direction = vec3Normalize(vec3Sub(b, a));
-    const reference =
-      Math.abs(direction.z) < 0.9
-        ? vec3(0, 0, 1)
-        : vec3(0, 1, 0);
+    const reference = Math.abs(direction.z) < 0.9 ? vec3(0, 0, 1) : vec3(0, 1, 0);
     const normal = vec3Normalize(vec3Cross(direction, reference));
 
     const plane: LwPolylinePlane = {
@@ -52,13 +49,20 @@ export function dxfEncLwPolyline(
   }
 
   const plane = findPlane(planePos, points);
-  if(!plane || !isCoplanar(points, plane)) {
+  if (!plane || !isCoplanar(points, plane)) {
     return undefined;
   }
   return encodeLwPolyline(points, plane, col, closed, handleRef, blockRefHandle);
 }
 
-function encodeLwPolyline(points: ReadonlyArray<Vec3>, plane: LwPolylinePlane, col: DxfColor, closed: boolean, handleRef: Handle, blockRefHandle?: string): string {
+function encodeLwPolyline(
+  points: ReadonlyArray<Vec3>,
+  plane: LwPolylinePlane,
+  col: DxfColor,
+  closed: boolean,
+  handleRef: Handle,
+  blockRefHandle?: string
+): string {
   let dxf = "";
   const planeElevation = vec3Dot(plane.pos, plane.normal);
 
@@ -73,7 +77,7 @@ function encodeLwPolyline(points: ReadonlyArray<Vec3>, plane: LwPolylinePlane, c
   dxf += `70\n${closed ? 1 : 0}\n`;
   dxf += `38\n${planeElevation}\n`;
 
-  for(const point of points) {
+  for (const point of points) {
     dxf += `10\n${vec3Dot(point, plane.xAxis)}\n`;
     dxf += `20\n${vec3Dot(point, plane.yAxis)}\n`;
   }
@@ -86,29 +90,29 @@ function encodeLwPolyline(points: ReadonlyArray<Vec3>, plane: LwPolylinePlane, c
 }
 
 function findPlane(planePos: Vec3, points: ReadonlyArray<Vec3>): LwPolylinePlane | undefined {
-  if(points.length < 3) {
+  if (points.length < 3) {
     return undefined;
   }
-  for(let i = 1; i < points.length; i++) {
+  for (let i = 1; i < points.length; i++) {
     const aRaw = points[i];
-    if(aRaw === undefined) {
+    if (aRaw === undefined) {
       continue;
     }
     const a = vec3Sub(aRaw, planePos);
-    for(let j = i + 1; j < points.length; j++) {
+    for (let j = i + 1; j < points.length; j++) {
       const bRaw = points[j];
-      if(bRaw === undefined) {
+      if (bRaw === undefined) {
         continue;
       }
       const b = vec3Sub(bRaw, planePos);
       const normal = vec3Cross(a, b);
-      if(vec3Length(normal) > EPSILON) {
+      if (vec3Length(normal) > EPSILON) {
         const normalizedNormal = vec3Normalize(normal);
         return {
           normal: normalizedNormal,
           pos: planePos,
           ...dxfOCSXYAxis(normalizedNormal),
-        }
+        };
       }
     }
   }
@@ -120,4 +124,4 @@ function isCoplanar(points: ReadonlyArray<Vec3>, plane: LwPolylinePlane): boolea
     const distance = vec3Dot(vec3Sub(p, plane.pos), plane.normal);
     return Math.abs(distance) < EPSILON;
   });
-}
+}

package/src/renderers/dxf/dxf-encoding/dxf-mtext.ts

@@ -11,9 +11,18 @@ export enum DxfMTextAttachment {
   BottomLeft = 7,
   BottomCenter = 8,
   BottomRight = 9,
-};
+}
 
-export function dxfEncMText(pos: Vec3, text: string, dir: Vec3, normal: Vec3, fontSize: number, handleRef: Handle, attachment: DxfMTextAttachment = DxfMTextAttachment.MiddleCenter, blockRefHandle?: string): string {
+export function dxfEncMText(
+  pos: Vec3,
+  text: string,
+  dir: Vec3,
+  normal: Vec3,
+  fontSize: number,
+  handleRef: Handle,
+  attachment: DxfMTextAttachment = DxfMTextAttachment.MiddleCenter,
+  blockRefHandle?: string
+): string {
   return `0
 MTEXT
 5
@@ -55,4 +64,4 @@ ${encodeDxfFormattedText(text)}
 
 export function encodeDxfFormattedText(text: string): string {
   return text.replace(/\r\n|\r|\n/g, "\\P");
-}
+}

package/src/renderers/dxf/dxf-encoding/dxf-polyline.ts

@@ -2,13 +2,7 @@ import type { Vec3 } from "../../../abstract-3d.js";
 import { type DxfColor, dxfColor } from "./dxf-color.js";
 import { DXF_MODEL_SPACE_HANDLE, dxfHandleNext, dxfRound, type Handle } from "./dxf-common.js";
 
-export function dxfEncPolyline(
-  points: ReadonlyArray<Vec3>,
-  col: DxfColor,
-  closed: boolean,
-  handleRef: Handle,
-  blockRefHandle?: string
-): string {
+export function dxfEncPolyline(points: ReadonlyArray<Vec3>, col: DxfColor, closed: boolean, handleRef: Handle, blockRefHandle?: string): string {
   if (points.length < 2) {
     return "";
   }
@@ -17,7 +11,7 @@ export function dxfEncPolyline(
   const seqEndHandle = dxfHandleNext(handleRef);
   const vertices = points
     .map((p) => {
-  return `  0
+      return `  0
 VERTEX
 5
 ${dxfHandleNext(handleRef)}
@@ -42,7 +36,6 @@ ${dxfRound(p.z)}
 32`;
     })
     .join("\n");
-  
 
   return `  0
 POLYLINE
@@ -79,4 +72,4 @@ AcDbEntity
 8
 0
 `;
-}
+}

package/src/renderers/dxf/dxf-encoding/dxf-solid.ts

@@ -2,15 +2,7 @@ import type { Vec3 } from "../../../abstract-3d.js";
 import { type DxfColor, dxfColor } from "./dxf-color.js";
 import { DXF_MODEL_SPACE_HANDLE, dxfHandleNext, dxfRound, type Handle } from "./dxf-common.js";
 
-export const dxfEncSolid = (
-  vec1: Vec3,
-  vec2: Vec3,
-  vec3: Vec3,
-  vec4: Vec3,
-  col: DxfColor,
-  handleRef: Handle,
-  blockRefHandle?: string
-): string => `  0
+export const dxfEncSolid = (vec1: Vec3, vec2: Vec3, vec3: Vec3, vec4: Vec3, col: DxfColor, handleRef: Handle, blockRefHandle?: string): string => `  0
 SOLID
 5
 ${dxfHandleNext(handleRef)}
@@ -45,4 +37,4 @@ ${dxfRound(vec4.x)}
 ${dxfRound(vec4.y)}
 33
 ${dxfRound(vec4.z)}
-`;
+`;

package/src/renderers/dxf/dxf-encoding/dxf-triangle.ts

@@ -4,20 +4,8 @@ import type { DxfColor } from "./dxf-color.js";
 import type { Handle } from "./dxf-common.js";
 import { dxfEncSolid } from "./dxf-solid.js";
 
-export const dxfEnc3DFaceTriangle = (
-  vec1: Vec3,
-  vec2: Vec3,
-  vec3: Vec3,
-  col: DxfColor,
-  handleRef: Handle,
-  blockRefHandle?: string
-): string => dxfEnc3DFace(vec1, vec2, vec3, vec3, col, handleRef, blockRefHandle);
+export const dxfEnc3DFaceTriangle = (vec1: Vec3, vec2: Vec3, vec3: Vec3, col: DxfColor, handleRef: Handle, blockRefHandle?: string): string =>
+  dxfEnc3DFace(vec1, vec2, vec3, vec3, col, handleRef, blockRefHandle);
 
-export const dxfEncSolidTriangle = (
-  vec1: Vec3,
-  vec2: Vec3,
-  vec3: Vec3,
-  col: DxfColor,
-  handleRef: Handle,
-  blockRefHandle?: string
-): string => dxfEncSolid(vec1, vec2, vec3, vec3, col, handleRef, blockRefHandle);
+export const dxfEncSolidTriangle = (vec1: Vec3, vec2: Vec3, vec3: Vec3, col: DxfColor, handleRef: Handle, blockRefHandle?: string): string =>
+  dxfEncSolid(vec1, vec2, vec3, vec3, col, handleRef, blockRefHandle);

package/src/renderers/dxf/dxf-geometries/dxf-box.ts

@@ -1,15 +1,6 @@
-import {
-  type Box,
-  type Material,
-  type Vec3,
-  vec3,
-  vec3RotCombine,
-  vec3Scale, 
-  vec3TransRot,
-  vec3Zero,
-} from "../../../abstract-3d.js";
-import type { Handle } from "../dxf-encoding/dxf-common.js";
+import { type Box, type Material, type Vec3, vec3, vec3RotCombine, vec3Scale, vec3TransRot, vec3Zero } from "../../../abstract-3d.js";
 import { dxfEnc3DFace } from "../dxf-encoding/dxf-3dface.js";
+import type { Handle } from "../dxf-encoding/dxf-common.js";
 
 export function dxfBox(b: Box, m: Material, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
   const pos = vec3TransRot(b.pos, parentPos, parentRot);

package/src/renderers/dxf/dxf-geometries/dxf-cone.ts

@@ -1,23 +1,8 @@
-import {
-  type Cone,
-  type Material,
-  type Vec3,
-  vec3,
-  vec3RotCombine,
-  vec3TransRot,
-  vec3Zero,
-} from "../../../abstract-3d.js";
+import { type Cone, type Material, type Vec3, vec3, vec3RotCombine, vec3TransRot, vec3Zero } from "../../../abstract-3d.js";
 import type { Handle } from "../dxf-encoding/dxf-common.js";
 import { dxfEnc3DFaceTriangle } from "../dxf-encoding/dxf-triangle.js";
 
-export function dxfCone(
-  c: Cone,
-  m: Material,
-  sides: number,
-  parentPos: Vec3,
-  parentRot: Vec3,
-  handleRef: Handle
-): string {
+export function dxfCone(c: Cone, m: Material, sides: number, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
   let dxfString = "";
   const pos = vec3TransRot(c.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, c.rot ?? vec3Zero);
@@ -37,8 +22,7 @@ export function dxfCone(
     if (i !== 0) {
       const prevBot = botVec3Array[i - 1]!;
       dxfString +=
-        dxfEnc3DFaceTriangle(botPos, prevBot, currBot, m.normal, handleRef) +
-        dxfEnc3DFaceTriangle(currBot, prevBot, topPos, m.normal, handleRef);
+        dxfEnc3DFaceTriangle(botPos, prevBot, currBot, m.normal, handleRef) + dxfEnc3DFaceTriangle(currBot, prevBot, topPos, m.normal, handleRef);
     }
     currentAngle += angleStep;
   }

package/src/renderers/dxf/dxf-geometries/dxf-cylinder.ts

@@ -1,27 +1,10 @@
-import {
-  type Cylinder,
-  type Material,
-  type Vec3,
-  equals,
-  vec3,
-  vec3RotCombine,
-  vec3Scale,
-  vec3TransRot,
-  vec3Zero,
-} from "../../../abstract-3d.js";
-import type { Handle } from "../dxf-encoding/dxf-common.js";
+import { type Cylinder, type Material, type Vec3, equals, vec3, vec3RotCombine, vec3Scale, vec3TransRot, vec3Zero } from "../../../abstract-3d.js";
 import { dxfEnc3DFace } from "../dxf-encoding/dxf-3dface.js";
+import type { Handle } from "../dxf-encoding/dxf-common.js";
 import { dxfEnc3DFaceTriangle } from "../dxf-encoding/dxf-triangle.js";
 import { dxfPlane } from "./dxf-plane.js";
 
-export function dxfCylinder(
-  c: Cylinder,
-  m: Material,
-  sides: number,
-  parentPos: Vec3,
-  parentRot: Vec3,
-  handleRef: Handle
-): string {
+export function dxfCylinder(c: Cylinder, m: Material, sides: number, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
   const pos = vec3TransRot(c.pos, parentPos, parentRot);
   const rot = vec3RotCombine(parentRot, c.rot ?? vec3Zero);
   const vec3tr = (x: number, y: number, z: number): Vec3 => vec3TransRot(vec3(x, y, z), pos, rot);
@@ -47,8 +30,7 @@ export function dxfCylinder(
     if (i !== 0 && prevBot && prevTop) {
       if (!c.open) {
         dxfString +=
-          dxfEnc3DFaceTriangle(botPos, prevBot, currBot, m.normal, handleRef) +
-          dxfEnc3DFaceTriangle(topPos, prevTop, currTop, m.normal, handleRef);
+          dxfEnc3DFaceTriangle(botPos, prevBot, currBot, m.normal, handleRef) + dxfEnc3DFaceTriangle(topPos, prevTop, currTop, m.normal, handleRef);
       }
       dxfString += dxfEnc3DFace(currBot, prevBot, prevTop, currTop, m.normal, handleRef);
     }

package/src/renderers/dxf/dxf-geometries/dxf-dimension.ts

@@ -2,8 +2,15 @@ import { type Dimension, dimensionIsOfTypeMesh, type Vec3, vec3Length, vec3Sub,
 import type { Handle } from "../dxf-encoding/dxf-common.js";
 import { type DxfDimensionDefinition, dxfEncDimension } from "../dxf-encoding/dxf-dimension.js";
 
-export function dxfDimension(dimension: Dimension, parentPos: Vec3, parentRot: Vec3, sceneRotation: Vec3, viewRotation: Vec3, handleRef: Handle): DxfDimensionDefinition {
-  if(dimensionIsOfTypeMesh(dimension)) {
+export function dxfDimension(
+  dimension: Dimension,
+  parentPos: Vec3,
+  parentRot: Vec3,
+  sceneRotation: Vec3,
+  viewRotation: Vec3,
+  handleRef: Handle
+): DxfDimensionDefinition {
+  if (dimensionIsOfTypeMesh(dimension)) {
     return {
       block: "",
       entity: "",
@@ -15,4 +22,4 @@ export function dxfDimension(dimension: Dimension, parentPos: Vec3, parentRot: V
   const lp = vec3TransRot(dimension.linePosition, parentPos, parentRot);
   const text = dimension.text ?? `${vec3Length(vec3Sub(me, ms))}`;
   return dxfEncDimension(ms, me, lp, text, 7, sceneRotation, viewRotation, dimension.views ?? ["front"], handleRef);
-}
+}

package/src/renderers/dxf/dxf-geometries/dxf-image.ts

@@ -1,19 +1,9 @@
+import type { AbstractImage, Component } from "abstract-image";
+import { type ImageMesh, type Vec3, vec2Scale, vec3, vec3Add, vec3Rot, vec3RotCombine, vec3TransRot, vec3Zero } from "../../../abstract-3d.js";
+import type { DxfDynamicColor } from "../dxf-encoding/dxf-color.js";
 import { DEFAULT_CIRCLE_SIDE_COUNT, type Handle } from "../dxf-encoding/dxf-common.js";
 import { dxfEncLine } from "../dxf-encoding/dxf-line.js";
 import { dxfEncLwPolyline } from "../dxf-encoding/dxf-lwpolyline.js";
-import type { AbstractImage, Component } from "abstract-image";
-import type { DxfDynamicColor } from "../dxf-encoding/dxf-color.js";
-import {
-  type ImageMesh,
-  type Vec3,
-  vec2Scale,
-  vec3,
-  vec3Add,
-  vec3Rot,
-  vec3RotCombine,
-  vec3TransRot,
-  vec3Zero,
-} from "../../../abstract-3d.js";
 
 export function dxfImage(i: ImageMesh, parentPos: Vec3, parentRot: Vec3, handleRef: Handle): string {
   const half = vec2Scale(i.size, 0.5);
@@ -35,29 +25,17 @@ export function dxfImage(i: ImageMesh, parentPos: Vec3, parentRot: Vec3, handleR
 }
 
 function abstractImageToDxf3D(image: AbstractImage, pos: Vec3, rot: Vec3, scale: Vec3, handleRef: Handle): string {
-  const strokeScale = Math.max(scale.x, scale.y, scale.z);
-  return image.components
-    .map((comp) => abstractImageComponentToDxf3D(comp, pos, rot, scale, strokeScale, handleRef))
-    .join("");
+  return image.components.map((comp) => abstractImageComponentToDxf3D(comp, pos, rot, scale, handleRef)).join("");
 }
 
-function abstractImageComponentToDxf3D(
-  comp: Component,
-  pos: Vec3,
-  rot: Vec3,
-  scale: Vec3,
-  strokeScale: number,
-  handleRef: Handle
-): string {
+function abstractImageComponentToDxf3D(comp: Component, pos: Vec3, rot: Vec3, scale: Vec3, handleRef: Handle): string {
   const vec3tr = (x: number, y: number): Vec3 => vec3TransRot(vec3(x * scale.x, y * scale.y, 0), pos, rot);
   const strokeColor: DxfDynamicColor = 7;
 
   let dxf = "";
   switch (comp.type) {
     case "group": {
-      dxf += comp.children
-        .map((child) => abstractImageComponentToDxf3D(child, pos, rot, scale, strokeScale, handleRef))
-        .join("");
+      dxf += comp.children.map((child) => abstractImageComponentToDxf3D(child, pos, rot, scale, handleRef)).join("");
       break;
     }
     case "line": {
@@ -89,11 +67,11 @@ function abstractImageComponentToDxf3D(
     }
     case "rectangle": {
       const points = [
-          //these points form a loop
-          vec3tr(comp.topLeft.x, comp.topLeft.y),
-          vec3tr(comp.bottomRight.x, comp.topLeft.y),
-          vec3tr(comp.bottomRight.x, comp.bottomRight.y),
-          vec3tr(comp.topLeft.x, comp.bottomRight.y),
+        //these points form a loop
+        vec3tr(comp.topLeft.x, comp.topLeft.y),
+        vec3tr(comp.bottomRight.x, comp.topLeft.y),
+        vec3tr(comp.bottomRight.x, comp.bottomRight.y),
+        vec3tr(comp.topLeft.x, comp.bottomRight.y),
       ];
       dxf += dxfEncLwPolyline(pos, points, strokeColor, true, handleRef) ?? "";
       break;