@itwin/core-geometry 4.7.0-dev.6 → 4.7.0-dev.8

package/lib/esm/serialization/IModelJsonSchema.js

@@ -5,6 +5,7 @@
 /** @packageDocumentation
  * @module Serialization
  */
+import { assert } from "@itwin/core-bentley";
 import { AkimaCurve3d } from "../bspline/AkimaCurve3d";
 import { BSplineCurve3d } from "../bspline/BSplineCurve";
 import { BSplineCurve3dH } from "../bspline/BSplineCurve3dH";
@@ -340,24 +341,6 @@ export var IModelJson;
             }
             return undefined;
         }
-        // For each nonzero index, Announce Math.abs (value) -1
-        static addZeroBasedIndicesFromSignedOneBased(data, numPerFace, f) {
-            if (data && Geometry.isNumberArray(data)) {
-                if (numPerFace > 1) {
-                    // all indices are used ...
-                    for (const value of data) {
-                        f(Math.abs(value) - 1);
-                    }
-                }
-                else {
-                    // ignore separator zeros ...
-                    for (const value of data) {
-                        if (value !== 0)
-                            f(Math.abs(value) - 1);
-                    }
-                }
-            }
-        }
         /** parse polyface aux data content to PolyfaceAuxData instance */
         static parsePolyfaceAuxData(data = undefined, numPerFace = 0) {
             if (!Array.isArray(data.channels) || !Array.isArray(data.indices))
@@ -374,7 +357,7 @@ export var IModelJson;
                 }
             }
             const auxData = new PolyfaceAuxData(outChannels, []);
-            Reader.addZeroBasedIndicesFromSignedOneBased(data.indices, numPerFace, (x) => { auxData.indices.push(x); });
+            SerializationHelpers.announceZeroBasedIndicesFromSignedOneBasedIndices(data.indices, numPerFace, (x) => { auxData.indices.push(x); });
             return auxData;
         }
         /** parse indexed mesh content to an IndexedPolyface instance */
