@vitrosoftware/common-ui-ts 1.1.121 → 1.1.123

package/lib/dxf-viewer/DxfWorker.js

@@ -0,0 +1,229 @@
+import {DxfFetcher} from "./DxfFetcher.js"
+import {DxfScene} from "./DxfScene.js"
+import opentype from "/resource/dxfViewer/js/opentype/opentype.module.js"
+
+const MSG_SIGNATURE = "DxfWorkerMsg"
+
+/** Wraps web-worker instance and provides unified interface to its services, including the when
+ * web-worker is not used and all heavy operations are performed in main thread.
+ */
+export class DxfWorker {
+    /** @param worker Web worker instance with DxfViewer.SetupWorker() function called. Can be null
+     *  for synchronous operations.
+     *  @param isWorker True for worker-side wrapper.
+     */
+    constructor(worker, isWorker = false) {
+        this.worker = worker
+        if (isWorker) {
+            worker.onmessage = this._ProcessRequest.bind(this)
+        } else if (worker) {
+            worker.addEventListener("message", this._ProcessResponse.bind(this), false)
+            worker.addEventListener("error", this._OnError.bind(this), false)
+            this.reqSeq = 1
+            /* Indexed by sequence. */
+            this.requests = new Map()
+            this.progressCbk = null
+        }
+    }
+
+    /**
+     * @param url DXF file URL.
+     * @param fonts {?string[]} Fonts URLs.
+     * @param options Viewer options. See DxfViewer.DefaultOptions.
+     * @param progressCbk {Function?} (phase, processedSize, totalSize)
+     */
+    async Load(url, fonts, options, progressCbk) {
+        if (this.worker) {
+            return this._SendRequest(DxfWorker.WorkerMsg.LOAD,
+                                     { url, fonts, options: this._CloneOptions(options) },
+                                     progressCbk)
+        } else {
+            return this._Load(url, fonts, options, progressCbk)
+        }
+    }
+
+    async Destroy(noWait = false) {
+        if (this.worker) {
+            if (!noWait) {
+                await this._SendRequest(DxfWorker.WorkerMsg.DESTROY)
+            }
+            /* close() in the worker is not enough, instance is still visible in dev tools. */
+            this.worker.terminate()
+        }
+    }
+
+    async _ProcessRequest(event) {
+        const msg = event.data
+        if (msg.signature !== MSG_SIGNATURE) {
+            console.log("Message with bad signature", msg)
+            return
+        }
+        const resp = {seq: msg.seq, type: msg.type, signature: MSG_SIGNATURE}
+        const transfers = []
+        try {
+            resp.data = await this._ProcessRequestMessage(msg.type, msg.data, transfers, msg.seq)
+        } catch (error) {
+            console.error(error)
+            resp.error = String(error)
+        }
+        this.worker.postMessage(resp, transfers)
+        if (msg.type === DxfWorker.WorkerMsg.DESTROY) {
+            this.worker.onmessage = null
+            this.worker.close()
+            this.worker = null
+        }
+    }
+
+    async _ProcessRequestMessage(type, data, transfers, seq) {
+        switch (type) {
+        case DxfWorker.WorkerMsg.LOAD: {
+            const {scene, dxf} = await this._Load(
+                data.url,
+                data.fonts,
+                data.options,
+                (phase, size, totalSize) => this._SendProgress(seq, phase, size, totalSize))
+            transfers.push(scene.vertices)
+            transfers.push(scene.indices)
+            transfers.push(scene.transforms)
+            return {scene, dxf}
+        }
+        case DxfWorker.WorkerMsg.DESTROY:
+            return null
+        default:
+            throw "Unknown message type: " + type
+        }
+    }
+
+    async _ProcessResponse(event) {
+        const msg = event.data
+        if (msg.signature !== MSG_SIGNATURE) {
+            console.log("Message with bad signature", msg)
+            return
+        }
+        const seq = msg.seq
+        const req = this.requests.get(seq)
+        if (!req) {
+            console.error("Unmatched message sequence: ", seq)
+            return
+        }
+        const data = msg.data
+        if (msg.type === DxfWorker.WorkerMsg.PROGRESS && req.progressCbk) {
+            req.progressCbk(data.phase, data.size, data.totalSize)
+            return
+        }
+        this.requests.delete(seq)
+        if (msg.hasOwnProperty("error")) {
+            req.SetError(msg.error)
+        } else {
+            req.SetResponse(data)
+        }
+    }
+
+    async _OnError(error) {
+        console.error("DxfWorker worker error", error)
+        const reqs = Array.from(this.requests.values)
+        this.requests.clear()
+        reqs.forEach(req => req.SetError(error))
+    }
+
+    async _SendRequest(type, data = null, progressCbk = null) {
+        const seq = this.reqSeq++
+        const req = new DxfWorker.Request(seq, progressCbk)
+        this.requests.set(seq, req)
+        this.worker.postMessage({ seq, type, data, signature: MSG_SIGNATURE})
+        return await req.GetResponse()
+    }
+
+    _SendProgress(seq, phase, size, totalSize) {
+        this.worker.postMessage({
+            seq,
+            type: DxfWorker.WorkerMsg.PROGRESS,
+            data: {phase, size, totalSize},
+            signature: MSG_SIGNATURE
+        })
+    }
+
+    /** @return {Object} DxfScene serialized scene. */
+    async _Load(url, fonts, options, progressCbk) {
+        let fontFetchers
+        if (fonts) {
+            fontFetchers = this._CreateFontFetchers(fonts, progressCbk)
+        } else {
+            fontFetchers = []
+        }
+        const dxf = await new DxfFetcher(url).Fetch(progressCbk)
+        if (progressCbk) {
+            progressCbk("prepare", 0, null)
+        }
+        const dxfScene = new DxfScene(options)
+        await dxfScene.Build(dxf, fontFetchers)
+        return {scene: dxfScene.scene, dxf: options.retainParsedDxf === true ? dxf : undefined }
+    }
+
+    _CreateFontFetchers(urls, progressCbk) {
+
+        function CreateFetcher(url) {
+            return async function() {
+                if (progressCbk) {
+                    progressCbk("font", 0, null)
+                }
+                const data = await fetch(url).then(response => response.arrayBuffer())
+                if (progressCbk) {
+                    progressCbk("prepare", 0, null)
+                }
+                return opentype.parse(data)
+            }
+        }
+
+        const fetchers = []
+        for (const url of urls) {
+            fetchers.push(CreateFetcher(url))
+        }
+        return fetchers
+    }
+
+    _CloneOptions(options) {
+        /* Default options values are taken from prototype so need to implement deep clone here. */
+        if (Array.isArray(options)) {
+            return options.map(o => this._CloneOptions(o))
+        } else if (typeof options === "object" && options !== null) {
+            const result = {}
+            for (const propName in options) {
+                // noinspection JSUnfilteredForInLoop
+                result[propName] = this._CloneOptions(options[propName])
+            }
+            return result
+        } else {
+            return options
+        }
+    }
+}
+
+DxfWorker.WorkerMsg = {
+    LOAD: "LOAD",
+    PROGRESS: "PROGRESS",
+    DESTROY: "DESTROY"
+}
+
+DxfWorker.Request = class {
+    constructor(seq, progressCbk) {
+        this.seq = seq
+        this.progressCbk = progressCbk
+        this.promise = new Promise((resolve, reject) => {
+            this._Resolve = resolve
+            this._Reject = reject
+        })
+    }
+
+    async GetResponse() {
+        return await this.promise
+    }
+
+    SetResponse(response) {
+        this._Resolve(response)
+    }
+
+    SetError(error) {
+        this._Reject(error)
+    }
+}

