@archilogic/floor-plan-sdk 5.0.0-rc.1 → 5.0.0-rc.2

package/dist/fpe.d.ts

@@ -379,7 +379,7 @@ export declare class FloorPlanEngine extends FloorPlanCore {
      */
     off<EventType extends FpeEvent, Context>(event: EventType, handler?: FpeEventHandler<EventType>, ctx?: Context): this;
     emit<EventType extends FpeEvent>(event: EventType, ...args: FpeEventMap[EventType]): this;
-    handleDrop(evt: any): void;
+    handleDrop(evt: DragEvent): void;
     /**
      * Change options after the floor plan engine instance has been created
      * @param args - Startup options
@@ -575,6 +575,13 @@ declare type FpeCoreEventMap = {
 export declare type FpeDragEvent = {
     position: Vector2_2;
     screenPos: Vector2_2;
+    sourceEvent: FpeInteractionEvent;
+};
+
+export declare type FpeDropEvent = {
+    position: Vector2_2;
+    screenPos: Vector2_2;
+    verticalPos: number;
     sourceEvent: DragEvent;
 };
 
@@ -587,9 +594,7 @@ export declare type FpeEventMap = FpeCoreEventMap & {
     dblclick: [event: FpePointerEvent];
     'context-menu': [event: FpePointerEvent];
     mousemove: [event: FpePointerEvent];
-    drop: [event: FpeDragEvent & {
-        verticalPos: number;
-    }];
+    drop: [event: FpeDropEvent];
     'drag-move': [event: FpeDragEvent];
     'drag-start': [event: FpeDragEvent];
     'drag-end': [event: FpeDragEvent];
@@ -629,6 +634,8 @@ declare interface FpeInteraction {
     preventFocusoutOnAltKeyup: boolean;
 }
 
+export declare type FpeInteractionEvent = InteractionEventType[keyof InteractionEventType];
+
 export declare type FpeKeyEvent = {
     key: string;
     lowerCaseKey: string;
@@ -669,10 +676,10 @@ declare class FpeLoader extends TinyEmitter {
 declare type FpeLoader_2 = FloorPlanCore['loader'];
 
 export declare type FpePointerEvent = {
-    sourceEvent: PointerEvent;
     nodeId?: string;
     position: Vector2_2;
     isDoubleClick?: boolean;
+    sourceEvent: FpeInteractionEvent;
 };
 
 declare class GeometryBase extends SpaceGraphNodeBase {
@@ -977,6 +984,10 @@ declare interface InfoWindowState extends InfoWindowArgs {
     floorPlan?: FloorPlanEngine;
 }
 
+declare type InteractionEventType = {
+    dom: MouseEvent;
+};
+
 declare class Layout2dView extends LayoutViewBase {
     type: Layout2dViewType;
     parameters: Layout2dViewParameters;
@@ -2230,6 +2241,7 @@ declare type PolygonCurveType = typeof PolygonCurveTypeValue;
 
 declare const PolygonCurveTypeValue = "curve:polygon";
 
+/** outer ring counter clockwise, inner rings ( holes ) clockwise */
 declare type PolygonWithHoles = Polygon[];
 
 declare interface PolygonWithHolesCurve extends BaseShape {

package/dist/fpe.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 /*!
-  Archilogic Floor Plan Engine SDK v5.0.0-rc.1 webgl build 240712-133126-1d4aa7
+  Archilogic Floor Plan Engine SDK v5.0.0-rc.2 webgl build 240717-162515-eac508
 
   Copyright (c) 2024 Archilogic AG. All rights reserved.
 
@@ -4501,6 +4501,80 @@ function polygonUnion(polygons) {
   );
   return getPolygonsFromClipper(solution_paths);
 }
+function getPolyTreeAndPolygons(polyNode, index = 0, polyTree = [], polygons = [], currentPolygon = []) {
+  for (let child of polyNode.m_Children) {
+    if (!child.m_polygon.length) {
+      continue;
+    }
+    let isHole = index % 2 !== 0;
+    let polygon = getPolygonsFromClipper([child.m_polygon])[0];
+    let node = { polygon, children: [] };
+    polyTree.push(node);
+    if (!isHole) {
+      currentPolygon = [polygon];
+      polygons.push(currentPolygon);
+    } else {
+      currentPolygon.push(polygon);
+    }
+    getPolyTreeAndPolygons(child, index + 1, node.children, polygons, currentPolygon);
+  }
+  polygons.sort((a2, b2) => {
+    let areaA = polygonArea(a2[0]);
+    let areaB = polygonArea(b2[0]);
+    if (areaA > areaB) {
+      return -1;
+    } else {
+      return 1;
+    }
+  });
+  return { polyTree, polygons };
+}
+function polygonWithHolesUnion(polygonLists) {
+  if (!polygonLists.length || !polygonLists[0]) {
+    return { polygons: [], polyTree: [] };
+  }
+  let subj_paths = getClipperPolygons(polygonLists[0]);
+  let clip_paths = polygonLists.slice(1).flatMap(getClipperPolygons);
+  let cpr = new ClipperLib$1.Clipper();
+  cpr.AddPaths(subj_paths, ClipperLib$1.PolyType.ptSubject, true);
+  cpr.AddPaths(clip_paths, ClipperLib$1.PolyType.ptClip, true);
+  let clipperPolyTree = new ClipperLib$1.PolyTree();
+  cpr.Execute(
+    ClipperLib$1.ClipType.ctUnion,
+    clipperPolyTree,
+    ClipperLib$1.PolyFillType.pftNonZero,
+    ClipperLib$1.PolyFillType.pftNonZero
+  );
+  return getPolyTreeAndPolygons(clipperPolyTree);
+}
+function polygonOffset(polygons, delta = 0.1, endType, skipCleaning) {
+  const DEFAULT_DELTA = 0.1;
+  if (!polygons.length || !polygons[0]) {
+    return [];
+  }
+  if (endType === void 0) {
+    endType = ClipperLib$1.EndType.etClosedPolygon;
+  }
+  polygons = cleanPolygons(polygons);
+  delta = delta && typeof delta === "number" ? delta : DEFAULT_DELTA;
+  let _polygons = getClipperPolygons(polygons);
+  let co = new ClipperLib$1.ClipperOffset(2);
+  let solution = [];
+  co.AddPaths(_polygons, ClipperLib$1.JoinType.jtMiter, endType);
+  co.Execute(solution, delta);
+  return getPolygonsFromClipper(solution);
+}
+function polygonWithHolesOffset(polygonLists, delta = 0.1, endType = ClipperLib$1.EndType.etClosedPolygon) {
+  if (!polygonLists.length || !polygonLists[0]) {
+    return { polygons: [], polyTree: [] };
+  }
+  let paths = polygonLists.flatMap(getClipperPolygons);
+  let co = new ClipperLib$1.ClipperOffset(2);
+  co.AddPaths(paths, ClipperLib$1.JoinType.jtMiter, endType);
+  let clipperPolyTree = new ClipperLib$1.PolyTree();
+  co.Execute(clipperPolyTree, delta);
+  return getPolyTreeAndPolygons(clipperPolyTree);
+}
 function polygonDifference(subjectPolygons, clipPolygons, subjectPathOpen) {
   if (!subjectPolygons.length || !subjectPolygons[0]) {
     return [];
@@ -4521,6 +4595,24 @@ function polygonDifference(subjectPolygons, clipPolygons, subjectPathOpen) {
   let result = solution_paths;
   return getPolygonsFromClipper(result);
 }
+function polygonWithHolesDifference(subjectPolygonLists, clipPolygonLists) {
+  if (!subjectPolygonLists.length || !subjectPolygonLists[0]) {
+    return { polygons: [], polyTree: [] };
+  }
+  let subj_paths = subjectPolygonLists.flatMap(getClipperPolygons);
+  let clip_paths = clipPolygonLists.flatMap(getClipperPolygons);
+  let cpr = new ClipperLib$1.Clipper();
+  cpr.AddPaths(subj_paths, ClipperLib$1.PolyType.ptSubject, true);
+  cpr.AddPaths(clip_paths, ClipperLib$1.PolyType.ptClip, true);
+  let clipperPolyTree = new ClipperLib$1.PolyTree();
+  cpr.Execute(
+    ClipperLib$1.ClipType.ctDifference,
+    clipperPolyTree,
+    ClipperLib$1.PolyFillType.pftNonZero,
+    ClipperLib$1.PolyFillType.pftNonZero
+  );
+  return getPolyTreeAndPolygons(clipperPolyTree);
+}
 function pointInPolygon$1(point, polygon, holes = []) {
   let pt2 = new ClipperLib$1.FPoint(point[0], -point[1]);
   let _polygon = getClipperPolygons([polygon])[0];
@@ -6324,6 +6416,9 @@ function vec2Cross(v1, v2) {
 function vec2Dot(v1, v2) {
   return v1[0] * v2[0] + v1[1] * v2[1];
 }
+function vec2Equal(v1, v2, epsilon) {
+  return Math.abs(v1[0] - v2[0]) < epsilon && Math.abs(v1[1] - v2[1]) < epsilon;
+}
 function vec2Length(v2) {
   return Math.sqrt(vec2SqrLength(v2));
 }
@@ -6547,6 +6642,107 @@ function applyPolygonTransform2d(polygon, transform2d) {
     return position;
   });
 }
+const SEGMENT_TARGET$1 = 48;
+const MIN_SEGMENTS$1 = 12;
+function getArcSegmentCount(angleDelta, radius) {
+  let count = Math.ceil(SEGMENT_TARGET$1 / (Math.PI * 2) * angleDelta * radius);
+  const minCount = Math.ceil(MIN_SEGMENTS$1 / (Math.PI * 2) * angleDelta);
+  return Math.max(minCount, count);
+}
+function getArcPoint(angle, radius) {
+  let x2 = radius * Math.cos(angle);
+  let y2 = -radius * Math.sin(angle);
+  return [x2, y2];
+}
+function getArcPoints(angleStart, angleEnd, radius, open = true) {
+  let points = [];
+  let angleDelta = angleEnd - angleStart;
+  let segmentCount = getArcSegmentCount(Math.abs(angleDelta), radius);
+  let angleStep = angleDelta / segmentCount;
+  for (let i2 = 0; i2 < segmentCount; i2++) {
+    let angle = angleStart + i2 * angleStep;
+    let point = getArcPoint(angle, radius);
+    points.push(point);
+  }
+  if (open) {
+    let point = getArcPoint(angleEnd, radius);
+    points.push(point);
+  }
+  return points;
+}
+function getOpenCurvePoints(curve) {
+  let points = [];
+  switch (curve.type) {
+    case "curve:line":
+      points.push(curve.start, curve.end);
+      break;
+    case "curve:arc":
+      let angleStart = Math.PI * curve.startAngle / 180;
+      let angleEnd = Math.PI * curve.endAngle / 180;
+      points = getArcPoints(angleStart, angleEnd, curve.radius);
+      break;
+    case "curve:polyline":
+      points = curve.points;
+      break;
+  }
+  return points;
+}
+function resolveProfile(profile) {
+  let points = [];
+  let segmentRanges = [];
+  switch (profile.type) {
+    case "curve:circle":
+      points = getArcPoints(0, 2 * Math.PI, profile.radius, false);
+      segmentRanges.push({ index: 0, count: points.length });
+      break;
+    case "curve:polygon":
+      points = profile.points;
+      for (let i2 = 0; i2 < points.length; i2++) {
+        segmentRanges.push({ index: i2, count: 1 });
+      }
+      break;
+    case "curve:rectangle":
+      let { dimensions } = profile;
+      let sX = dimensions[0];
+      let sY = dimensions[1];
+      points = [
+        [0, 0],
+        [0, sY],
+        [sX, sY],
+        [sX, 0]
+      ];
+      for (let i2 = 0; i2 < points.length; i2++) {
+        segmentRanges.push({ index: i2, count: 1 });
+      }
+      break;
+    case "curve:composite":
+      const epsilon = 1e-7;
+      let firstPoint;
+      let lastPoint;
+      let segments = profile.segments;
+      for (let i2 = 0; i2 < segments.length; i2++) {
+        let segment = segments[i2];
+        let segmentPoints = getOpenCurvePoints(segment);
+        let p1 = segmentPoints[0];
+        let p2 = segmentPoints[segmentPoints.length - 1];
+        let curveContinuous = i2 === 0 ? true : vec2Equal(p1, lastPoint, epsilon);
+        if (!curveContinuous) {
+          logger$1.warn(`Composite curve segments ${i2} and ${i2 + 1} are not continuous.`);
+        }
+        if (i2 === 0) {
+          firstPoint = p1;
+        }
+        lastPoint = p2;
+        segmentRanges.push({ index: points.length, count: segmentPoints.length - 1 });
+        points.push(...segmentPoints.slice(0, segmentPoints.length - 1));
+      }
+      if (segments.length > 0 && !vec2Equal(lastPoint, firstPoint, epsilon)) {
+        logger$1.warn(`Composite curve not closed.`);
+      }
+      break;
+  }
+  return { points, segmentRanges };
+}
 class LayoutBoundary {
   constructor() {
     this.vertices = [];
@@ -17742,6 +17938,80 @@ function getSpaceObjectAlignedBoundingBox(space) {
     elementIsAxisAligned: false
   };
 }
+function getOpeningShapes(opening, offset = [0, 0]) {
+  let { dimensions } = opening.parameters;
+  let parent = opening.parent;
+  if (!parent)
+    return [];
+  let width = parent.parameters.width;
+  let polygon = [
+    [-offset[0], -offset[1]],
+    [dimensions[0] + offset[0], -offset[1]],
+    [dimensions[0] + offset[0], width + offset[1]],
+    [-offset[0], width + offset[1]]
+  ];
+  let mTransform = getPositionRotationMatrix(
+    opening.position,
+    opening.rotation,
+    [0, 1, 0]
+  );
+  applyTransformMatrix2d(polygon, mTransform);
+  return [
+    {
+      type: "curve:polygon",
+      points: polygon
+    }
+  ];
+}
+function getWallContours(layout) {
+  const offset = 0.01;
+  const walls = layout.elementsByType["element:wall"];
+  const boundaryWalls = layout.elementsByType["element:boundaryWall"];
+  const columns = layout.elementsByType["element:column"];
+  const openings = layout.elementsByType["element:opening"];
+  const openingContours = [];
+  for (const opening of openings) {
+    const shape = getOpeningShapes(opening, [0, offset]);
+    let points = shape[0].points;
+    openingContours.push([points]);
+  }
+  const wallShapes = [];
+  for (const wall of walls) {
+    let { points } = wall.geometryProfile;
+    points = polygonOffset([points], offset)[0];
+    wallShapes.push([points]);
+  }
+  for (const column of columns) {
+    const { profile } = column.parameters;
+    let { points } = resolveProfile(profile);
+    if (profile.type === "curve:rectangle") {
+      const [x2, y2] = profile.dimensions;
+      points = [
+        [-x2 / 2, -y2 / 2],
+        [x2 / 2, -y2 / 2],
+        [x2 / 2, y2 / 2],
+        [-x2 / 2, y2 / 2]
+      ];
+    }
+    points = applyPolygonTransform2d(points, {
+      position: [column.position[0], column.position[2]],
+      rotation: column.rotation
+    });
+    points = polygonOffset([points], offset)[0];
+    wallShapes.push([points]);
+  }
+  for (const boundaryWall of boundaryWalls) {
+    let points = boundaryWall.boundaries[0].geometryProfile;
+    points = polygonOffset([points], offset)[0];
+    wallShapes.push([points]);
+  }
+  let { polygons } = polygonWithHolesUnion(wallShapes);
+  polygons = polygonWithHolesOffset(polygons, -offset).polygons;
+  if (openingContours.length) {
+    polygons = polygonWithHolesDifference(polygons, openingContours).polygons;
+  }
+  return polygons;
+}
 const _FloorPlanCore = class _FloorPlanCore2 {
   constructor({ options = {} } = {}) {
     this.settings = Ve(defaultConfig);
@@ -17797,6 +18067,9 @@ const _FloorPlanCore = class _FloorPlanCore2 {
       computeLayoutGeometry(this.layout);
       createElementGeometries(this.layout);
     }
+    if (this.settings.theme.wallContours) {
+      this.computed.wallContours = getWallContours(this.layout);
+    }
     setTimeout(() => {
       this.loader.emit("spaces-loaded");
     }, 0);
@@ -17860,7 +18133,7 @@ const _FloorPlanCore = class _FloorPlanCore2 {
    * Change options after the floor plan engine instance has been created
    */
   set(args = {}) {
-    var _a, _b, _c, _d, _e2;
+    var _a, _b, _c, _d, _e2, _f, _g, _h, _i;
     const assetsAreHidden = (_a = this.settings.hideElements) == null ? void 0 : _a.includes("element:asset");
     let newSettings = Ve(args);
     if (newSettings.theme)
@@ -17892,6 +18165,11 @@ const _FloorPlanCore = class _FloorPlanCore2 {
     if (this.layout) {
       if (assetsAreHidden && showAssets)
         loadAllAssetResources(this);
+      if (((_f = newSettings.theme) == null ? void 0 : _f.wallContours) && !((_g = this.computed.wallContours) == null ? void 0 : _g.length)) {
+        this.computed.wallContours = getWallContours(this.layout);
+      } else if (!((_h = newSettings.theme) == null ? void 0 : _h.wallContours) && ((_i = this.computed.wallContours) == null ? void 0 : _i.length)) {
+        this.computed.wallContours = [];
+      }
     }
     this.emit("update-settings", this.settings);
   }
@@ -17931,7 +18209,7 @@ const _FloorPlanCore = class _FloorPlanCore2 {
     delete this.utils;
   }
 };
-_FloorPlanCore.version = "5.0.0-rc.1";
+_FloorPlanCore.version = "5.0.0-rc.2";
 let FloorPlanCore = _FloorPlanCore;
 function getDoorAnnotations(node) {
   let {
@@ -18120,31 +18398,6 @@ function getEdgeShapes(edge, style = {}) {
   }
   return shapes;
 }
-function getOpeningShapes(opening) {
-  let { dimensions } = opening.parameters;
-  let parent = opening.parent;
-  if (!parent)
-    return [];
-  let width = parent.parameters.width;
-  let polygon = [
-    [0, 0],
-    [dimensions[0], 0],
-    [dimensions[0], width],
-    [0, width]
-  ];
-  let mTransform = getPositionRotationMatrix(
-    opening.position,
-    opening.rotation,
-    [0, 1, 0]
-  );
-  applyTransformMatrix2d(polygon, mTransform);
-  return [
-    {
-      type: "curve:polygon",
-      points: polygon
-    }
-  ];
-}
 var r$2 = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) }, t$2 = function(r2) {
   return "string" == typeof r2 ? r2.length > 0 : "number" == typeof r2;
 }, n$2 = function(r2, t2, n2) {
@@ -41203,10 +41456,12 @@ function drawNode(node, floorPlan, { ctx, style, container, preview }) {
   } else {
     nodeContainer = new Container();
   }
+  const wallContourTypes = ["element:wall", "element:boundaryWall", "element:column", "spatialGraph:edge"];
   const skipGraphic = settings2.hideElements.includes(node.type) || // conditionally draw edges and floor plan images
   node.type === "spatialGraph:edge" && !settings2.showSpaceDividers || node.type === "spatialGraph:edge" && ((_a = node.element) == null ? void 0 : _a.type) === "element:spaceDivider" || node.type === "element:spaceDivider" && !settings2.showSpaceDividers || node.type === "annotation:floorPlanImage" && !settings2.showFloorPlan || // don't draw 'element:floor' and 'element:ceiling' because we already draw the space
   "space" in node || // skip detached opening elements
-  (node.type === "element:window" || node.type === "element:door") && !node.parent;
+  (node.type === "element:window" || node.type === "element:door") && !node.parent || // skip structural elements if merged wall contours are drawn
+  floorPlan.computed.wallContours.length && wallContourTypes.includes(node.type);
   const zValue = getIndex(node.type);
   nodeContainer.zIndex = zValue || 0;
   if (!skipGraphic) {
@@ -41630,6 +41885,35 @@ const focusHandler = (floorPlan) => {
     false
   );
 };
+function drawWallContours(floorPlan, options) {
+  const { ctx, style } = options;
+  const { wallContours } = floorPlan.computed;
+  const id = "wallContours";
+  const shapes = wallContours.map((polygons) => ({
+    type: "curve:polygonWithHoles",
+    polygons
+  }));
+  let container = ctx.getChildByName(id);
+  if (container) {
+    clearContainer(container);
+  } else {
+    container = new Container();
+    container.name = id;
+  }
+  const zValue = getIndex("element:wall");
+  container.zIndex = zValue || 0;
+  const nodeStyle = getNodeStyle({
+    style,
+    settings: floorPlan.settings,
+    elementType: "element:wall"
+  });
+  const gfx = new Graphics();
+  for (const shape of shapes) {
+    drawShape({ shape, gfx, style: nodeStyle });
+  }
+  container.addChild(gfx);
+  ctx.addChild(container);
+}
 function drawLayout({ floorPlan, update = false }) {
   const { layout, view, settings: settings2 } = floorPlan;
   const { _renderer: renderer, _viewport: viewport } = view;
@@ -41655,6 +41939,9 @@ function drawLayout({ floorPlan, update = false }) {
   for (let edge of layout.spatialGraph.edges) {
     drawNode(edge, floorPlan, drawNodeOptions);
   }
+  if (floorPlan.computed.wallContours.length) {
+    drawWallContours(floorPlan, drawNodeOptions);
+  }
   drawRoomStamps(floorPlan, true);
   view.emit("scene-rendered", { update });
   view.viewportNeedsUpdate = true;