@@ -384,74 +367,49 @@ export var IModelJson;
             if (data.hasOwnProperty("point") && Array.isArray(data.point)
                 && data.hasOwnProperty("pointIndex") && Array.isArray(data.pointIndex)) {
                 const polyface = IndexedPolyface.create();
-                if (data.hasOwnProperty("normal") && Array.isArray(data.normal)) {
-                    // for normals, addNormal() is overeager to detect the (common) case of duplicate normals in sequence.
-                    // use addNormalXYZ which always creates a new one.
-                    // likewise for params
-                    for (const uvw of data.normal) {
-                        if (Geometry.isNumberArray(uvw, 3))
-                            polyface.addNormalXYZ(uvw[0], uvw[1], uvw[2]);
-                    }
-                }
+                const numPerFace = data.hasOwnProperty("numPerFace") ? data.numPerFace : 0;
                 if (data.hasOwnProperty("twoSided")) {
                     const q = data.twoSided;
                     if (q === true || q === false) {
                         polyface.twoSided = q;
                     }
                 }
-                const numPerFace = data.hasOwnProperty("numPerFace") ? data.numPerFace : 0;
                 if (data.hasOwnProperty("expectedClosure")) {
                     const q = data.expectedClosure;
                     if (Number.isFinite(q)) {
                         polyface.expectedClosure = q;
                     }
                 }
-                if (data.hasOwnProperty("param") && Array.isArray(data.param)) {
+                if (data.hasOwnProperty("normal") && Array.isArray(data.normal) && data.hasOwnProperty("normalIndex")) {
+                    // For normals, addNormal() is overeager to detect the (common) case of duplicate normals in sequence.
+                    // Use addNormalXYZ which always creates a new one. Likewise for params.
+                    for (const uvw of data.normal) {
+                        if (Geometry.isNumberArray(uvw, 3))
+                            polyface.addNormalXYZ(uvw[0], uvw[1], uvw[2]);
+                    }
+                    SerializationHelpers.announceZeroBasedIndicesFromSignedOneBasedIndices(data.normalIndex, numPerFace, (x) => { polyface.addNormalIndex(x); });
+                }
+                if (data.hasOwnProperty("param") && Array.isArray(data.param) && data.hasOwnProperty("paramIndex")) {
                     for (const uv of data.param) {
                         if (Geometry.isNumberArray(uv, 2))
                             polyface.addParamUV(uv[0], uv[1]);
                     }
+                    SerializationHelpers.announceZeroBasedIndicesFromSignedOneBasedIndices(data.paramIndex, numPerFace, (x) => { polyface.addParamIndex(x); });
                 }
-                if (data.hasOwnProperty("color") && Array.isArray(data.color)) {
-                    for (const c of data.color) {
+                if (data.hasOwnProperty("color") && Array.isArray(data.color) && data.hasOwnProperty("colorIndex")) {
+                    for (const c of data.color)
                         polyface.addColor(c);
-                    }
+                    SerializationHelpers.announceZeroBasedIndicesFromSignedOneBasedIndices(data.colorIndex, numPerFace, (x) => { polyface.addColorIndex(x); });
                 }
                 for (const p of data.point)
                     polyface.addPointXYZ(p[0], p[1], p[2]);
-                if (numPerFace > 1) {
-                    for (let i = 0; i < data.pointIndex.length; i++) {
-                        const p = data.pointIndex[i];
-                        const p0 = Math.abs(p) - 1;
-                        polyface.addPointIndex(p0, p > 0);
-                        if ((i + 1) % numPerFace === 0)
-                            polyface.terminateFacet(false);
-                    }
-                }
-                else {
-                    for (const p of data.pointIndex) {
-                        if (p === 0)
-                            polyface.terminateFacet(false); // we are responsible for index checking !!!
-                        else {
-                            const p0 = Math.abs(p) - 1;
-                            polyface.addPointIndex(p0, p > 0);
-                        }
-                    }
-                }
-                if (data.hasOwnProperty("normalIndex")) {
-                    Reader.addZeroBasedIndicesFromSignedOneBased(data.normalIndex, numPerFace, (x) => { polyface.addNormalIndex(x); });
-                }
-                if (data.hasOwnProperty("paramIndex")) {
-                    Reader.addZeroBasedIndicesFromSignedOneBased(data.paramIndex, numPerFace, (x) => { polyface.addParamIndex(x); });
-                }
-                if (data.hasOwnProperty("colorIndex")) {
-                    Reader.addZeroBasedIndicesFromSignedOneBased(data.colorIndex, numPerFace, (x) => { polyface.addColorIndex(x); });
-                }
+                SerializationHelpers.announceZeroBasedIndicesFromSignedOneBasedIndices(data.pointIndex, numPerFace, (i, v) => { polyface.addPointIndex(i, v); }, () => { polyface.terminateFacet(false); });
+                if (!polyface.validateAllIndices())
+                    return undefined;
                 if (data.hasOwnProperty("auxData"))
                     polyface.data.auxData = Reader.parsePolyfaceAuxData(data.auxData, numPerFace);
-                if (data.hasOwnProperty("tags")) {
+                if (data.hasOwnProperty("tags"))
                     polyface.data.taggedNumericData = Reader.parseTaggedNumericProps(data.tags);
-                }
                 return polyface;
             }
             return undefined;
@@ -1107,28 +1065,18 @@ export var IModelJson;
             return out;
         }
         handlePolyfaceAuxData(auxData, pf) {
-            const contents = {};
-            contents.indices = [];
+            assert(auxData === pf.data.auxData);
+            const contents = { indices: [], channels: [] };
             const visitor = pf.createVisitor(0);
-            if (!visitor.auxData)
-                return;
             while (visitor.moveToNextFacet()) {
-                for (let i = 0; i < visitor.indexCount; i++) {
+                for (let i = 0; i < visitor.indexCount; i++)
                     contents.indices.push(visitor.auxData.indices[i] + 1);
-                }
                 contents.indices.push(0); // facet terminator.
             }
-            contents.channels = [];
             for (const inChannel of auxData.channels) {
-                const outChannel = {};
-                outChannel.dataType = inChannel.dataType;
-                outChannel.name = inChannel.name;
-                outChannel.inputName = inChannel.inputName;
-                outChannel.data = [];
+                const outChannel = { data: [], dataType: inChannel.dataType, name: inChannel.name, inputName: inChannel.inputName };
                 for (const inData of inChannel.data) {
-                    const outData = {};
-                    outData.input = inData.input;
-                    outData.values = inData.values.slice(0);
+                    const outData = { input: inData.input, values: inData.values.slice(0) };
                     outChannel.data.push(outData);
                 }
                 contents.channels.push(outChannel);