npm - @treasuryspatial/rhino-bridge - Versions diffs - 0.1.4 → 0.1.6 - Mend

@treasuryspatial/rhino-bridge 0.1.4 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import * as THREE from "three";
-export type RhinoBridgeOptions = {
+export type GeometryBridgeOptions = {
     wasmPath?: string;
     wasmUrl?: string;
     rotateToYUp?: boolean;
@@ -12,6 +12,15 @@ export type RhinoBridgeOptions = {
     packetKey?: string;
     layerKey?: string;
     materialKey?: string;
+    curveMode?: "auto" | "always" | "never";
+    zFightMitigation?: boolean | ZFightMitigationOptions;
+};
+export type ZFightMitigationOptions = {
+    enabled?: boolean;
+    dedupe?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    polygonOffsetUnits?: number;
 };
 export type LayeredGeometryOptions = {
     mapLayerToId?: (layerName: string, attributes: any) => string | null;
@@ -23,18 +32,39 @@ export type LayeredGeometryOptions = {
     layerKey?: string;
     materialKey?: string;
 };
-export declare function threeGroupFrom3dm(base64: string, options?: RhinoBridgeOptions): Promise<THREE.Group>;
-export type Rhino3dmInspection = {
+export declare const sanitizeObject3d: (root?: THREE.Object3D | null) => void;
+export declare const dedupeMeshesInGroup: (group?: THREE.Group | null) => void;
+export declare const applyPolygonOffsetToGroup: (group?: THREE.Group | null, factor?: number, units?: number) => void;
+export declare const applyZFightMitigation: (group?: THREE.Group | null, options?: boolean | ZFightMitigationOptions) => void;
+export declare function threeGroupFrom3dm(base64: string, options?: GeometryBridgeOptions): Promise<THREE.Group>;
+export type Geometry3dmInspection = {
     ok: boolean;
     meshCount: number;
     brepCount: number;
     extrusionCount: number;
     otherCount: number;
 };
-export declare function inspect3dmArrayBuffer(buffer: ArrayBuffer | Uint8Array): Promise<Rhino3dmInspection>;
-export declare function inspect3dmBase64(base64: string): Promise<Rhino3dmInspection>;
+export type GrasshopperTo3dmStats = {
+    decodedObjects: number;
+    meshesAdded: number;
+    brepsMeshed: number;
+    brepsSkipped: number;
+    unsupported: Record<string, number>;
+    errors: string[];
+};
+export declare function grasshopperResultTo3dmBase64(result: {
+    values?: any[];
+} | null | undefined): Promise<{
+    geometry3dm: string;
+    stats: GrasshopperTo3dmStats;
+}>;
+export declare function inspect3dmArrayBuffer(buffer: ArrayBuffer | Uint8Array): Promise<Geometry3dmInspection>;
+export declare function inspect3dmBase64(base64: string): Promise<Geometry3dmInspection>;
 export declare function loadLayeredGeometry(geometry3dm: string, options?: LayeredGeometryOptions): Promise<Record<string, THREE.Group>>;
-export declare function extractBrepsByRole(base64: string, options?: RhinoBridgeOptions): Promise<Record<string, string>>;
-declare function convertGeometryToThree(geometry: any): THREE.Object3D | null;
+export declare function extractBrepsByRole(base64: string, options?: GeometryBridgeOptions): Promise<Record<string, string>>;
+type ConvertGeometryOptions = {
+    allowCurves?: boolean;
+};
+declare function convertGeometryToThree(geometry: any, options?: ConvertGeometryOptions): THREE.Object3D | null;
 export { convertGeometryToThree };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA0B/B,MAAM,MAAM,~~kBAAkB~~,GAAG;~~IAC/B~~,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;~~CACtB~~,CAAC;~~AA2FF~~,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC;IACrE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAUF,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,~~kBAAkB~~,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,~~CAqD1G~~;AAED,MAAM,MAAM,~~kBAAkB~~,GAAG;~~IAC/B~~,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;~~AAsCF~~,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,~~kBAAkB~~,CAAC,~~CAQzG~~;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,~~kBAAkB~~,CAAC,~~CAGlF~~;AAED,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAyErI;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,~~kBAAkB~~,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,~~CAgDtH~~;AAED,iBAAS,sBAAsB,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,QAAQ,GAAG,IAAI,~~CAkBpE~~;AAyGD,OAAO,EAAE,sBAAsB,EAAE,CAAC"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js CHANGED Viewed

@@ -1,53 +1,73 @@
 import * as THREE from "three";
 import rhino3dm from "rhino3dm";
-const DEFAULT_BROWSER_WASM_PATH = "/rhino3dm.wasm";
+const DEFAULT_BROWSER_WASM_PATH = "/geometry.wasm";
+const DEFAULT_BROWSER_WASM_FILENAME = DEFAULT_BROWSER_WASM_PATH.split("/").pop() ?? "geometry.wasm";
 const DEFAULT_ROLE_KEY = "b2:role";
 const DEFAULT_GEOMETRY_ROLE = "geometry";
 const DEFAULT_ID_KEY = "b2:id";
 const trimTrailingSlashes = (value) => value.replace(/\/+$/, "");
 const trimLeadingSlashes = (value) => value.replace(/^\/+/, "");
 const resolveBrowserWasmUrl = (path, override) => {
-    const envBase = override?.trim() || process.env.NEXT_PUBLIC_RHINO3DM_WASM_URL?.trim() || process.env.RHINO3DM_WASM_URL?.trim();
-    const normalizedPath = trimLeadingSlashes(path);
+    const envBase = override?.trim() || process.env.NEXT_PUBLIC_GEOMETRY_WASM_URL?.trim() || process.env.GEOMETRY_WASM_URL?.trim();
     if (envBase && envBase.length > 0) {
         if (envBase.endsWith(".wasm"))
             return envBase;
         const base = trimTrailingSlashes(envBase);
-        return `${base}/${normalizedPath}`;
+        return `${base}/${DEFAULT_BROWSER_WASM_FILENAME}`;
     }
-    return `${DEFAULT_BROWSER_WASM_PATH.replace(/[^/]+$/, "")}${normalizedPath}`;
+    return DEFAULT_BROWSER_WASM_PATH;
 };
-let rhinoModulePromise = null;
-async function getRhinoModule(options) {
-    if (!rhinoModulePromise) {
+let geometryModulePromise = null;
+const DEFAULT_Z_FIGHT_OPTIONS = {
+    enabled: true,
+    dedupe: true,
+    polygonOffset: true,
+    polygonOffsetFactor: 0.5,
+    polygonOffsetUnits: 0.5,
+};
+const resolveZFightOptions = (input) => {
+    if (input === false || input === undefined || input === null)
+        return null;
+    if (input === true)
+        return { ...DEFAULT_Z_FIGHT_OPTIONS };
+    if (input.enabled === false)
+        return null;
+    return {
+        ...DEFAULT_Z_FIGHT_OPTIONS,
+        ...input,
+        enabled: input.enabled ?? true,
+    };
+};
+async function getGeometryModule(options) {
+    if (!geometryModulePromise) {
         if (typeof window === "undefined") {
             const pathModule = await import("path");
             const fs = await import("fs");
             const wasmPath = options?.wasmPath
                 ? pathModule.resolve(process.cwd(), options.wasmPath)
-                : process.env.RHINO3DM_WASM_PATH
-                    ? pathModule.resolve(process.cwd(), process.env.RHINO3DM_WASM_PATH)
-                    : pathModule.resolve(process.cwd(), "public", "rhino3dm.wasm");
+                : process.env.GEOMETRY_WASM_PATH
+                    ? pathModule.resolve(process.cwd(), process.env.GEOMETRY_WASM_PATH)
+                    : pathModule.resolve(process.cwd(), "public", "geometry.wasm");
             let wasmBinary = null;
             try {
                 const buffer = fs.readFileSync(wasmPath);
                 wasmBinary = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
             }
             catch (error) {
-                console.error("[rhino3dm] Failed to read WASM binary from", wasmPath, error);
+                console.error("[geometry] Failed to read WASM binary from", wasmPath, error);
             }
-            rhinoModulePromise = rhino3dm({
+            geometryModulePromise = rhino3dm({
                 wasmBinary: wasmBinary ?? undefined,
                 locateFile: (path) => (wasmBinary ? wasmPath : resolveBrowserWasmUrl(path, options?.wasmUrl)),
             });
         }
         else {
-            rhinoModulePromise = rhino3dm({
+            geometryModulePromise = rhino3dm({
                 locateFile: (path) => resolveBrowserWasmUrl(path, options?.wasmUrl),
             });
         }
     }
-    return rhinoModulePromise;
+    return geometryModulePromise;
 }
 const base64ToUint8Array = (base64) => {
     const normalized = base64.replace(/\s/g, "");
@@ -96,7 +116,7 @@ const getUserString = (attributes, key) => {
         }
     }
     catch (error) {
-        console.warn("[rhino3dm] Unable to read user string", key, error);
+        console.warn("[geometry] Unable to read user string", key, error);
     }
     return null;
 };
@@ -108,13 +128,101 @@ const resolveUserString = (attributes, keys) => {
     }
     return null;
 };
+export const sanitizeObject3d = (root) => {
+    if (!root || !Array.isArray(root.children))
+        return;
+    const children = root.children;
+    for (let i = children.length - 1; i >= 0; i -= 1) {
+        const child = children[i];
+        if (!child || !child.isObject3D) {
+            children.splice(i, 1);
+            continue;
+        }
+        sanitizeObject3d(child);
+    }
+};
+const buildGeometrySignature = (geometry) => {
+    const position = geometry.getAttribute("position");
+    if (!position || position.count === 0)
+        return null;
+    const index = geometry.getIndex();
+    const box = new THREE.Box3().setFromBufferAttribute(position);
+    const sampleCount = Math.min(position.count, 30);
+    const indexCount = index ? Math.min(index.count, 30) : 0;
+    let signature = `${position.count}|${index?.count ?? 0}|`;
+    signature += `${box.min.x.toFixed(4)},${box.min.y.toFixed(4)},${box.min.z.toFixed(4)}|`;
+    signature += `${box.max.x.toFixed(4)},${box.max.y.toFixed(4)},${box.max.z.toFixed(4)}`;
+    for (let i = 0; i < sampleCount; i += 1) {
+        signature += `|${position.getX(i).toFixed(4)},${position.getY(i).toFixed(4)},${position.getZ(i).toFixed(4)}`;
+    }
+    for (let i = 0; i < indexCount; i += 1) {
+        signature += `:${index?.getX(i) ?? 0}`;
+    }
+    return signature;
+};
+export const dedupeMeshesInGroup = (group) => {
+    if (!group || typeof group.traverse !== "function")
+        return;
+    sanitizeObject3d(group);
+    const seen = new Map();
+    const duplicates = [];
+    group.traverse((object) => {
+        if (!(object instanceof THREE.Mesh))
+            return;
+        const geometry = object.geometry;
+        if (!(geometry instanceof THREE.BufferGeometry))
+            return;
+        const signature = buildGeometrySignature(geometry);
+        if (!signature)
+            return;
+        const existing = seen.get(signature);
+        if (existing) {
+            duplicates.push(object);
+        }
+        else {
+            seen.set(signature, object);
+        }
+    });
+    if (duplicates.length > 0) {
+        duplicates.forEach((object) => {
+            object.parent?.remove(object);
+        });
+    }
+};
+export const applyPolygonOffsetToGroup = (group, factor = DEFAULT_Z_FIGHT_OPTIONS.polygonOffsetFactor, units = DEFAULT_Z_FIGHT_OPTIONS.polygonOffsetUnits) => {
+    if (!group || typeof group.traverse !== "function")
+        return;
+    group.traverse((object) => {
+        if (!(object instanceof THREE.Mesh))
+            return;
+        const materials = Array.isArray(object.material) ? object.material : [object.material];
+        materials.forEach((material) => {
+            if (!material)
+                return;
+            material.polygonOffset = true;
+            material.polygonOffsetFactor = factor;
+            material.polygonOffsetUnits = units;
+        });
+    });
+};
+export const applyZFightMitigation = (group, options) => {
+    const resolved = resolveZFightOptions(options);
+    if (!resolved || !group)
+        return;
+    if (resolved.dedupe) {
+        dedupeMeshesInGroup(group);
+    }
+    if (resolved.polygonOffset) {
+        applyPolygonOffsetToGroup(group, resolved.polygonOffsetFactor, resolved.polygonOffsetUnits);
+    }
+};
 export async function threeGroupFrom3dm(base64, options) {
-    const rhino = await getRhinoModule(options);
+    const rhino = await getGeometryModule(options);
     const bytes = base64ToUint8Array(base64);
     const doc = rhino.File3dm.fromByteArray(bytes);
     const group = new THREE.Group();
     if (!doc) {
-        console.error("[rhino3dm] Failed to parse 3DM file from bytes");
+        console.error("[geometry] Failed to parse 3DM file from bytes");
         return group;
     }
     const rotation = options?.rotateToYUp === false ? null : new THREE.Matrix4().makeRotationX(-Math.PI / 2);
@@ -127,6 +235,23 @@ export async function threeGroupFrom3dm(base64, options) {
     const materialKey = options?.materialKey ?? "b2:material";
     const objects = doc.objects();
     const objectCount = objects.count ?? 0;
+    const curveMode = options?.curveMode ?? "auto";
+    let allowCurves = curveMode === "always";
+    if (curveMode === "auto") {
+        allowCurves = true;
+        for (let i = 0; i < objectCount; i += 1) {
+            const obj = objects.get(i);
+            const geom = obj?.geometry?.();
+            const typeName = geom?.constructor?.name;
+            if (typeName === "Mesh") {
+                allowCurves = false;
+                break;
+            }
+        }
+    }
+    else if (curveMode === "never") {
+        allowCurves = false;
+    }
     for (let i = 0; i < objectCount; i += 1) {
         const obj = objects.get(i);
         const attributes = typeof obj?.attributes === "function" ? obj.attributes() : null;
@@ -135,7 +260,7 @@ export async function threeGroupFrom3dm(base64, options) {
             continue;
         }
         const geom = obj?.geometry?.();
-        const threeObject = convertGeometryToThree(geom);
+        const threeObject = convertGeometryToThree(geom, { allowCurves });
         if (threeObject) {
             if (rotation) {
                 threeObject.applyMatrix4(rotation);
@@ -154,9 +279,130 @@ export async function threeGroupFrom3dm(base64, options) {
             group.add(threeObject);
         }
     }
+    sanitizeObject3d(group);
+    if (options?.zFightMitigation) {
+        applyZFightMitigation(group, options.zFightMitigation);
+    }
     return group;
 }
-const countRhinoObjects = (doc) => {
+export async function grasshopperResultTo3dmBase64(result) {
+    const rhino = await getGeometryModule();
+    const stats = {
+        decodedObjects: 0,
+        meshesAdded: 0,
+        brepsMeshed: 0,
+        brepsSkipped: 0,
+        unsupported: {},
+        errors: [],
+    };
+    const doc = new rhino.File3dm();
+    const values = Array.isArray(result?.values) ? result?.values ?? [] : [];
+    if (!values.length) {
+        return { geometry3dm: "", stats };
+    }
+    const addObject = (geometry, name) => {
+        try {
+            if (name && rhino.ObjectAttributes) {
+                const attributes = new rhino.ObjectAttributes();
+                attributes.name = name;
+                doc.objects().add(geometry, attributes);
+            }
+            else {
+                doc.objects().add(geometry, null);
+            }
+        }
+        catch (e) {
+            stats.errors.push(`Failed to add object to 3dm: ${e?.message ?? String(e)}`);
+        }
+    };
+    const tryMeshBrep = (brep) => {
+        try {
+            const createFromBrep = rhino.Mesh?.createFromBrep;
+            if (typeof createFromBrep !== "function")
+                return null;
+            const mp = rhino.MeshingParameters?.default ?? null;
+            try {
+                const meshes = mp ? createFromBrep(brep, mp) : createFromBrep(brep);
+                return Array.isArray(meshes) ? meshes.filter(Boolean) : null;
+            }
+            catch {
+                const meshes = createFromBrep(brep);
+                return Array.isArray(meshes) ? meshes.filter(Boolean) : null;
+            }
+        }
+        catch (e) {
+            stats.errors.push(`Failed to mesh Brep: ${e?.message ?? String(e)}`);
+            return null;
+        }
+    };
+    for (const output of values) {
+        const paramName = String(output?.ParamName ?? "output");
+        const tree = output?.InnerTree ?? {};
+        for (const path of Object.keys(tree)) {
+            const items = Array.isArray(tree[path]) ? tree[path] : [];
+            for (let idx = 0; idx < items.length; idx += 1) {
+                const item = items[idx];
+                const itemType = String(item?.type ?? "");
+                const rawData = item?.data;
+                if (!itemType.startsWith("Rhino.Geometry"))
+                    continue;
+                let json = null;
+                try {
+                    if (typeof rawData === "string") {
+                        json = JSON.parse(rawData);
+                    }
+                    else if (typeof rawData === "object") {
+                        json = rawData;
+                    }
+                }
+                catch (e) {
+                    stats.errors.push(`Failed to parse geometry JSON (${paramName} ${path} ${idx}): ${e?.message ?? String(e)}`);
+                    continue;
+                }
+                if (!json)
+                    continue;
+                let decoded = null;
+                try {
+                    decoded = rhino.CommonObject.decode(json);
+                }
+                catch (e) {
+                    stats.errors.push(`Failed to decode geometry (${paramName} ${path} ${idx}): ${e?.message ?? String(e)}`);
+                    continue;
+                }
+                if (!decoded)
+                    continue;
+                stats.decodedObjects += 1;
+                const typeName = decoded?.constructor?.name ?? "unknown";
+                if (typeName === "Mesh") {
+                    addObject(decoded, `${paramName}[${path}][${idx}]`);
+                    stats.meshesAdded += 1;
+                    continue;
+                }
+                if (typeName === "Brep") {
+                    const meshes = tryMeshBrep(decoded);
+                    if (meshes?.length) {
+                        stats.brepsMeshed += 1;
+                        for (let mi = 0; mi < meshes.length; mi += 1) {
+                            addObject(meshes[mi], `${paramName}[${path}][${idx}]::mesh${mi}`);
+                            stats.meshesAdded += 1;
+                        }
+                    }
+                    else {
+                        addObject(decoded, `${paramName}[${path}][${idx}]::brep`);
+                        stats.brepsSkipped += 1;
+                    }
+                    continue;
+                }
+                stats.unsupported[typeName] = (stats.unsupported[typeName] ?? 0) + 1;
+                addObject(decoded, `${paramName}[${path}][${idx}]::${typeName}`);
+            }
+        }
+    }
+    const bytes = doc.toByteArray();
+    const geometry3dm = bytes?.length ? uint8ArrayToBase64(new Uint8Array(bytes)) : "";
+    return { geometry3dm, stats };
+}
+const countGeometryObjects = (doc) => {
     const objects = doc?.objects?.();
     const total = objects?.count ?? 0;
     let meshCount = 0;
@@ -190,25 +436,25 @@ const countRhinoObjects = (doc) => {
     };
 };
 export async function inspect3dmArrayBuffer(buffer) {
-    const rhino = await getRhinoModule();
+    const rhino = await getGeometryModule();
     const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
     const doc = rhino.File3dm.fromByteArray(bytes);
     if (!doc) {
         return { ok: false, meshCount: 0, brepCount: 0, extrusionCount: 0, otherCount: 0 };
     }
-    return countRhinoObjects(doc);
+    return countGeometryObjects(doc);
 }
 export async function inspect3dmBase64(base64) {
     const bytes = base64ToUint8Array(base64);
     return inspect3dmArrayBuffer(bytes);
 }
 export async function loadLayeredGeometry(geometry3dm, options) {
-    const rhino = await getRhinoModule();
+    const rhino = await getGeometryModule();
     const bytes = base64ToUint8Array(geometry3dm);
     const doc = rhino.File3dm.fromByteArray(bytes);
     const groups = {};
     if (!doc) {
-        console.error("[rhino3dm] Failed to parse 3DM file");
+        console.error("[geometry] Failed to parse 3DM file");
         return groups;
     }
     const layerTable = doc.layers?.();
@@ -268,12 +514,12 @@ export async function loadLayeredGeometry(geometry3dm, options) {
     return groups;
 }
 export async function extractBrepsByRole(base64, options) {
-    const rhino = await getRhinoModule(options);
+    const rhino = await getGeometryModule(options);
     const bytes = base64ToUint8Array(base64);
     const doc = rhino.File3dm.fromByteArray(bytes);
     const breps = {};
     if (!doc) {
-        console.error("[rhino3dm] Failed to parse 3DM file for Brep extraction");
+        console.error("[geometry] Failed to parse 3DM file for Brep extraction");
         return breps;
     }
     const roleKeys = options?.roleKeys ?? [];
@@ -311,7 +557,134 @@ export async function extractBrepsByRole(base64, options) {
     }
     return breps;
 }
-function convertGeometryToThree(geometry) {
+const extractPolylinePoints = (polyline) => {
+    if (!polyline)
+        return null;
+    const points = [];
+    const count = typeof polyline.count === "number" ? polyline.count : typeof polyline.pointCount === "number" ? polyline.pointCount : 0;
+    const getter = typeof polyline.get === "function" ? polyline.get.bind(polyline) : null;
+    const pointGetter = typeof polyline.point === "function" ? polyline.point.bind(polyline) : null;
+    for (let i = 0; i < count; i += 1) {
+        const raw = getter ? getter(i) : pointGetter ? pointGetter(i) : null;
+        if (Array.isArray(raw) && raw.length >= 3) {
+            const x = Number(raw[0]);
+            const y = Number(raw[1]);
+            const z = Number(raw[2]);
+            if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)) {
+                points.push([x, y, z]);
+            }
+        }
+    }
+    return points.length > 1 ? points : null;
+};
+const extractCurvePoints = (curve) => {
+    if (!curve)
+        return null;
+    try {
+        if (typeof curve.ToPolyline === "function") {
+            const polyline = curve.ToPolyline();
+            const points = extractPolylinePoints(polyline);
+            if (points)
+                return points;
+        }
+        if (typeof curve.toPolyline === "function") {
+            const polyline = curve.toPolyline();
+            const points = extractPolylinePoints(polyline);
+            if (points)
+                return points;
+        }
+        if (typeof curve.tryGetPolyline === "function") {
+            const result = curve.tryGetPolyline();
+            const success = Array.isArray(result) ? result[0] : result?.[0];
+            const polyline = Array.isArray(result) ? result[1] : result?.[1];
+            if (success && polyline) {
+                const points = extractPolylinePoints(polyline);
+                if (points)
+                    return points;
+            }
+        }
+    }
+    catch {
+        // fall through to sampling
+    }
+    if (typeof curve.pointAt === "function" && Array.isArray(curve.domain) && curve.domain.length >= 2) {
+        const t0 = Number(curve.domain[0]);
+        const t1 = Number(curve.domain[1]);
+        if (Number.isFinite(t0) && Number.isFinite(t1) && t0 !== t1) {
+            const segments = 64;
+            const points = [];
+            for (let i = 0; i <= segments; i += 1) {
+                const t = t0 + ((t1 - t0) * i) / segments;
+                const raw = curve.pointAt(t);
+                if (Array.isArray(raw) && raw.length >= 3) {
+                    const x = Number(raw[0]);
+                    const y = Number(raw[1]);
+                    const z = Number(raw[2]);
+                    if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)) {
+                        points.push([x, y, z]);
+                    }
+                }
+            }
+            if (points.length > 1) {
+                if (curve.isClosed && points.length > 2) {
+                    const first = points[0];
+                    const last = points[points.length - 1];
+                    if (first[0] !== last[0] || first[1] !== last[1] || first[2] !== last[2]) {
+                        points.push([...first]);
+                    }
+                }
+                return points;
+            }
+        }
+    }
+    return null;
+};
+const pointsToLine = (points) => {
+    if (!points || points.length < 2)
+        return null;
+    const positions = new Float32Array(points.length * 3);
+    points.forEach((point, index) => {
+        positions[index * 3 + 0] = point[0];
+        positions[index * 3 + 1] = point[1];
+        positions[index * 3 + 2] = point[2];
+    });
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    const material = new THREE.LineBasicMaterial({
+        color: 0x1f2937,
+        transparent: true,
+        opacity: 1,
+        toneMapped: false,
+        depthTest: false,
+        depthWrite: false,
+    });
+    const line = new THREE.Line(geometry, material);
+    line.renderOrder = 10;
+    return line;
+};
+const pointsToPoints = (points) => {
+    if (!points || points.length === 0)
+        return null;
+    const positions = new Float32Array(points.length * 3);
+    points.forEach((point, index) => {
+        positions[index * 3 + 0] = point[0];
+        positions[index * 3 + 1] = point[1];
+        positions[index * 3 + 2] = point[2];
+    });
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    const material = new THREE.PointsMaterial({
+        color: 0x1f2937,
+        size: 3,
+        sizeAttenuation: false,
+        depthTest: false,
+        depthWrite: false,
+    });
+    const pointsObject = new THREE.Points(geometry, material);
+    pointsObject.renderOrder = 10;
+    return pointsObject;
+};
+function convertGeometryToThree(geometry, options) {
     if (!geometry) {
         return null;
     }
@@ -319,24 +692,44 @@ function convertGeometryToThree(geometry) {
     if (typeName === "Mesh") {
         return meshToThree(geometry);
     }
+    if (options?.allowCurves) {
+        if (typeName === "Point") {
+            const location = geometry.location;
+            if (Array.isArray(location) && location.length >= 3) {
+                return pointsToPoints([[Number(location[0]), Number(location[1]), Number(location[2])]]);
+            }
+        }
+        if (typeName === "PointCloud" && typeof geometry.getPoints === "function") {
+            const points = geometry.getPoints();
+            if (Array.isArray(points) && points.length > 0) {
+                return pointsToPoints(points);
+            }
+        }
+        if (typeName === "Curve" || typeName === "PolylineCurve" || typeName === "LineCurve" || typeName === "ArcCurve" || typeName === "PolyCurve" || typeName === "NurbsCurve") {
+            const points = extractCurvePoints(geometry);
+            if (points) {
+                return pointsToLine(points);
+            }
+        }
+    }
     if (typeName === "Brep" || typeName === "Extrusion") {
-        console.warn("[rhino3dm] Non-meshed geometry received. Ensure server-side meshing before serialization.");
+        console.warn("[geometry] Non-meshed geometry received. Ensure server-side meshing before serialization.");
         return null;
     }
-    console.warn(`[rhino3dm] Unsupported geometry type: ${typeName}`);
+    console.warn(`[geometry] Unsupported geometry type: ${typeName}`);
     return null;
 }
 function meshToThree(mesh) {
     const vertices = mesh.vertices?.();
     const faces = mesh.faces?.();
     if (!vertices || !faces) {
-        console.warn("[rhino3dm] Mesh missing vertices or faces");
+        console.warn("[geometry] Mesh missing vertices or faces");
         return null;
     }
     const vertexCount = vertices.count ?? 0;
     const faceCount = faces.count ?? 0;
     if (vertexCount === 0 || faceCount === 0) {
-        console.warn("[rhino3dm] Mesh received with no vertices or faces; skipping");
+        console.warn("[geometry] Mesh received with no vertices or faces; skipping");
         return null;
     }
     const geometry = new THREE.BufferGeometry();
@@ -372,7 +765,7 @@ function meshToThree(mesh) {
         };
         for (let i = 0; i < vertexCount; i += 1) {
             if (!writeVertex(i, vertices.get(i))) {
-                console.warn("[rhino3dm] Invalid vertex encountered; skipping mesh");
+                console.warn("[geometry] Invalid vertex encountered; skipping mesh");
                 return null;
             }
         }
@@ -380,7 +773,7 @@ function meshToThree(mesh) {
     else {
         for (let i = 0; i < positionArray.length; i += 1) {
             if (!Number.isFinite(positionArray[i])) {
-                console.warn("[rhino3dm] Mesh float array contained non-finite values; skipping mesh");
+                console.warn("[geometry] Mesh float array contained non-finite values; skipping mesh");
                 return null;
             }
         }
@@ -396,7 +789,7 @@ function meshToThree(mesh) {
         const c = face[2];
         const d = face.length > 3 ? face[3] : undefined;
         if (![a, b, c].every((idx) => Number.isInteger(idx) && idx >= 0 && idx < vertexCount)) {
-            console.warn("[rhino3dm] Face reference out of bounds; skipping mesh");
+            console.warn("[geometry] Face reference out of bounds; skipping mesh");
             return null;
         }
         indexArray.push(a, b, c);
@@ -405,7 +798,7 @@ function meshToThree(mesh) {
         }
     }
     if (indexArray.length === 0) {
-        console.warn("[rhino3dm] Mesh produced no triangle indices; skipping");
+        console.warn("[geometry] Mesh produced no triangle indices; skipping");
         return null;
     }
     geometry.setIndex(indexArray);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@treasuryspatial/rhino-bridge",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "license": "UNLICENSED",
   "main": "./dist/index.js",