@configura/babylon-view 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/geometry/stretch/CfgStretchData.js

@@ -1,350 +1,350 @@
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { SymGfxMode } from "@configura/web-core/dist/cm/format/cmsym/components/SymComponent.js";
-import { convertLength, hashCode } from "@configura/web-utilities";
-import { MESH_UNIT } from "../../nodes/CfgSymRootNode.js";
-import { cmPointToVector3 } from "../../utilities/utilities3D.js";
-function calculateNormals(sp, ep) {
-    const normal = ep.subtract(sp);
-    const spToEpLength = normal.length();
-    const normalizedNormal = normal.normalizeToNew();
-    return {
-        spToEpLength,
-        normal,
-        normalizedNormal,
-    };
-}
-/**
- * How far along from sp to ep is a point on a plane crossing the sp to ep line?
- * 1 means at ep, 0 means at sp.
- */
-export function calculateAlongness(p, sp, spToEpLength, normalizedNormal) {
-    const towardTp = p.subtract(sp);
-    return ((normalizedNormal.x * towardTp.x +
-        normalizedNormal.y * towardTp.y +
-        normalizedNormal.z * towardTp.z) /
-        spToEpLength);
-}
-/**
- * Where does the point p end up given the CfgStretchDatas and the StretchMap.
- * This is the same equations that Babylon uses for stretching, only Babylon does it in the
- * shaders during rendering and is thus GPU accelerated.
- * This version is much slower, but that is okay as long as this function is sparingly used.
- */
-export const toStretchedPoint = (p, stretchDatas, stretchReferenceLengthsByMeasureParamCode) => stretchDatas.reduce((acc, stretchData) => {
-    const referenceLength = stretchReferenceLengthsByMeasureParamCode.get(stretchData.measureParam);
-    if (referenceLength === undefined) {
-        return acc;
-    }
-    return acc.add(stretchData
-        .stretchPointToTwice(p)
-        .scale(stretchData.calculateInfluenceGivenTwiceMorphTarget(referenceLength.current)));
-}, p);
-function spOrEpToPoint(node) {
-    const trans = node.symTransform(true);
-    if (trans.scale.x !== 1 || trans.scale.y !== 1 || trans.scale.z !== 1) {
-        throw new Error("We do not expect scale on sp or ep");
-    }
-    if (trans.rot !== undefined) {
-        throw new Error("We do not expect rotation on sp or ep");
-    }
-    if (trans.pivot !== undefined) {
-        throw new Error("We do not expect pivot on sp or ep");
-    }
-    const pos = trans.pos;
-    if (pos === undefined) {
-        return new Vector3();
-    }
-    return cmPointToVector3(pos);
-}
-/**
- * Please note that stretch is not bound to be contained between sp and ep.
- *
- * The thinking in the equations in CfgStretchData is that we want to support MorphTargets in an as
- * efficient manner as possible. As MorphTargets work by morphing between pre-compiled meshes we
- * calculate what happens if you stretch to twice the referenceLength, to make MorphTargets for
- * twice the referenceLength, and then calculate how these MorphTargets should be applied to
- * achieve to requested referenceLength.
- *
- * This adaption to MorphTargets might make the code for stretching points for other purposes look
- * (be) a bit complicated. However, as a mesh often contains millions of vertices that needs to be
- * moved and calculating for bounding boxes, and anchor points and such moves very few vertices,
- * this is okay.
- *
- * Using "Twice" as the precomputed target is arbitrarily, we just chose it because it makes
- * equations simple.
- */
-export class CfgStretchData {
-    /**
-     * It is assumed that the symNode passed really is stretch (symNodeIsStretch has been run)
-     * so any data missing for stretch will be an Exception.
-     *
-     * @param detailLevel
-     * @param measureParam Name of the parameter controlling the stretch
-     * @param stretchSymNodeId Id of the SymNode. This is used for anchoring.
-     * @param originalReferenceLength Server-side calculated original referenceLength. We do not
-     * actually use this for anything, but it can be handy for debug.
-     * @param sp Start Point, the start anchor of the stretch line.
-     * @param ep End Point, the end anchor of the stretch line.
-     * @param spToEpLength Distance from sp to ep.
-     * @param originalSpToEpLength spToEpLength before transforms.
-     * @param normal The normal is from sp to ep and is the normal of every plane that divides this
-     * stretch.
-     * @param normalNormalized Normalized version of normal
-     * @param sections The slices the model is sliced into
-     */
-    constructor(detailLevel, measureParam, stretchSymNodeId, originalReferenceLength, sp, ep, spToEpLength, originalSpToEpLength, normal, normalNormalized, sections) {
-        this.detailLevel = detailLevel;
-        this.measureParam = measureParam;
-        this.stretchSymNodeId = stretchSymNodeId;
-        this.originalReferenceLength = originalReferenceLength;
-        this.sp = sp;
-        this.ep = ep;
-        this.spToEpLength = spToEpLength;
-        this.originalSpToEpLength = originalSpToEpLength;
-        this.normal = normal;
-        this.normalNormalized = normalNormalized;
-        this.sections = sections;
-        /** How far along between sp and ep is p? */
-        this.getAlongness = (p) => calculateAlongness(p, this.sp, this.spToEpLength, this.normalNormalized);
-    }
-    static make(logger, symNode, detailLevel) {
-        const symMeasure = symNode.getMeasure();
-        if (symMeasure === undefined) {
-            throw new Error("No symMeasure found");
-        }
-        const { measureParam, sections, originalLength } = symMeasure;
-        if (measureParam === undefined) {
-            throw new Error("No measureParam");
-        }
-        const stretchSymNodeId = symNode.id;
-        if (stretchSymNodeId !== measureParam) {
-            logger.warn(`measureParam (${measureParam}) has different ID from parent symNode (${stretchSymNodeId})`);
-        }
-        const children = symNode.children(logger, true, true);
-        let sp;
-        let ep;
-        const detailLevelToDividerNameToPos = new Map();
-        let detailLevelNodeName3D;
-        let detailLevelNodeName2D;
-        for (const [name, node] of children) {
-            const symReps = node.symReps(true);
-            const details = symReps._details;
-            // We relax the requirements on detail-level a bit when it comes to sp and ep.
-            // If we can not find sp and/or ep that is the right detail-level we take the
-            // first one we found.
-            if (sp === undefined && name === "sp") {
-                sp = spOrEpToPoint(node);
-            }
-            else if (ep === undefined && name === "ep") {
-                ep = spOrEpToPoint(node);
-            }
-            // We only handle children which either has no detail-level or has an acceptable
-            // detail-level
-            if (details !== undefined) {
-                const detailMask = details.values().next().value;
-                if (!detailMask.includes(detailLevel)) {
-                    continue;
-                }
-            }
-            if (name.startsWith("divider")) {
-                const nodeChildren = node.children(logger, true, true);
-                for (const [subLevelNodeName, subNode] of nodeChildren) {
-                    const trans = subNode.symTransform(true);
-                    if (trans === undefined) {
-                        continue;
-                    }
-                    const pos = trans.pos;
-                    if (pos === undefined) {
-                        continue;
-                    }
-                    let dividerNameToPos = detailLevelToDividerNameToPos.get(subLevelNodeName);
-                    if (dividerNameToPos === undefined) {
-                        dividerNameToPos = new Map();
-                        detailLevelToDividerNameToPos.set(subLevelNodeName, dividerNameToPos);
-                    }
-                    dividerNameToPos.set(name, cmPointToVector3(pos));
-                }
-            }
-            else if (name.startsWith("3D")) {
-                detailLevelNodeName3D = name;
-            }
-            else if (name.startsWith("2D")) {
-                detailLevelNodeName2D = name;
-            }
-            else if (name === "sp") {
-                sp = spOrEpToPoint(node);
-            }
-            else if (name === "ep") {
-                ep = spOrEpToPoint(node);
-            }
-        }
-        if (sp === undefined) {
-            throw new Error("Start point missing");
-        }
-        if (ep === undefined) {
-            throw new Error("End point missing");
-        }
-        if (sp.equals(ep)) {
-            throw new Error("Start point and End point are equal");
-        }
-        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
-        if (detailLevelToDividerNameToPos.size === 0) {
-            throw new Error("Dividers missing");
-        }
-        if (detailLevelNodeName3D === undefined && detailLevelNodeName2D === undefined) {
-            throw new Error("Details level node name missing");
-        }
-        let detailLevelGfxMode = SymGfxMode.undefined;
-        let dividerNameToPos;
-        if (detailLevelNodeName3D !== undefined) {
-            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName3D);
-            if (dividerNameToPos !== undefined) {
-                detailLevelGfxMode = SymGfxMode.x3D;
-            }
-        }
-        if (dividerNameToPos === undefined && detailLevelNodeName2D !== undefined) {
-            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName2D);
-            if (dividerNameToPos !== undefined) {
-                detailLevelGfxMode = SymGfxMode.x2D;
-            }
-        }
-        if (dividerNameToPos === undefined) {
-            throw new Error("Dividers for detail level missing");
-        }
-        const processedSections = CfgStretchData.processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal);
-        return new this(detailLevel, measureParam, stretchSymNodeId, originalLength, sp, ep, spToEpLength, spToEpLength, normal, normalizedNormal, processedSections);
-    }
-    static processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal) {
-        // The morph target shall morph to making the morphed thing
-        // twice as long as before morph, that is, 100% increase.
-        // The sizeChange parameters are assumed to aggregate to 1.
-        // The alongness goes from 0 at sp to 1 at ep. So summing these
-        // should make the postStretchEndAlongness of the last one be 2.
-        let accumulatedSizeChange = 0;
-        let startAlongness = 0;
-        let atTwiceStartAlongness = 0;
-        return sections.map((section, sectionIndex) => {
-            const { move, sizeChange, gfxModeToDetailLevelToMultiSelector } = section;
-            const sectionsLength = sections.length;
-            if (sectionsLength < 1) {
-                throw new Error("At lease one section needed for stretch");
-            }
-            const first = sectionIndex === 0;
-            const last = sectionIndex === sectionsLength - 1;
-            const detailLevelToMultiSelector = gfxModeToDetailLevelToMultiSelector.get(detailLevelGfxMode);
-            if (detailLevelToMultiSelector === undefined) {
-                throw new Error("No x3D or x2D for section");
-            }
-            const multiSelector = detailLevelToMultiSelector.get(detailLevel);
-            if (multiSelector === undefined) {
-                throw new Error("No multiSelector for detail level");
-            }
-            const selectors = multiSelector.selectors;
-            const selectorsLength = selectors.length;
-            if ((first || last ? 1 : 2) !== selectorsLength) {
-                throw new Error("Divider plane count expected to be 1 for first or last and 2 for others");
-            }
-            let endAlongness;
-            if (last) {
-                endAlongness = 1;
-            }
-            else {
-                const dividerId = selectors[selectorsLength - 1].dividerId;
-                const pos = dividerNameToPos.get(dividerId);
-                if (pos === undefined) {
-                    throw new Error("No position found for symDividerSelector");
-                }
-                endAlongness = calculateAlongness(pos, sp, spToEpLength, normalizedNormal);
-            }
-            accumulatedSizeChange += sizeChange;
-            const atTwiceEndAlongness = endAlongness + accumulatedSizeChange;
-            const result = {
-                last,
-                move,
-                sizeChange,
-                startAlongness,
-                endAlongness,
-                atTwiceTranslation: move && 0 < sectionIndex
-                    ? atTwiceEndAlongness - endAlongness
-                    : atTwiceStartAlongness - startAlongness,
-                atTwiceScale: move
-                    ? 0
-                    : (atTwiceEndAlongness - atTwiceStartAlongness) /
-                        (endAlongness - startAlongness) -
-                        1,
-            };
-            startAlongness = endAlongness;
-            atTwiceStartAlongness = atTwiceEndAlongness;
-            return result;
-        });
-    }
-    get hash() {
-        if (this._hash === undefined) {
-            this._hash = hashCode(`${this.detailLevel}-${this.measureParam}-${this.sp.asArray().join(",")}-${this.ep
-                .asArray()
-                .join(",")}-${this.originalSpToEpLength}-${this.sections
-                .map((section) => `${section.startAlongness}-${section.endAlongness}-${section.move ? "Y" : "N"}-${section.sizeChange}`)
-                .join(",")}`);
-        }
-        return this._hash;
-    }
-    /**
-     * If the Matrix is identity the original CfgStretchData is returned.
-     * If not a new CfgStretchData will be created.
-     * sp, ep, spToEpLength, normal, normalNormalized, scale will be cloned and transformed
-     * The rest will still reference the original objects
-     */
-    applyMatrix(matrix) {
-        if (matrix.isIdentity()) {
-            return this;
-        }
-        const sp = Vector3.TransformCoordinates(this.sp, matrix);
-        const ep = Vector3.TransformCoordinates(this.ep, matrix);
-        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
-        return new CfgStretchData(this.detailLevel, this.measureParam, this.stretchSymNodeId, this.originalReferenceLength, sp, ep, spToEpLength, this.spToEpLength, normal, normalizedNormal, this.sections);
-    }
-    /**
-     * Calculates the translation of a point which moves it from its original position to where it
-     * would be if we stretched to twice the reference length. Please note: this gives the
-     * translation, not the new location. The new location will be p.add(stretchPointToTwice(p))
-     */
-    stretchPointToTwice(p) {
-        const alongness = this.getAlongness(p);
-        const { sections, normal } = this;
-        for (const section of sections) {
-            const endAlongness = section.endAlongness;
-            if (section.last || alongness <= endAlongness) {
-                let translation = section.atTwiceTranslation;
-                if (!section.move) {
-                    translation += (alongness - section.startAlongness) * section.atTwiceScale;
-                }
-                return normal.scale(translation);
-            }
-        }
-        throw new Error("Should not be possible");
-    }
-    /**
-     * Given a reference length calculates the influence that should be applied to a MorphTarget to
-     * achieve the requested length, given that these MorphTargets are constructed so that they
-     * will double the length when the influence 1 is applied.
-     *
-     * Please note that the referenceLength is the wanted length between sp and ep, that is, the
-     * stretch line. This line does not have to be span the entire model. Also, there can be
-     * multiple stretch lines that are not orthogonal to this, and the will also affect the actual
-     * size. Finally there can be transforms applied in the tree. So, the referenceLength will only
-     * be the actual length of the model in specific cases. However, we believe that models with
-     * stretch are often constructed in such a way that in real use cases the referenceLength is
-     * the actual real length.
-     */
-    calculateInfluenceGivenTwiceMorphTarget(referenceLength) {
-        const { originalSpToEpLength } = this;
-        if (referenceLength.length === 0) {
-            // CET considers 0 as a no-value and will return the stretch to the default value.
-            // If this changes, remove this workaround.
-            return 0;
-        }
-        return ((convertLength(referenceLength.length, referenceLength.unit, MESH_UNIT) -
-            originalSpToEpLength) /
-            originalSpToEpLength);
-    }
-}
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { SymGfxMode } from "@configura/web-core/dist/cm/format/cmsym/components/SymComponent.js";
+import { convertLength, hashCode } from "@configura/web-utilities";
+import { MESH_UNIT } from "../../nodes/CfgSymRootNode.js";
+import { cmPointToVector3 } from "../../utilities/utilities3D.js";
+function calculateNormals(sp, ep) {
+    const normal = ep.subtract(sp);
+    const spToEpLength = normal.length();
+    const normalizedNormal = normal.normalizeToNew();
+    return {
+        spToEpLength,
+        normal,
+        normalizedNormal,
+    };
+}
+/**
+ * How far along from sp to ep is a point on a plane crossing the sp to ep line?
+ * 1 means at ep, 0 means at sp.
+ */
+export function calculateAlongness(p, sp, spToEpLength, normalizedNormal) {
+    const towardTp = p.subtract(sp);
+    return ((normalizedNormal.x * towardTp.x +
+        normalizedNormal.y * towardTp.y +
+        normalizedNormal.z * towardTp.z) /
+        spToEpLength);
+}
+/**
+ * Where does the point p end up given the CfgStretchDatas and the StretchMap.
+ * This is the same equations that Babylon uses for stretching, only Babylon does it in the
+ * shaders during rendering and is thus GPU accelerated.
+ * This version is much slower, but that is okay as long as this function is sparingly used.
+ */
+export const toStretchedPoint = (p, stretchDatas, stretchReferenceLengthsByMeasureParamCode) => stretchDatas.reduce((acc, stretchData) => {
+    const referenceLength = stretchReferenceLengthsByMeasureParamCode.get(stretchData.measureParam);
+    if (referenceLength === undefined) {
+        return acc;
+    }
+    return acc.add(stretchData
+        .stretchPointToTwice(p)
+        .scale(stretchData.calculateInfluenceGivenTwiceMorphTarget(referenceLength.current)));
+}, p);
+function spOrEpToPoint(node) {
+    const trans = node.symTransform(true);
+    if (trans.scale.x !== 1 || trans.scale.y !== 1 || trans.scale.z !== 1) {
+        throw new Error("We do not expect scale on sp or ep");
+    }
+    if (trans.rot !== undefined) {
+        throw new Error("We do not expect rotation on sp or ep");
+    }
+    if (trans.pivot !== undefined) {
+        throw new Error("We do not expect pivot on sp or ep");
+    }
+    const pos = trans.pos;
+    if (pos === undefined) {
+        return new Vector3();
+    }
+    return cmPointToVector3(pos);
+}
+/**
+ * Please note that stretch is not bound to be contained between sp and ep.
+ *
+ * The thinking in the equations in CfgStretchData is that we want to support MorphTargets in an as
+ * efficient manner as possible. As MorphTargets work by morphing between pre-compiled meshes we
+ * calculate what happens if you stretch to twice the referenceLength, to make MorphTargets for
+ * twice the referenceLength, and then calculate how these MorphTargets should be applied to
+ * achieve to requested referenceLength.
+ *
+ * This adaption to MorphTargets might make the code for stretching points for other purposes look
+ * (be) a bit complicated. However, as a mesh often contains millions of vertices that needs to be
+ * moved and calculating for bounding boxes, and anchor points and such moves very few vertices,
+ * this is okay.
+ *
+ * Using "Twice" as the precomputed target is arbitrarily, we just chose it because it makes
+ * equations simple.
+ */
+export class CfgStretchData {
+    /**
+     * It is assumed that the symNode passed really is stretch (symNodeIsStretch has been run)
+     * so any data missing for stretch will be an Exception.
+     *
+     * @param detailLevel
+     * @param measureParam Name of the parameter controlling the stretch
+     * @param stretchSymNodeId Id of the SymNode. This is used for anchoring.
+     * @param originalReferenceLength Server-side calculated original referenceLength. We do not
+     * actually use this for anything, but it can be handy for debug.
+     * @param sp Start Point, the start anchor of the stretch line.
+     * @param ep End Point, the end anchor of the stretch line.
+     * @param spToEpLength Distance from sp to ep.
+     * @param originalSpToEpLength spToEpLength before transforms.
+     * @param normal The normal is from sp to ep and is the normal of every plane that divides this
+     * stretch.
+     * @param normalNormalized Normalized version of normal
+     * @param sections The slices the model is sliced into
+     */
+    constructor(detailLevel, measureParam, stretchSymNodeId, originalReferenceLength, sp, ep, spToEpLength, originalSpToEpLength, normal, normalNormalized, sections) {
+        this.detailLevel = detailLevel;
+        this.measureParam = measureParam;
+        this.stretchSymNodeId = stretchSymNodeId;
+        this.originalReferenceLength = originalReferenceLength;
+        this.sp = sp;
+        this.ep = ep;
+        this.spToEpLength = spToEpLength;
+        this.originalSpToEpLength = originalSpToEpLength;
+        this.normal = normal;
+        this.normalNormalized = normalNormalized;
+        this.sections = sections;
+        /** How far along between sp and ep is p? */
+        this.getAlongness = (p) => calculateAlongness(p, this.sp, this.spToEpLength, this.normalNormalized);
+    }
+    static make(logger, symNode, detailLevel) {
+        const symMeasure = symNode.getMeasure();
+        if (symMeasure === undefined) {
+            throw new Error("No symMeasure found");
+        }
+        const { measureParam, sections, originalLength } = symMeasure;
+        if (measureParam === undefined) {
+            throw new Error("No measureParam");
+        }
+        const stretchSymNodeId = symNode.id;
+        if (stretchSymNodeId !== measureParam) {
+            logger.warn(`measureParam (${measureParam}) has different ID from parent symNode (${stretchSymNodeId})`);
+        }
+        const children = symNode.children(logger, true, true);
+        let sp;
+        let ep;
+        const detailLevelToDividerNameToPos = new Map();
+        let detailLevelNodeName3D;
+        let detailLevelNodeName2D;
+        for (const [name, node] of children) {
+            const symReps = node.symReps(true);
+            const details = symReps._details;
+            // We relax the requirements on detail-level a bit when it comes to sp and ep.
+            // If we can not find sp and/or ep that is the right detail-level we take the
+            // first one we found.
+            if (sp === undefined && name === "sp") {
+                sp = spOrEpToPoint(node);
+            }
+            else if (ep === undefined && name === "ep") {
+                ep = spOrEpToPoint(node);
+            }
+            // We only handle children which either has no detail-level or has an acceptable
+            // detail-level
+            if (details !== undefined) {
+                const detailMask = details.values().next().value;
+                if (!detailMask.includes(detailLevel)) {
+                    continue;
+                }
+            }
+            if (name.startsWith("divider")) {
+                const nodeChildren = node.children(logger, true, true);
+                for (const [subLevelNodeName, subNode] of nodeChildren) {
+                    const trans = subNode.symTransform(true);
+                    if (trans === undefined) {
+                        continue;
+                    }
+                    const pos = trans.pos;
+                    if (pos === undefined) {
+                        continue;
+                    }
+                    let dividerNameToPos = detailLevelToDividerNameToPos.get(subLevelNodeName);
+                    if (dividerNameToPos === undefined) {
+                        dividerNameToPos = new Map();
+                        detailLevelToDividerNameToPos.set(subLevelNodeName, dividerNameToPos);
+                    }
+                    dividerNameToPos.set(name, cmPointToVector3(pos));
+                }
+            }
+            else if (name.startsWith("3D")) {
+                detailLevelNodeName3D = name;
+            }
+            else if (name.startsWith("2D")) {
+                detailLevelNodeName2D = name;
+            }
+            else if (name === "sp") {
+                sp = spOrEpToPoint(node);
+            }
+            else if (name === "ep") {
+                ep = spOrEpToPoint(node);
+            }
+        }
+        if (sp === undefined) {
+            throw new Error("Start point missing");
+        }
+        if (ep === undefined) {
+            throw new Error("End point missing");
+        }
+        if (sp.equals(ep)) {
+            throw new Error("Start point and End point are equal");
+        }
+        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
+        if (detailLevelToDividerNameToPos.size === 0) {
+            throw new Error("Dividers missing");
+        }
+        if (detailLevelNodeName3D === undefined && detailLevelNodeName2D === undefined) {
+            throw new Error("Details level node name missing");
+        }
+        let detailLevelGfxMode = SymGfxMode.undefined;
+        let dividerNameToPos;
+        if (detailLevelNodeName3D !== undefined) {
+            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName3D);
+            if (dividerNameToPos !== undefined) {
+                detailLevelGfxMode = SymGfxMode.x3D;
+            }
+        }
+        if (dividerNameToPos === undefined && detailLevelNodeName2D !== undefined) {
+            dividerNameToPos = detailLevelToDividerNameToPos.get(detailLevelNodeName2D);
+            if (dividerNameToPos !== undefined) {
+                detailLevelGfxMode = SymGfxMode.x2D;
+            }
+        }
+        if (dividerNameToPos === undefined) {
+            throw new Error("Dividers for detail level missing");
+        }
+        const processedSections = CfgStretchData.processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal);
+        return new this(detailLevel, measureParam, stretchSymNodeId, originalLength, sp, ep, spToEpLength, spToEpLength, normal, normalizedNormal, processedSections);
+    }
+    static processSections(sections, detailLevel, detailLevelGfxMode, dividerNameToPos, sp, spToEpLength, normalizedNormal) {
+        // The morph target shall morph to making the morphed thing
+        // twice as long as before morph, that is, 100% increase.
+        // The sizeChange parameters are assumed to aggregate to 1.
+        // The alongness goes from 0 at sp to 1 at ep. So summing these
+        // should make the postStretchEndAlongness of the last one be 2.
+        let accumulatedSizeChange = 0;
+        let startAlongness = 0;
+        let atTwiceStartAlongness = 0;
+        return sections.map((section, sectionIndex) => {
+            const { move, sizeChange, gfxModeToDetailLevelToMultiSelector } = section;
+            const sectionsLength = sections.length;
+            if (sectionsLength < 1) {
+                throw new Error("At lease one section needed for stretch");
+            }
+            const first = sectionIndex === 0;
+            const last = sectionIndex === sectionsLength - 1;
+            const detailLevelToMultiSelector = gfxModeToDetailLevelToMultiSelector.get(detailLevelGfxMode);
+            if (detailLevelToMultiSelector === undefined) {
+                throw new Error("No x3D or x2D for section");
+            }
+            const multiSelector = detailLevelToMultiSelector.get(detailLevel);
+            if (multiSelector === undefined) {
+                throw new Error("No multiSelector for detail level");
+            }
+            const selectors = multiSelector.selectors;
+            const selectorsLength = selectors.length;
+            if ((first || last ? 1 : 2) !== selectorsLength) {
+                throw new Error("Divider plane count expected to be 1 for first or last and 2 for others");
+            }
+            let endAlongness;
+            if (last) {
+                endAlongness = 1;
+            }
+            else {
+                const dividerId = selectors[selectorsLength - 1].dividerId;
+                const pos = dividerNameToPos.get(dividerId);
+                if (pos === undefined) {
+                    throw new Error("No position found for symDividerSelector");
+                }
+                endAlongness = calculateAlongness(pos, sp, spToEpLength, normalizedNormal);
+            }
+            accumulatedSizeChange += sizeChange;
+            const atTwiceEndAlongness = endAlongness + accumulatedSizeChange;
+            const result = {
+                last,
+                move,
+                sizeChange,
+                startAlongness,
+                endAlongness,
+                atTwiceTranslation: move && 0 < sectionIndex
+                    ? atTwiceEndAlongness - endAlongness
+                    : atTwiceStartAlongness - startAlongness,
+                atTwiceScale: move
+                    ? 0
+                    : (atTwiceEndAlongness - atTwiceStartAlongness) /
+                        (endAlongness - startAlongness) -
+                        1,
+            };
+            startAlongness = endAlongness;
+            atTwiceStartAlongness = atTwiceEndAlongness;
+            return result;
+        });
+    }
+    get hash() {
+        if (this._hash === undefined) {
+            this._hash = hashCode(`${this.detailLevel}-${this.measureParam}-${this.sp.asArray().join(",")}-${this.ep
+                .asArray()
+                .join(",")}-${this.originalSpToEpLength}-${this.sections
+                .map((section) => `${section.startAlongness}-${section.endAlongness}-${section.move ? "Y" : "N"}-${section.sizeChange}`)
+                .join(",")}`);
+        }
+        return this._hash;
+    }
+    /**
+     * If the Matrix is identity the original CfgStretchData is returned.
+     * If not a new CfgStretchData will be created.
+     * sp, ep, spToEpLength, normal, normalNormalized, scale will be cloned and transformed
+     * The rest will still reference the original objects
+     */
+    applyMatrix(matrix) {
+        if (matrix.isIdentity()) {
+            return this;
+        }
+        const sp = Vector3.TransformCoordinates(this.sp, matrix);
+        const ep = Vector3.TransformCoordinates(this.ep, matrix);
+        const { spToEpLength, normal, normalizedNormal } = calculateNormals(sp, ep);
+        return new CfgStretchData(this.detailLevel, this.measureParam, this.stretchSymNodeId, this.originalReferenceLength, sp, ep, spToEpLength, this.spToEpLength, normal, normalizedNormal, this.sections);
+    }
+    /**
+     * Calculates the translation of a point which moves it from its original position to where it
+     * would be if we stretched to twice the reference length. Please note: this gives the
+     * translation, not the new location. The new location will be p.add(stretchPointToTwice(p))
+     */
+    stretchPointToTwice(p) {
+        const alongness = this.getAlongness(p);
+        const { sections, normal } = this;
+        for (const section of sections) {
+            const endAlongness = section.endAlongness;
+            if (section.last || alongness <= endAlongness) {
+                let translation = section.atTwiceTranslation;
+                if (!section.move) {
+                    translation += (alongness - section.startAlongness) * section.atTwiceScale;
+                }
+                return normal.scale(translation);
+            }
+        }
+        throw new Error("Should not be possible");
+    }
+    /**
+     * Given a reference length calculates the influence that should be applied to a MorphTarget to
+     * achieve the requested length, given that these MorphTargets are constructed so that they
+     * will double the length when the influence 1 is applied.
+     *
+     * Please note that the referenceLength is the wanted length between sp and ep, that is, the
+     * stretch line. This line does not have to be span the entire model. Also, there can be
+     * multiple stretch lines that are not orthogonal to this, and the will also affect the actual
+     * size. Finally there can be transforms applied in the tree. So, the referenceLength will only
+     * be the actual length of the model in specific cases. However, we believe that models with
+     * stretch are often constructed in such a way that in real use cases the referenceLength is
+     * the actual real length.
+     */
+    calculateInfluenceGivenTwiceMorphTarget(referenceLength) {
+        const { originalSpToEpLength } = this;
+        if (referenceLength.length === 0) {
+            // CET considers 0 as a no-value and will return the stretch to the default value.
+            // If this changes, remove this workaround.
+            return 0;
+        }
+        return ((convertLength(referenceLength.length, referenceLength.unit, MESH_UNIT) -
+            originalSpToEpLength) /
+            originalSpToEpLength);
+    }
+}