abstract-3d 2.6.19 → 2.7.0

package/src/renderers/dxf/dxf.ts

@@ -1,37 +1,42 @@
 import {
-  Scene,
-  View,
-  vec3RotCombine,
-  vec3Zero,
-  Group,
-  Vec3,
-  vec3TransRot,
-  group,
-  bounds3ToSize,
-  vec3,
-  rotationForCameraPos,
+  type Bounds3,
+  type Dimensions,
+  type Group,
+  type Scene,
+  type Vec3,
+  type View,
+  bounds3Center,
   bounds3FromPosAndSize,
-  Bounds3,
   bounds3Merge,
-  bounds3Center,
-  vec3Add,
-  sizeBoundsForCameraPos,
+  bounds3ToSize,
   boundsScene,
+  group,
+  rotationForCameraPos,
+  sizeBoundsForCameraPos,
+  vec3,
+  vec3Add,
+  vec3RotCombine,
   vec3Sub,
+  vec3TransRot,
+  vec3Zero
 } from "../../abstract-3d.js";
-import { DEFAULT_CIRCLE_SIDE_COUNT, dxf, dxfHandleCreate, DxfOrigin, Handle } from "./dxf-encoding.js";
+import { DEFAULT_CIRCLE_SIDE_COUNT, type DxfOrigin, type Handle, dxfBuild, dxfHandleInit } from "./dxf-encoding/dxf-common.js";
+import { type Optional, calculateVisibleViews } from "../../utils.js";
 import { dxfPlane } from "./dxf-geometries/dxf-plane.js";
 import { dxfBox } from "./dxf-geometries/dxf-box.js";
 import { dxfCylinder } from "./dxf-geometries/dxf-cylinder.js";
 import { dxfCone } from "./dxf-geometries/dxf-cone.js";
 import { dxfPolygon } from "./dxf-geometries/dxf-polygon.js";
-import { Optional } from "../../utils.js";
 import { dxfImage } from "./dxf-geometries/dxf-image.js";
+import { dxfText } from "./dxf-geometries/dxf-text.js";
+import { dxfEncLine } from "./dxf-encoding/dxf-line.js";
+import { dxfDimension } from "./dxf-geometries/dxf-dimension.js";
 
 export type DxfOptions = {
   readonly view: View;
   readonly origin: DxfOrigin;
   readonly cylinderSideCount: number;
+  readonly showDimensions: boolean;
 };
 
 export type DxfScenesOptionsBase = Omit<DxfOptions, "origin"> & { readonly origin: Exclude<DxfOrigin, "SameAsScene"> };