package/lib/dxf-viewer/DynamicBuffer.js

@@ -0,0 +1,100 @@
+/** Typed-array-based buffer which can be dynamically extended. */
+export class DynamicBuffer {
+    /**
+     * @param type Array type, see NativeType.
+     * @param initialCapacity Initial capacity, number of elements.
+     */
+    constructor(type, initialCapacity = 16) {
+        this.type = type
+        this.capacity = initialCapacity
+        this.size = 0
+        this.buffer = new (NativeArray(type))(initialCapacity)
+    }
+
+    GetSize() {
+        return this.size
+    }
+
+    /**
+     * Append new value to the buffer end.
+     * @return Appended value position in the buffer.
+     */
+    Push(value) {
+        this._CheckGrow()
+        const pos = this.size
+        this.buffer[pos] = value
+        this.size++
+        return pos
+    }
+
+    Get(index) {
+        if (index >= this.size) {
+            throw new Error(`Index out of range: ${index}/${this.size}`)
+        }
+        return this.buffer[index]
+    }
+
+    /** Copy content to the specified buffer.
+     * @param dstBuffer Destination buffer, should be typed array of the same type.
+     * @param dstOffset {number} Offset in elements in the destination buffer.
+     * @param srcOffset {number} Offset in elements in this buffer.
+     * @param size {number} Number of elements to copy, -1 (default) to copy till this buffer end.
+     */
+    CopyTo(dstBuffer, dstOffset, srcOffset = 0, size = -1) {
+        if (size === -1) {
+            size = this.size - srcOffset
+        }
+        const src = new (NativeArray(this.type))(this.buffer.buffer, srcOffset, size)
+        dstBuffer.set(src, dstOffset)
+    }
+
+    _CheckGrow() {
+        if (this.size < this.capacity) {
+            return
+        }
+        this.capacity *= 2
+        const newBuffer = new (NativeArray(this.type))(this.capacity)
+        newBuffer.set(this.buffer)
+        this.buffer = newBuffer
+    }
+}
+
+export const NativeType = {
+    INT8: 0,
+    UINT8: 1,
+    UINT8_CLAMPED: 2,
+    INT16: 3,
+    UINT16: 4,
+    INT32: 5,
+    UINT32: 6,
+    INT64: 7,
+    UINT64: 8,
+    FLOAT32: 9,
+    FLOAT64: 10
+}
+
+/** Get TypedArray type corresponding to the specified NativeType. */
+export function NativeArray(type) {
+    switch (type) {
+    case NativeType.INT8:
+        return Int8Array
+    case NativeType.UINT8:
+        return Uint8Array
+    case NativeType.UINT8_CLAMPED:
+        return Uint8ClampedArray
+    case NativeType.INT16:
+        return Int16Array
+    case NativeType.UINT16:
+        return Uint16Array
+    case NativeType.INT32:
+        return Int32Array
+    case NativeType.UINT32:
+        return Uint32Array
+    case NativeType.FLOAT32:
+        return Float32Array
+    case NativeType.FLOAT64:
+        return Float64Array
+    default:
+        throw new Error("Unrecognized native type: " + type)
+    }
+}

