@cognite/reveal-components 1.0.2 → 1.48552.0

package/dist/domains/primitives/cylinder/CylinderView.js

@@ -1,185 +1,385 @@
-import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
-import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
-import { Quantity as n } from "../../../foundation/domainObjectsHelpers/Quantity.js";
-import { PrimitiveType as r } from "../../../foundation/utilities/primitives/PrimitiveType.js";
-import { BoxFace as i } from "../common/BoxFace.js";
-import { Range1 as a } from "../../../foundation/utilities/geometry/Range1.js";
-import { Cylinder as o } from "../../../foundation/utilities/primitives/Cylinder.js";
-import { VIEWER_TO_CDF_TRANSFORMATION as s, convertFromViewerCoordinates as c } from "../../../foundation/renderTarget/convertCoordinates.js";
-import { CylinderUtils as l } from "../../../foundation/utilities/primitives/CylinderUtils.js";
-import { GroupThreeView as u } from "../../../foundation/views/GroupThreeView.js";
-import { PrimitivePickInfo as d } from "../common/PrimitivePickInfo.js";
-import { createSprite as f, rotateEdgeCircle as p, updateLineSegmentsMaterial as m, updateMarkerMaterial as h, updateSolidMaterial as g, updateWireframeMaterial as _ } from "../box/BoxView.js";
-import { CircleGeometry as v, LineBasicMaterial as y, LineSegments as b, Mesh as x, MeshPhongMaterial as S, RingGeometry as C } from "three";
-import { CDF_TO_VIEWER_TRANSFORMATION as w, Vector3Pool as T } from "@cognite/reveal";
-import { LineMaterial as E } from "three/examples/jsm/lines/LineMaterial.js";
-import { Wireframe as D } from "three/examples/jsm/lines/Wireframe.js";
-//#region libs/shared/reveal-components/src/domains/primitives/cylinder/CylinderView.ts
-var O = .2, k = .9, A = new a(.4, .7), j = 32, M = 1.1, N = .99, P = "HeightLabel", F = "DiameterLabelA", I = "DiameterLabelB", L = 100, R = 101, z = class extends u {
-	get style() {
-		return super.style;
-	}
-	update(t) {
-		super.update(t), t.isChanged(e.selected, e.focus, e.renderStyle, e.color, e.unit) && (this.removeChildren(), this.invalidateBoundingBox(), this.invalidateRenderTarget());
-	}
-	beforeRender(e) {
-		super.beforeRender(e), !this.isEmpty && this.updateLabels(e);
-	}
-	get useDepthTest() {
-		let { domainObject: e } = this;
-		return e.focusType === t.Pending || e.isSelected ? !1 : this.style.depthTest;
-	}
-	addChildren() {
-		let { domainObject: e, style: t } = this, n = this.getMatrix(), { focusType: r } = e;
-		t.showSolid && this.addChild(this.createSolid(n)), t.showLines && (t.getLineWidth(e.isSelected) === 1 ? this.addChild(this.createLines(n)) : this.addChild(this.createWireframe(n))), B(r) && (e.canMoveCaps && (this.addChild(this.createRotationRing(n, new i(2))), this.addChild(this.createRotationRing(n, new i(5)))), this.addEdgeCircles(n)), t.showLabel && this.addLabels();
-	}
-	intersectIfCloser(e, n) {
-		let { domainObject: r } = this;
-		if (r.focusType === t.Pending) return;
-		let { cylinder: a } = r, o = H(a.centerA), s = H(a.centerB);
-		o.applyMatrix4(w), s.applyMatrix4(w);
-		let l = e.raycaster.ray, u = a.intersectRay(l, w);
-		if (u === void 0) return;
-		let f = this.getMatrix(), p = u.distanceTo(l.origin);
-		if (n !== void 0 && n < p || r.hasClippingInIntersection && !e.isVisible(u)) return;
-		let m = H(u).applyMatrix4(f.invert()), h = new i().fromPositionAtFace(m), g = c(u), _ = this.getPickedFocusType(g, h), v = {
-			type: "customObject",
-			point: u,
-			distanceToCamera: p,
-			userData: new d(h, _),
-			customObject: this,
-			domainObject: r
-		};
-		return this.shouldPickBoundingBox && (v.boundingBox = this.boundingBox), v;
-	}
-	getFaceRadius() {
-		return this.domainObject.cylinder.radius / 2;
-	}
-	getMatrix() {
-		let { domainObject: e } = this, t = e.cylinder.getMatrix();
-		return t.premultiply(w), t;
-	}
-	createSolid(e) {
-		let { domainObject: t } = this, { style: n } = this, r = new S();
-		g(r, t, n);
-		let i = l.createUnitGeometry();
-		i.applyMatrix4(s);
-		let a = new x(i, r);
-		return a.renderOrder = L, a.applyMatrix4(e), a;
-	}
-	createLines(e) {
-		let { domainObject: t } = this, { style: n } = this, r = new y();
-		m(r, t, n, this.useDepthTest);
-		let i = l.createLineSegmentsBufferGeometry(), a = new b(i, r);
-		return a.renderOrder = L, a.applyMatrix4(e), a;
-	}
-	createWireframe(e) {
-		let { domainObject: t } = this, { style: n } = this, r = new E();
-		_(r, t, n, this.useDepthTest);
-		let i = l.createLineSegmentsGeometry(), a = new D(i, r);
-		return a.renderOrder = L, a.applyMatrix4(e), a;
-	}
-	createRotationRing(e, n) {
-		if (!U(n)) return;
-		let { domainObject: r } = this, { focusType: i } = r, a = this.getFaceRadius(), o = A.max * 2 * a, s = A.min * 2 * a, c = new C(s, o, j), l = new S();
-		h(l, i === t.Rotation, this.useDepthTest);
-		let u = new x(c, l);
-		u.renderOrder = L;
-		let d = n.getCenter(H());
-		d.applyMatrix4(e), u.position.copy(d);
-		let f = r.cylinder.getRotationMatrix();
-		return f.premultiply(w), p(u, n, f), u;
-	}
-	createEdgeCircle(e, t, n) {
-		let { domainObject: r } = this, i = 2 * O * this.getFaceRadius(), a = new v(i, j);
-		t.transparent = !0, t.depthWrite = !1;
-		let o = new x(a, t);
-		o.renderOrder = L;
-		let s = n.getCenter(H());
-		s.applyMatrix4(e), o.position.copy(s);
-		let c = r.cylinder.getRotationMatrix();
-		return c.premultiply(w), p(o, n, c), o;
-	}
-	addEdgeCircles(e) {
-		let { domainObject: n } = this, r = n.focusFace;
-		this.domainObject.focusType !== t.Face && (r = void 0);
-		let a = new S();
-		h(a, !1, this.useDepthTest);
-		for (let t of i.getAllFaces()) U(t) && (r === void 0 || !r.equals(t)) && this.addChild(this.createEdgeCircle(e, a, t));
-		if (r !== void 0 && U(r)) {
-			let t = new S();
-			h(t, !0, this.useDepthTest), this.addChild(this.createEdgeCircle(e, t, r));
-		}
-	}
-	addLabels() {
-		let e = this.domainObject.primitiveType;
-		(e === r.Diameter || e === r.VerticalCylinder || e === r.HorizontalCircle || e === r.HorizontalCylinder) && (this.addChild(this.createDiameterLabel(I)), this.addChild(this.createDiameterLabel(F))), (e === r.VerticalCylinder || e === r.HorizontalCylinder) && this.addChild(this.createHeightLabel(P));
-	}
-	createDiameterLabel(e) {
-		let { cylinder: t } = this.domainObject;
-		if (t.radius < o.MinSize * N) return;
-		let n = this.getDiameterLabelHeight();
-		return this.createLabel(e, t.diameter, n);
-	}
-	createHeightLabel(e) {
-		let t = this.domainObject.cylinder.height;
-		if (t < o.MinSize * N) return;
-		let n = this.getHeightLabelHeight();
-		return this.createLabel(e, t, n);
-	}
-	getDiameterLabelHeight() {
-		let { style: e, domainObject: t } = this;
-		return 2 * e.relativeTextSize * t.cylinder.diameter;
-	}
-	getHeightLabelHeight() {
-		let { style: e, domainObject: t } = this;
-		return 2 * e.relativeTextSize * t.cylinder.height;
-	}
-	createLabel(e, t, r) {
-		let i = this.getUnitSystem().toStringWithUnit(t, n.Length), a = f(i, this.style, r);
-		return a.name = e, a.renderOrder = R, a;
-	}
-	updateLabels(e) {
-		let t = this._group.getObjectByName(F), n = this._group.getObjectByName(I), r = this._group.getObjectByName(P);
-		if (t === void 0 && n === void 0 && r === void 0) return;
-		let { cylinder: i } = this.domainObject, a = H(i.centerA), o = H(i.centerB);
-		a.applyMatrix4(w), o.applyMatrix4(w);
-		let s = H().subVectors(o, a).normalize(), c = e.getWorldPosition(H());
-		if (t !== void 0 && l(a, t, -1, this.getDiameterLabelHeight()), n !== void 0 && l(o, n, 1, this.getDiameterLabelHeight()), r !== void 0) {
-			let e = H().addVectors(a, o).multiplyScalar(.5);
-			r !== void 0 && u(e, r);
-		}
-		function l(e, t, n, r) {
-			let a = H().subVectors(e, c).normalize();
-			if (t.visible = Math.sign(s.dot(a)) !== n, !t.visible) return;
-			let o = H().crossVectors(a, s).normalize(), l = H(e).addScaledVector(o, .5 * i.radius);
-			l.addScaledVector(s, .5 * n * M * r), t.position.copy(l);
-		}
-		function u(e, t) {
-			let n = H().subVectors(e, c).normalize(), r = H().crossVectors(n, s).normalize(), a = H().crossVectors(r, s).normalize();
-			t.position.copy(e), t.position.addScaledVector(a, i.radius), t.visible = !0;
-		}
-	}
-	getPickedFocusType(e, n) {
-		let { domainObject: i } = this, a = H().setScalar(this.getFaceRadius()), o = i.cylinder.getScaledMatrix(a);
-		o.invert();
-		let s = H(e).applyMatrix4(o), c = n.getPlanePoint(s).length() / 2;
-		return !U(n) || c < O ? t.Face : i.canMoveCaps && A.isInside(c) ? t.Rotation : c > k && i.primitiveType === r.HorizontalCircle ? (n.face = 0, t.Face) : t.Body;
-	}
-};
-function B(e) {
-	switch (e) {
-		case t.Pending:
-		case t.None: return !1;
-		default: return !0;
-	}
+import { Mesh, MeshPhongMaterial, LineSegments, LineBasicMaterial, RingGeometry, CircleGeometry } from "three";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial.js";
+import { Wireframe } from "three/examples/jsm/lines/Wireframe.js";
+import { CDF_TO_VIEWER_TRANSFORMATION, Vector3Pool } from "@cognite/reveal";
+import { Changes } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { Quantity } from "../../../foundation/domainObjectsHelpers/Quantity.js";
+import { convertFromViewerCoordinates, VIEWER_TO_CDF_TRANSFORMATION } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { Range1 } from "../../../foundation/utilities/geometry/Range1.js";
+import { Cylinder } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { CylinderUtils } from "../../../foundation/utilities/primitives/CylinderUtils.js";
+import { PrimitiveType } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { GroupThreeView } from "../../../foundation/views/GroupThreeView.js";
+import { rotateEdgeCircle, updateWireframeMaterial, updateLineSegmentsMaterial, updateMarkerMaterial, updateSolidMaterial, createSprite } from "../box/BoxView.js";
+import { BoxFace } from "../common/BoxFace.js";
+import { PrimitivePickInfo } from "../common/PrimitivePickInfo.js";
+const RELATIVE_RESIZE_RADIUS = 0.2;
+const RELATIVE_MAX_RADIUS = 0.9;
+const RELATIVE_ROTATION_RADIUS = new Range1(0.4, 0.7);
+const CIRCULAR_SEGMENTS = 32;
+const LABEL_PADDING_FACTOR = 1.1;
+const SMALL_SIZE_TOLERANCE_FACTOR = 0.99;
+const HEIGHT_LABEL = 'HeightLabel';
+const DIAMETER_LABEL_A = 'DiameterLabelA';
+const DIAMETER_LABEL_B = 'DiameterLabelB';
+const RENDER_ORDER = 100;
+const LABEL_RENDER_ORDER = 101;
+export class CylinderView extends GroupThreeView {
+    // ==================================================
+    // INSTANCE PROPERTIES
+    // ==================================================
+    get style() {
+        return super.style;
+    }
+    // ==================================================
+    // OVERRIDES of BaseView
+    // ==================================================
+    update(change) {
+        super.update(change);
+        if (change.isChanged(Changes.selected, Changes.focus, Changes.renderStyle, Changes.color, Changes.unit)) {
+            this.removeChildren();
+            this.invalidateBoundingBox();
+            this.invalidateRenderTarget();
+        }
+    }
+    // ==================================================
+    // OVERRIDES of ThreeView
+    // ==================================================
+    beforeRender(camera) {
+        super.beforeRender(camera);
+        if (this.isEmpty) {
+            return;
+        }
+        this.updateLabels(camera);
+    }
+    // ==================================================
+    // OVERRIDES of GroupThreeView
+    // ==================================================
+    // TODO(BND3D-6342): Need to rename useDepthTest to hasDepthTest in Reveal
+    // eslint-disable-next-line @eslint-react/hooks-extra/no-unnecessary-use-prefix -- this in an implementation detail of an interface in Reveal, it requires an update to Reveal first
+    get useDepthTest() {
+        const { domainObject } = this;
+        if (domainObject.focusType === FocusType.Pending || domainObject.isSelected) {
+            return false;
+        }
+        return this.style.depthTest;
+    }
+    addChildren() {
+        const { domainObject, style } = this;
+        const matrix = this.getMatrix();
+        const { focusType } = domainObject;
+        if (style.showSolid) {
+            this.addChild(this.createSolid(matrix));
+        }
+        if (style.showLines) {
+            if (style.getLineWidth(domainObject.isSelected) === 1) {
+                this.addChild(this.createLines(matrix));
+            } else {
+                this.addChild(this.createWireframe(matrix));
+            }
+        }
+        if (showMarkers(focusType)) {
+            if (domainObject.canMoveCaps) {
+                this.addChild(this.createRotationRing(matrix, new BoxFace(2)));
+                this.addChild(this.createRotationRing(matrix, new BoxFace(5)));
+            }
+            this.addEdgeCircles(matrix);
+        }
+        if (style.showLabel) {
+            this.addLabels();
+        }
+    }
+    intersectIfCloser(intersectInput, closestDistance) {
+        const { domainObject } = this;
+        if (domainObject.focusType === FocusType.Pending) {
+            return undefined; // Should never be picked
+        }
+        const { cylinder } = domainObject;
+        const centerA = newVector3(cylinder.centerA);
+        const centerB = newVector3(cylinder.centerB);
+        centerA.applyMatrix4(CDF_TO_VIEWER_TRANSFORMATION);
+        centerB.applyMatrix4(CDF_TO_VIEWER_TRANSFORMATION);
+        const ray = intersectInput.raycaster.ray;
+        const point = cylinder.intersectRay(ray, CDF_TO_VIEWER_TRANSFORMATION);
+        if (point === undefined) {
+            return undefined;
+        }
+        const matrix = this.getMatrix();
+        const distanceToCamera = point.distanceTo(ray.origin);
+        if (closestDistance !== undefined && closestDistance < distanceToCamera) {
+            return undefined;
+        }
+        if (domainObject.hasClippingInIntersection && !intersectInput.isVisible(point)) {
+            return undefined;
+        }
+        const positionAtFace = newVector3(point).applyMatrix4(matrix.invert());
+        const boxFace = new BoxFace().fromPositionAtFace(positionAtFace);
+        const cdfPosition = convertFromViewerCoordinates(point);
+        const focusType = this.getPickedFocusType(cdfPosition, boxFace);
+        const customObjectIntersection = {
+            type: 'customObject',
+            point,
+            distanceToCamera,
+            userData: new PrimitivePickInfo(boxFace, focusType),
+            customObject: this,
+            domainObject
+        };
+        if (this.shouldPickBoundingBox) {
+            customObjectIntersection.boundingBox = this.boundingBox;
+        }
+        return customObjectIntersection;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Getters
+    // ==================================================
+    getFaceRadius() {
+        return this.domainObject.cylinder.radius / 2;
+    }
+    getMatrix() {
+        const { domainObject } = this;
+        const matrix = domainObject.cylinder.getMatrix();
+        matrix.premultiply(CDF_TO_VIEWER_TRANSFORMATION);
+        return matrix;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Create Object3D's
+    // ==================================================
+    createSolid(matrix) {
+        const { domainObject } = this;
+        const { style } = this;
+        const material = new MeshPhongMaterial();
+        updateSolidMaterial(material, domainObject, style);
+        const geometry = CylinderUtils.createUnitGeometry();
+        // In Three.js, the cylinder is oriented along the Y-axis, so we need to rotate it
+        // so up is the Z-axis.
+        geometry.applyMatrix4(VIEWER_TO_CDF_TRANSFORMATION);
+        const mesh = new Mesh(geometry, material);
+        mesh.renderOrder = RENDER_ORDER;
+        mesh.applyMatrix4(matrix);
+        return mesh;
+    }
+    createLines(matrix) {
+        const { domainObject } = this;
+        const { style } = this;
+        const material = new LineBasicMaterial();
+        updateLineSegmentsMaterial(material, domainObject, style, this.useDepthTest);
+        const geometry = CylinderUtils.createLineSegmentsBufferGeometry();
+        const result = new LineSegments(geometry, material);
+        result.renderOrder = RENDER_ORDER;
+        result.applyMatrix4(matrix);
+        return result;
+    }
+    createWireframe(matrix) {
+        const { domainObject } = this;
+        const { style } = this;
+        const material = new LineMaterial();
+        updateWireframeMaterial(material, domainObject, style, this.useDepthTest);
+        const geometry = CylinderUtils.createLineSegmentsGeometry();
+        const result = new Wireframe(geometry, material);
+        result.renderOrder = RENDER_ORDER;
+        result.applyMatrix4(matrix);
+        return result;
+    }
+    createRotationRing(matrix, face) {
+        if (!isFaceVisible(face)) {
+            return undefined;
+        }
+        const { domainObject } = this;
+        const { focusType } = domainObject;
+        const radius = this.getFaceRadius();
+        const outerRadius = RELATIVE_ROTATION_RADIUS.max * 2 * radius;
+        const innerRadius = RELATIVE_ROTATION_RADIUS.min * 2 * radius;
+        const geometry = new RingGeometry(innerRadius, outerRadius, CIRCULAR_SEGMENTS);
+        const material = new MeshPhongMaterial();
+        updateMarkerMaterial(material, focusType === FocusType.Rotation, this.useDepthTest);
+        const result = new Mesh(geometry, material);
+        result.renderOrder = RENDER_ORDER;
+        const center = face.getCenter(newVector3());
+        center.applyMatrix4(matrix);
+        result.position.copy(center);
+        const rotationMatrix = domainObject.cylinder.getRotationMatrix();
+        rotationMatrix.premultiply(CDF_TO_VIEWER_TRANSFORMATION);
+        rotateEdgeCircle(result, face, rotationMatrix);
+        return result;
+    }
+    createEdgeCircle(matrix, material, face) {
+        const { domainObject } = this;
+        const radius = 2 * RELATIVE_RESIZE_RADIUS * this.getFaceRadius();
+        const geometry = new CircleGeometry(radius, CIRCULAR_SEGMENTS);
+        material.transparent = true;
+        material.depthWrite = false;
+        const result = new Mesh(geometry, material);
+        result.renderOrder = RENDER_ORDER;
+        const center = face.getCenter(newVector3());
+        center.applyMatrix4(matrix);
+        result.position.copy(center);
+        const rotationMatrix = domainObject.cylinder.getRotationMatrix();
+        rotationMatrix.premultiply(CDF_TO_VIEWER_TRANSFORMATION);
+        rotateEdgeCircle(result, face, rotationMatrix);
+        return result;
+    }
+    // ==================================================
+    // INSTANCE METHODS: Add Object3D's
+    // ==================================================
+    addEdgeCircles(matrix) {
+        const { domainObject } = this;
+        let selectedFace = domainObject.focusFace;
+        if (this.domainObject.focusType !== FocusType.Face) {
+            selectedFace = undefined;
+        }
+        const material = new MeshPhongMaterial();
+        updateMarkerMaterial(material, false, this.useDepthTest);
+        for (const boxFace of BoxFace.getAllFaces()){
+            if (!isFaceVisible(boxFace)) {
+                continue;
+            }
+            if (selectedFace === undefined || !selectedFace.equals(boxFace)) {
+                this.addChild(this.createEdgeCircle(matrix, material, boxFace));
+            }
+        }
+        if (selectedFace !== undefined && isFaceVisible(selectedFace)) {
+            const material = new MeshPhongMaterial();
+            updateMarkerMaterial(material, true, this.useDepthTest);
+            this.addChild(this.createEdgeCircle(matrix, material, selectedFace));
+        }
+    }
+    // ==================================================
+    // INSTANCE METHODS: Labels
+    // ==================================================
+    addLabels() {
+        const type = this.domainObject.primitiveType;
+        if (type === PrimitiveType.Diameter || type === PrimitiveType.VerticalCylinder || type === PrimitiveType.HorizontalCircle || type === PrimitiveType.HorizontalCylinder) {
+            this.addChild(this.createDiameterLabel(DIAMETER_LABEL_B));
+            this.addChild(this.createDiameterLabel(DIAMETER_LABEL_A));
+        }
+        if (type === PrimitiveType.VerticalCylinder || type === PrimitiveType.HorizontalCylinder) {
+            this.addChild(this.createHeightLabel(HEIGHT_LABEL));
+        }
+    }
+    createDiameterLabel(name) {
+        const { cylinder } = this.domainObject;
+        if (cylinder.radius < Cylinder.MinSize * SMALL_SIZE_TOLERANCE_FACTOR) {
+            return undefined; // Not show when about 0
+        }
+        const labelHeight = this.getDiameterLabelHeight();
+        return this.createLabel(name, cylinder.diameter, labelHeight);
+    }
+    createHeightLabel(name) {
+        const value = this.domainObject.cylinder.height;
+        if (value < Cylinder.MinSize * SMALL_SIZE_TOLERANCE_FACTOR) {
+            return undefined; // Not show when about 0
+        }
+        const labelHeight = this.getHeightLabelHeight();
+        return this.createLabel(name, value, labelHeight);
+    }
+    getDiameterLabelHeight() {
+        const { style, domainObject } = this;
+        return 2 * style.relativeTextSize * domainObject.cylinder.diameter;
+    }
+    getHeightLabelHeight() {
+        const { style, domainObject } = this;
+        return 2 * style.relativeTextSize * domainObject.cylinder.height;
+    }
+    createLabel(name, value, labelHeight) {
+        const text = this.getUnitSystem().toStringWithUnit(value, Quantity.Length);
+        const sprite = createSprite(text, this.style, labelHeight);
+        sprite.name = name;
+        sprite.renderOrder = LABEL_RENDER_ORDER;
+        return sprite;
+    }
+    updateLabels(camera) {
+        const diameterLabelA = this._group.getObjectByName(DIAMETER_LABEL_A);
+        const diameterLabelB = this._group.getObjectByName(DIAMETER_LABEL_B);
+        const heightLabel = this._group.getObjectByName(HEIGHT_LABEL);
+        if (diameterLabelA === undefined && diameterLabelB === undefined && heightLabel === undefined) {
+            return;
+        }
+        const { cylinder } = this.domainObject;
+        const centerA = newVector3(cylinder.centerA);
+        const centerB = newVector3(cylinder.centerB);
+        centerA.applyMatrix4(CDF_TO_VIEWER_TRANSFORMATION);
+        centerB.applyMatrix4(CDF_TO_VIEWER_TRANSFORMATION);
+        const axis = newVector3().subVectors(centerB, centerA).normalize();
+        const cameraPosition = camera.getWorldPosition(newVector3());
+        if (diameterLabelA !== undefined) {
+            updateDiameterLabel(centerA, diameterLabelA, -1, this.getDiameterLabelHeight());
+        }
+        if (diameterLabelB !== undefined) {
+            updateDiameterLabel(centerB, diameterLabelB, 1, this.getDiameterLabelHeight());
+        }
+        if (heightLabel !== undefined) {
+            const center = newVector3().addVectors(centerA, centerB).multiplyScalar(0.5);
+            if (heightLabel !== undefined) {
+                updateHeightLabel(center, heightLabel);
+            }
+        }
+        function updateDiameterLabel(center, label, sign, labelHeight) {
+            const cameraDirection = newVector3().subVectors(center, cameraPosition).normalize();
+            label.visible = Math.sign(axis.dot(cameraDirection)) !== sign; // Show only when the cap is visible
+            if (!label.visible) {
+                return;
+            }
+            const radialDirection = newVector3().crossVectors(cameraDirection, axis).normalize();
+            const position = newVector3(center).addScaledVector(radialDirection, 0.5 * cylinder.radius);
+            position.addScaledVector(axis, 0.5 * sign * LABEL_PADDING_FACTOR * labelHeight);
+            label.position.copy(position);
+        }
+        function updateHeightLabel(center, label) {
+            const cameraDirection = newVector3().subVectors(center, cameraPosition).normalize();
+            const radialDirection = newVector3().crossVectors(cameraDirection, axis).normalize();
+            const forwardDirection = newVector3().crossVectors(radialDirection, axis).normalize();
+            label.position.copy(center);
+            label.position.addScaledVector(forwardDirection, cylinder.radius);
+            label.visible = true;
+        }
+    }
+    getPickedFocusType(realPosition, face) {
+        const { domainObject } = this;
+        const scale = newVector3().setScalar(this.getFaceRadius());
+        const scaledMatrix = domainObject.cylinder.getScaledMatrix(scale);
+        scaledMatrix.invert();
+        const scaledPositionAtFace = newVector3(realPosition).applyMatrix4(scaledMatrix);
+        const planePoint = face.getPlanePoint(scaledPositionAtFace);
+        const relativeDistance = planePoint.length() / 2;
+        if (!isFaceVisible(face)) {
+            return FocusType.Face;
+        }
+        if (relativeDistance < RELATIVE_RESIZE_RADIUS) {
+            return FocusType.Face;
+        }
+        if (domainObject.canMoveCaps && RELATIVE_ROTATION_RADIUS.isInside(relativeDistance)) {
+            return FocusType.Rotation;
+        }
+        if (relativeDistance > RELATIVE_MAX_RADIUS && domainObject.primitiveType === PrimitiveType.HorizontalCircle) {
+            // This makes it possible to pick the face at the edges, so the radius can be changed
+            face.face = 0;
+            return FocusType.Face;
+        }
+        return FocusType.Body;
+    }
 }
-var V = new T();
-function H(e) {
-	return V.getNext(e);
+// ==================================================
+// PRIVATE FUNCTIONS: Update materials
+// ==================================================
+function showMarkers(focusType) {
+    switch(focusType){
+        case FocusType.Pending:
+        case FocusType.None:
+            return false;
+        default:
+            return true;
+    }
 }
-function U(e) {
-	return e.index === 2;
+// ==================================================
+// PRIVATE FUNCTIONS: Vector pool
+// ==================================================
+const VECTOR_POOL = new Vector3Pool();
+function newVector3(copyFrom) {
+    return VECTOR_POOL.getNext(copyFrom);
 }
-//#endregion
-export { z as CylinderView };
+function isFaceVisible(face) {
+    return face.index === 2; // Z Face visible only
+}
+
+//# sourceMappingURL=CylinderView.js.map