@@ -44,28 +49,30 @@ export type DxfScene = {
 
 export function renderScenes(scenes: ReadonlyArray<DxfScene>, baseOptions?: Optional<DxfScenesOptionsBase>): string {
   let allGroups = "";
+  let allDimensions = "";
   const allBounds = Array<Bounds3>();
-  const handle = dxfHandleCreate();
+  const handle = dxfHandleInit();
   const originOffset = originOffsetFromScenes(scenes, baseOptions?.origin ?? "Center");
   for (const view of scenes) {
-    const { groups, size, center } = renderInternal(
+    const { groups, dimensions, size, center } = renderInternal(
       view.scene,
       optionsDef({ ...baseOptions, ...view.options, origin: "Center" }),
       vec3Add(view.pos, originOffset),
       handle
     );
     allGroups += groups;
+    allDimensions += dimensions;
     allBounds.push(bounds3FromPosAndSize(center, size));
   }
   const bounds = bounds3Merge(...allBounds);
-  return dxf(allGroups, bounds, bounds3ToSize(bounds), bounds3Center(bounds));
+  return dxfBuild(allGroups, allDimensions, bounds, bounds3ToSize(bounds), bounds3Center(bounds));
 }
 
 export const render = (scene: Scene, options?: Optional<DxfOptions>): string => {
   const opts = optionsDef(options);
   const bounds = boundsScene(scene);
-  const { groups, size, center } = renderInternal(scene, opts, vec3Zero, dxfHandleCreate());
-  return dxf(groups, bounds, size, center);
+  const { groups, dimensions, size, center } = renderInternal(scene, opts, vec3Zero, dxfHandleInit());
+  return dxfBuild(groups, dimensions, bounds, size, center);
 };
 
 const renderInternal = (
@@ -73,7 +80,7 @@ const renderInternal = (
   options: DxfOptions,
   offset: Vec3,
   handleRef: Handle
-): { readonly groups: string; readonly size: Vec3; readonly center: Vec3 } => {
+): { readonly groups: string; readonly dimensions: string; readonly size: Vec3; readonly center: Vec3 } => {
   const unitRot = vec3RotCombine(rotationForCameraPos(options.view), scene.rotation_deprecated ?? vec3Zero);
   const unitCenter = scene.center_deprecated ?? vec3Zero;
   const [size] = sizeBoundsForCameraPos(scene.size_deprecated, unitCenter, unitRot);
@@ -81,8 +88,11 @@ const renderInternal = (
   const dxfOriginOffset = originOffsetFromBounds(bounds, options.origin);
   const pos =
     options.origin === "SameAsScene" ? vec3Zero : vec3NegateY(vec3Add(unitCenter, vec3Add(offset, dxfOriginOffset)));
+  const visibleViews = calculateVisibleViews(options.view, scene.rotation_deprecated);
+
   return {
     groups: scene.groups.reduce((a, c) => a + dxfGroup(c, pos, unitRot, options, handleRef), ""),
+    dimensions: dxfDimensions(scene.dimensions_deprecated, vec3Zero, unitRot, visibleViews, options, handleRef),
     size,
     center: pos,
   };
@@ -148,6 +158,16 @@ function dxfGroup(g: Group, parentPos: Vec3, parentRot: Vec3, options: DxfOption
         dxf += dxfImage(mesh.geometry, pos, rot, handleRef);
         break;
       }
+      case "Line": {
+        //const start = vec3TransRot(mesh.geometry.start, pos, rot);
+        //const end = vec3TransRot(mesh.geometry.end, pos, rot);
+        //dxf += dxfEncLine(start, end, 7, handleRef);
+        break;
+      }
+      case "Text": {
+        //dxf += dxfText(mesh.geometry, mesh.material, pos, rot, handleRef);
+        break;
+      }
       default:
         break;
     }
@@ -160,11 +180,19 @@ function dxfGroup(g: Group, parentPos: Vec3, parentRot: Vec3, options: DxfOption
   return dxf;
 }
 
+function dxfDimensions(d: Dimensions | undefined, parentPos: Vec3, parentRot: Vec3, _visibleViews: Record<string, boolean>, options: DxfOptions, handleRef: Handle): string {
+  if(!d || !options.showDimensions) {
+   return "";
+  }
+  return d.dimensions.map((d) => dxfDimension(d, parentPos, parentRot, handleRef)).join("");
+}
+
 function optionsDef(options: Optional<DxfOptions> | undefined): DxfOptions {
   return {
     view: options?.view ?? "front",
     origin: options?.origin ?? "BottomLeftFront",
-    cylinderSideCount: DEFAULT_CIRCLE_SIDE_COUNT,
+    cylinderSideCount: options?.cylinderSideCount ?? DEFAULT_CIRCLE_SIDE_COUNT,
+    showDimensions: options?.showDimensions ?? true,
   };
 }
 
@@ -178,22 +206,12 @@ export const renderOld = (scene: Scene, options?: Optional<DxfOptions>): string
     opts.origin === "Center" ? vec3Zero : vec3(Math.abs(bounds.min.x), Math.abs(bounds.min.y), -bounds.max.z),
     center
   );
-
-  const newBounds: Bounds3 = {
-    max: {
-      x: bounds.max.x + offset.x,
-      y: bounds.max.y + offset.y,
-      z: bounds.max.z + offset.z,
-    },
-    min: {
-      x: bounds.min.x + offset.x,
-      y: bounds.min.y + offset.y,
-      z: bounds.min.z + offset.z,
-    },
-  };
+  const dimensionsPos = vec3TransRot(center, offset, unitRot);
+  const visibleViews = calculateVisibleViews(opts.view, scene.rotation_deprecated);
 
   const bounds2 = bounds3FromPosAndSize(offset, scene.size_deprecated);
   const groupRoot = group([], offset, vec3Zero, scene.groups);
-  const handleRef = dxfHandleCreate();
-  return dxf(dxfGroup(groupRoot, center, unitRot, opts, handleRef), bounds2, scene.size_deprecated, center);
+  const handleRef = dxfHandleInit();
+  const dimensions = dxfDimensions(scene.dimensions_deprecated, dimensionsPos, unitRot, visibleViews, opts, handleRef);
+  return dxfBuild(dxfGroup(groupRoot, center, unitRot, opts, handleRef), dimensions, bounds2, scene.size_deprecated, center);
 };

package/src/renderers/dxf/index.ts

@@ -1,2 +1,2 @@
 export * from "./dxf.js";
-export type { DxfOrigin } from "./dxf-encoding.js";
+export type { DxfOrigin } from "./dxf-encoding/dxf-common.js";

package/src/renderers/react/react-dimension.tsx

@@ -1,7 +1,7 @@
 import { useFrame } from "@react-three/fiber";
 import React from "react";
 import type { Group } from "three";
-import { Dimensions, Vec3, Dimension, vec3TransRot, vec3Flip, Mesh } from "../../abstract-3d.js";
+import { Dimensions, Vec3, Dimension, vec3TransRot, vec3Flip, Mesh, dimensionConvertToTypeMesh, vec3Zero, Material } from "../../abstract-3d.js";
 import { ReactMaterial } from "./react-material.js";
 import { ReactMesh } from "./react-mesh.js";
 
@@ -26,7 +26,8 @@ export const ReactDimensions = React.memo(
         {dimensions?.dimensions.map((dimension, i) => (
           <ReactDimension
             key={i}
-            d={dimension}
+            dimension={dimension}
+            material={dimensions.material}
             visible={showDimensions}
             sceneRotation={sceneRotation}
             sceneCenter={sceneCenter}
@@ -40,18 +41,21 @@ export const ReactDimensions = React.memo(
 );
 
 export function ReactDimension({
-  d,
+  dimension,
+  material,
   visible,
   children,
   sceneRotation,
   sceneCenter,
 }: {
-  readonly d: Dimension;
+  readonly dimension: Dimension;
+  readonly material: Material;
   readonly visible: boolean;
   readonly children: React.JSX.Element;
   readonly sceneRotation: Vec3 | undefined;
   readonly sceneCenter: Vec3 | undefined;
 }): React.JSX.Element {
+  const d = dimensionConvertToTypeMesh(dimension, sceneRotation ?? vec3Zero, material);
   const ref = React.useRef<Group>(undefined!);
   useFrame(({ camera }) => {
     ref.current.visible =

package/src/renderers/step/step-encoding.ts

@@ -2,6 +2,8 @@ import { Vec2, Vec3 } from "../../abstract-3d.js";
 
 export type MutableStep = { refs: Map<string, number>; step: string; geoContext3d: number; };
 
+export const STEP_NUMBER_EPSILON: number = 1e-5;
+
 const mutate = (step: string, m: MutableStep): number => {
   const prevRef = m.refs.get(step);
   if (prevRef !== undefined) {
@@ -15,6 +17,20 @@ const mutate = (step: string, m: MutableStep): number => {
   }
 };
 
+const stepNumber = (num: number): number => {
+  const absNum = Math.abs(num);
+  if(absNum < STEP_NUMBER_EPSILON) {
+    return 0.0;
+  }
+
+  const roundNum = Math.round(num);
+  if(Math.abs(absNum - Math.abs(roundNum)) < STEP_NUMBER_EPSILON) {
+    return roundNum;
+  }
+
+  return num;
+}
+
 export const HEADER = (date: string): string =>
   `ISO-10303-21;
 HEADER;
@@ -32,16 +48,16 @@ END-ISO-10303-21;`;
 
 export const CARTESIAN_POINT = (p: Vec3 | Vec2, m: MutableStep): number =>
   mutate(
-    `CARTESIAN_POINT('',(${p.x},${p.y}${
-      (p as Vec3)?.z !== undefined ? `,${(p as Vec3).z}` : ""
+    `CARTESIAN_POINT('',(${stepNumber(p.x)},${stepNumber(p.y)}${
+      (p as Vec3)?.z !== undefined ? `,${stepNumber((p as Vec3).z)}` : ""
     }))`,
     m
   );
 
 export const DIRECTION = (d: Vec3 | Vec2, m: MutableStep): number =>
   mutate(
-    `DIRECTION('',(${d.x},${d.y}${
-      (d as Vec3)?.z !== undefined ? `,${(d as Vec3).z}` : ""
+    `DIRECTION('',(${stepNumber(d.x)},${stepNumber(d.y)}${
+      (d as Vec3)?.z !== undefined ? `,${stepNumber((d as Vec3).z)}` : ""
     }))`,
     m
   );
@@ -96,7 +112,10 @@ export const PCURVE = (
 ): number => mutate(`PCURVE('',#${CYLINDRICAL_SURFACE_or_PLANE},#${DEFINITIONAL_REPRESENTATION})`, m);
 
 export const CYLINDRICAL_SURFACE = (AXIS2_PLACEMENT_3D: number, radius: number, m: MutableStep): number =>
-  mutate(`CYLINDRICAL_SURFACE('',#${AXIS2_PLACEMENT_3D},${radius})`, m);
+  mutate(`CYLINDRICAL_SURFACE('',#${AXIS2_PLACEMENT_3D},${stepNumber(radius)})`, m);
+
+export const CONICAL_SURFACE = (AXIS2_PLACEMENT_3D: number, radius: number, semiAngle: number, m: MutableStep): number =>
+  mutate(`CONICAL_SURFACE('',#${AXIS2_PLACEMENT_3D},${stepNumber(radius)},${stepNumber(semiAngle)})`, m);
 
 export const DEFINITIONAL_REPRESENTATION = (LINEorCircle: number, m: MutableStep): number =>
   mutate(`DEFINITIONAL_REPRESENTATION('',(#${LINEorCircle}),#7)`, m);

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

@@ -11,6 +11,7 @@ import {
   vec3Sub,
   vec3Add,
   vec3Rot,
+  vec3Length,
 } from "../../../abstract-3d.js";
 import { parseRgb } from "../../../utils.js";
 import {
@@ -44,6 +45,7 @@ import {
   PRODUCT_DEFINITION_FORMATION,
   PRODUCT_DEFINITION_SHAPE,
   SHAPE_DEFINITION_REPRESENTATION,
+  STEP_NUMBER_EPSILON,
   STYLED_ITEM,
   SURFACE_SIDE_STYLE,
   SURFACE_STYLE_FILL_AREA,
@@ -60,6 +62,10 @@ export function stepBox(b: Box, mat: Material, parentPos: Vec3, parentRot: Vec3,
   const color = parseRgb(mat.normal);
   const rotate = (v: Vec3): Vec3 => vec3Rot(v, vec3Zero, rotation);
 
+  if(size.x === 0.0 || size.y === 0.0 || size.z === 0.0) {
+    return;
+  }
+
   const corners = [
     vec3(0, 0, 0),
     vec3(0, 0, size.z),