package/lib/dxf-viewer/HatchCalculator.js

@@ -0,0 +1,345 @@
+import { Vector2, Matrix3, Box2 } from "/resource/dxfViewer/js/three/three.module.js"
+import { IntersectSegmentsParametric } from "./math/utils"
+
+export const HatchStyle = Object.freeze({
+    ODD_PARITY: 0,
+    OUTERMOST: 1,
+    THROUGH_ENTIRE_AREA: 2
+})
+
+/** Force intersection at this distance from edge endpoint (parameter value). */
+const ENDPOINT_MARGIN = 1e-4
+
+/** @return {boolean} True if both edges crossed from the same side, false otherwise. */
+function EdgeSameSide(e1, e2) {
+    return (e1.intersection[2] > 0 && e2.intersection[2]) > 0 ||
+        (e1.intersection[2] < 0 && e2.intersection[2] < 0)
+}
+
+/** Context for one line clipping calculations. */
+class ClipCalculator {
+
+    constructor(boundaryLoops, style, line) {
+        this.style = style
+        this.line = line
+        this.lineDir = line[1].clone().sub(line[0]).normalize()
+
+        this.loops = []
+        for (let loopIdx = 0; loopIdx < boundaryLoops.length; loopIdx++) {
+            const loop = boundaryLoops[loopIdx]
+            const _loop = []
+            for (let vtxIdx = 0; vtxIdx < loop.length; vtxIdx++) {
+                _loop.push({
+                    idx: vtxIdx,
+                    start: loop[vtxIdx],
+                    end: loop[vtxIdx == loop.length - 1 ? 0 : vtxIdx + 1],
+                    loopIdx
+                })
+            }
+            this.loops.push(_loop)
+        }
+    }
+
+    /**
+     * @return {number[2][]} List of resulting line segments in parametric form. Parameter value 0
+     *  corresponds to the provided line start point, 1 - to end point.
+     */
+    Calculate() {
+        this._ProcessEdges()
+        this._CreateNodes()
+        /* Sort from line start towards end. */
+        this.nodes.sort((e1, e2) => e1.intersection[0] - e2.intersection[0])
+        if (this.style == HatchStyle.ODD_PARITY) {
+            return this._GenerateOddParitySegments()
+        }
+        //XXX assume through all for all the reset style
+        return this._GenerateThroughAllSegments()
+    }
+
+    _ProcessEdges() {
+        for (const loop of this.loops) {
+            for (const edge of loop) {
+                const edgeVec = edge.end.clone().sub(edge.start)
+                const len = edgeVec.length()
+                edge.isZero = len <= Number.EPSILON
+                if (edge.isZero) {
+                    continue
+                }
+                edgeVec.divideScalar(len)
+                const a = edgeVec.cross(this.lineDir)
+                edge.isParallel = Math.abs(a) <= 1e-6
+                if (edge.isParallel) {
+                    continue
+                }
+                edge.intersection = IntersectSegmentsParametric(this.line[0], this.line[1],
+                    edge.start, edge.end, true)
+            }
+        }
+    }
+
+    /** Create intersection nodes. Each node with `toggle` property set causes line state change, so
+     * unnecessary changes should be filtered out inside this method. Node also can suppress or
+     * un-suppress line if currently enabled, this is done by setting `suppress` and
+     * `unsuppress` properties on the edge.
+     */
+    _CreateNodes() {
+        this.nodes = []
+        for (const loop of this.loops) {
+            for (let edge of loop) {
+                if (edge.isZero || edge.isParallel || edge.isProcessed || !edge.intersection) {
+                    continue
+                }
+
+                if (edge.intersection[1] < -ENDPOINT_MARGIN ||
+                    edge.intersection[1] > 1 + ENDPOINT_MARGIN) {
+                    /* No intersection. */
+                    continue
+                }
+
+                /* Some intersection exists, check if near endpoints. */
+                const isStartVtx = edge.intersection[1] <= ENDPOINT_MARGIN
+                if (isStartVtx || edge.intersection[1] >= 1 - ENDPOINT_MARGIN) {
+                    /* Intersection near start or end vertex, force connected edge check. */
+                    let [connEdge, isDirect] = this._GetConnectedEdge(edge, isStartVtx)
+                    if (!connEdge) {
+                        /* Some invalid case, ignore. */
+                        continue
+                    }
+                    edge.isProcessed = true
+                    connEdge.isProcessed = true
+                    if (isDirect) {
+                        if (EdgeSameSide(edge, connEdge)) {
+                            edge.toggle = true
+                            this.nodes.push(edge)
+                        }
+                    } else {
+                        /** Connected through colinear edge(s). Mark the first edge to temporarily
+                         * disable line if it is enabled. Second edge either toggles the state or
+                         * restores previous one.
+                         */
+                        if (edge.intersection[0] > connEdge.intersection[0]) {
+                            /* Set proper order, `edge` is the first intersection, `connEdge` - the
+                             * second one.
+                             */
+                            const tmp = connEdge
+                            connEdge = edge
+                            edge = tmp
+                        }
+
+                        edge.suppress = true
+                        connEdge.unsuppress = true
+
+                        this.nodes.push(edge)
+
+                        if (EdgeSameSide(edge, connEdge)) {
+                            connEdge.toggle = true
+                        }
+                        this.nodes.push(connEdge)
+                    }
+
+                } else {
+                    /* Clean inner intersection. */
+                    edge.isProcessed = true
+                    edge.toggle = true
+                    this.nodes.push(edge)
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {Edge} edge
+     * @param {boolean} isStartVtx True for connected through start vertex, false for end vertex.
+     * @return {[?Edge, boolean]} Connected valid edge if found, null if not found (e.g. is the same
+     *  edge for some reason). Second value is true if directly connected, false if though colinear
+     *  edges.
+     */
+    _GetConnectedEdge(edge, isStartVtx) {
+        const loop = this.loops[edge.loopIdx]
+        let i = edge.idx
+        let isDirect = true
+        do {
+            if (isStartVtx) {
+                if (i == 0) {
+                    i = loop.length - 1
+                } else {
+                    i--
+                }
+            } else {
+                if (i == loop.length - 1) {
+                    i = 0
+                } else {
+                    i++
+                }
+            }
+            const connEdge = loop[i]
+            if (connEdge.isZero || connEdge.isParallel) {
+                isDirect = false
+            } else {
+                return [connEdge, isDirect]
+            }
+        } while (i != edge.idx)
+        return [null, false]
+    }
+
+    _GenerateOddParitySegments() {
+        const result = []
+        let state = false
+        /* Incremented with each suppression, decremented with each un-suppression. */
+        let suppress = 0
+        /* Previous node when line was enabled. */
+        let prevNode = null
+
+        for (const node of this.nodes) {
+            if (node.suppress) {
+                suppress++
+            }
+            if (node.unsuppress) {
+                suppress--
+            }
+            if (node.toggle) {
+                state = !state
+            }
+            if (suppress == 0 && state && (node.unsuppress || node.toggle)) {
+                /* Just started new segment. */
+                prevNode = node
+            } else if ((suppress || !state) && prevNode) {
+                if (node.intersection[0] - prevNode.intersection[0] > Number.EPSILON) {
+                    result.push([prevNode.intersection[0], node.intersection[0]])
+                }
+                prevNode = null
+            }
+        }
+
+        return result
+    }
+
+    _GenerateThroughAllSegments() {
+        const result = []
+        /* Incremented with each suppression, decremented with each un-suppression. */
+        let suppress = 0
+        /* Previous node when line was enabled. */
+        let prevNode = null
+        /** For each loop count number of crossing from each side. One side increments corresponding
+         * loop value, other decrements. When all values are zero, line is outside of any loop and
+         * should not be rendered.
+         */
+        const loopStack = new Array(this.loops.length).fill(0);
+
+        function IsOutside() {
+            for (const n of loopStack) {
+                if (n != 0) {
+                    return false
+                }
+            }
+            return true
+        }
+
+        for (const node of this.nodes) {
+            if (node.suppress) {
+                suppress++
+            }
+            if (node.unsuppress) {
+                suppress--
+            }
+            const wasOutside = IsOutside()
+            if (node.toggle) {
+                if (node.intersection[2] > 0) {
+                    loopStack[node.loopIdx]++
+                } else {
+                    loopStack[node.loopIdx]--
+                }
+            }
+            if (suppress == 0 && !IsOutside() && (node.unsuppress || wasOutside)) {
+                /* Just started new segment. */
+                prevNode = node
+            } else if ((suppress || IsOutside()) && prevNode) {
+                if (node.intersection[0] - prevNode.intersection[0] > Number.EPSILON) {
+                    result.push([prevNode.intersection[0], node.intersection[0]])
+                }
+                prevNode = null
+            }
+        }
+
+        return result
+    }
+}
+
+export class HatchCalculator {
+    boundaryLoops
+    style
+
+    /**
+     * Arrays of `Path` to use as boundary, and each `Path` is array of `Point`.
+     *
+     * @param {Vector2[][]} boundaryLoops
+     * @param {HatchStyle} style
+     */
+    constructor(boundaryLoops, style) {
+        this.boundaryLoops = boundaryLoops
+        this.style = style
+    }
+
+    /**
+     * Clip `line` using strategy defined by `this.style`
+     *
+     * @param {[Vector2, Vector2]} line Line segment defined by start and end points. Assuming start
+     *  and end points lie out of the boundary loops specified in the constructor.
+     * @returns {[Vector2, Vector2][]} clipped line segments
+     */
+    ClipLine(line) {
+        return new ClipCalculator(this.boundaryLoops, this.style, line).Calculate()
+    }
+
+    /**
+     * @param {Vector2} seedPoint Pattern seed point coordinates in OCS.
+     * @param {?number} angle Pattern rotation angle in radians.
+     * @param {?number} scale Pattern scale.
+     * @return {Matrix3} Transformation from OCS to pattern space.
+     */
+    GetPatternTransform({seedPoint, angle, scale}) {
+        const m = new Matrix3().makeTranslation(-seedPoint.x, -seedPoint.y)
+        if (angle) {
+            /* Matrix3.rotate() inverts angle sign. */
+            m.rotate(angle)
+        }
+        if ((scale ?? 1) != 1) {
+            m.scale(1 / scale, 1 / scale)
+        }
+        return m
+    }
+
+    /**
+     * @param {Matrix3} patTransform Transformation from OCS to pattern space previously obtained by
+     *      GetPatternTransform() method.
+     * @param {?Vector2} basePoint Line base point coordinate in pattern space.
+     * @param {?number} angle Line direction angle in radians, CCW from +X direction.
+     * @return {Matrix3} Transformation from OCS to pattern line space. Line is started at origin
+     *  and directed into position X axis direction.
+     */
+    GetLineTransform({patTransform, basePoint, angle}) {
+        const m = patTransform.clone()
+        if (basePoint) {
+            m.translate(-basePoint.x, -basePoint.y)
+        }
+        if (angle) {
+            /* Matrix3.rotate() inverts angle sign. */
+            m.rotate(angle)
+        }
+        return m
+    }
+
+    /**
+     * @param {Matrix3} transform Transformation from OCS to target coordinates space.
+     * @return {Box2} Pattern AABB in target coordinate space.
+     */
+    GetBoundingBox(transform) {
+        const box = new Box2()
+        for (const path of this.boundaryLoops) {
+            for (const v of path) {
+                box.expandByPoint(v.clone().applyMatrix3(transform))
+            }
+        }
+        return box
+    }
+}