first commit

app/src/modules/builder/geomentries/lines/addLineToScene.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+function addLineToScene(
+    start: Types.Vector3,
+    end: Types.Vector3,
+    colour: Types.Color,
+    userData: Types.UserData,
+    floorPlanGroupLine: Types.RefGroup
+): void {
+
+    //////////  A function that creates and adds lines based on the start, end, and colour from the params, Also adds the userData in the mesh userData  //////////
+
+    const path = new THREE.CatmullRomCurve3([start, end]);
+    const geometry = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+    const material = new THREE.MeshBasicMaterial({ color: colour });
+    const mesh = new THREE.Mesh(geometry, material);
+    floorPlanGroupLine.current.add(mesh);
+
+    mesh.userData.linePoints = userData;
+}
+
+export default addLineToScene;

app/src/modules/builder/geomentries/lines/createAndMoveReferenceLine.ts

@@ -0,0 +1,98 @@
+import * as THREE from "three";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+function createAndMoveReferenceLine(
+    point: Types.Vector3,
+    cursorPosition: Types.Vector3,
+    isSnapped: Types.RefBoolean,
+    ispreSnapped: Types.RefBoolean,
+    line: Types.RefLine,
+    setRefTextUpdate: Types.NumberIncrementState,
+    floorPlanGroup: Types.RefGroup,
+    ReferenceLineMesh: Types.RefMesh,
+    LineCreated: Types.RefBoolean,
+    Tube: Types.RefTubeGeometry,
+    anglesnappedPoint: Types.RefVector3,
+    isAngleSnapped: Types.RefBoolean
+): void {
+
+    //////////  Creating new and maintaining the old reference line and also snap the reference line based on its angle  //////////
+
+    const startPoint = point;
+
+    const dx = cursorPosition.x - startPoint.x;
+    const dz = cursorPosition.z - startPoint.z;
+    let angle = Math.atan2(dz, dx);
+
+    angle = (angle * 180) / Math.PI;
+    angle = (angle + 360) % 360;
+
+    const snapAngles = [0, 90, 180, 270, 360];
+    const snapThreshold = 2.5;
+
+    const closestSnapAngle = snapAngles.reduce((prev, curr) =>
+        Math.abs(curr - angle) < Math.abs(prev - angle) ? curr : prev
+    );
+
+    if (!isSnapped.current && !ispreSnapped.current && line.current.length > 0) {
+        if (Math.abs(closestSnapAngle - angle) <= snapThreshold) {
+            const snappedAngleRad = (closestSnapAngle * Math.PI) / 180;
+            const distance = Math.sqrt(dx * dx + dz * dz);
+            const snappedX = startPoint.x + distance * Math.cos(snappedAngleRad);
+            const snappedZ = startPoint.z + distance * Math.sin(snappedAngleRad);
+
+            if (
+                cursorPosition.distanceTo(
+                    new THREE.Vector3(snappedX, 0.01, snappedZ)
+                ) < 2
+            ) {
+                cursorPosition.set(snappedX, 0.01, snappedZ);
+                isAngleSnapped.current = true;
+                anglesnappedPoint.current = new THREE.Vector3(
+                    snappedX,
+                    0.01,
+                    snappedZ
+                );
+            } else {
+                isAngleSnapped.current = false;
+                anglesnappedPoint.current = null;
+            }
+        } else {
+            isAngleSnapped.current = false;
+            anglesnappedPoint.current = null;
+        }
+    } else {
+        isAngleSnapped.current = false;
+        anglesnappedPoint.current = null;
+    }
+
+    if (!LineCreated.current) {
+        setRefTextUpdate((prevUpdate) => prevUpdate - 1);
+        const path = new THREE.LineCurve3(startPoint, cursorPosition);
+        Tube.current = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+        const material = new THREE.MeshBasicMaterial({ color: CONSTANTS.lineConfig.helperColor });
+        ReferenceLineMesh.current = new THREE.Mesh(Tube.current, material);
+        ReferenceLineMesh.current.name = CONSTANTS.lineConfig.referenceName;
+        ReferenceLineMesh.current.userData = {
+            linePoints: { startPoint, cursorPosition },
+        };
+        floorPlanGroup.current?.add(ReferenceLineMesh.current);
+        LineCreated.current = true;
+    } else {
+        if (ReferenceLineMesh.current) {
+            const path = new THREE.LineCurve3(startPoint, new THREE.Vector3(cursorPosition.x, 0.01, cursorPosition.z));
+            Tube.current = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+
+            if (ReferenceLineMesh.current) {
+                ReferenceLineMesh.current.userData = {
+                    linePoints: { startPoint, cursorPosition },
+                };
+                ReferenceLineMesh.current.geometry.dispose();
+                ReferenceLineMesh.current.geometry = Tube.current;
+            }
+        }
+    }
+}
+
+export default createAndMoveReferenceLine;

app/src/modules/builder/geomentries/lines/deleteLine.ts

@@ -0,0 +1,92 @@
+import { Socket } from "socket.io-client";
+// import { deleteLineApi } from "../../../../services/factoryBuilder/lines/deleteLineApi";
+import * as Types from "../../../../types/world/worldTypes";
+
+import { toast } from 'react-toastify';
+
+function deleteLine(
+    hoveredDeletableLine: Types.RefMesh,
+    onlyFloorlines: Types.RefOnlyFloorLines,
+    lines: Types.RefLines,
+    floorPlanGroupLine: Types.RefGroup,
+    floorPlanGroupPoint: Types.RefGroup,
+    setDeletedLines: any,
+    socket: Socket<any>,
+    projectId?: string
+): void {
+
+    //////////  Deleting a line and the points if they are not connected to any other line  //////////
+
+    if (!hoveredDeletableLine.current) {
+        return;
+    }
+
+    const linePoints = hoveredDeletableLine.current.userData.linePoints;
+    const connectedpoints = [linePoints[0][1], linePoints[1][1]];
+
+    const email = localStorage.getItem('email')
+    const organization = (email!.split("@")[1]).split(".")[0];
+    const userId = localStorage.getItem("userId");
+
+    //REST
+
+    // deleteLineApi(
+    //     organization,
+    //     [
+    //         { "uuid": linePoints[0][1] },
+    //         { "uuid": linePoints[1][1] }
+    //     ]
+    // )
+
+    //SOCKET
+
+    const data = {
+        organization: organization,
+        line: [
+            { "uuid": linePoints[0][1] },
+            { "uuid": linePoints[1][1] }
+        ],
+        socketId: socket.id,
+        projectId,
+        userId
+    }
+
+    socket.emit('v1:Line:delete', data);
+
+
+    onlyFloorlines.current = onlyFloorlines.current.map(floorline =>
+        floorline.filter(line => line[0][1] !== connectedpoints[0] && line[1][1] !== connectedpoints[1])
+    ).filter(floorline => floorline.length > 0);
+
+    lines.current = lines.current.filter(item => item !== linePoints);
+    (<any>hoveredDeletableLine.current.material).dispose();
+    (<any>hoveredDeletableLine.current.geometry).dispose();
+    floorPlanGroupLine.current.remove(hoveredDeletableLine.current);
+    setDeletedLines([linePoints]);
+
+    connectedpoints.forEach((pointUUID) => {
+        let isConnected = false;
+        floorPlanGroupLine.current.children.forEach((line) => {
+            const linePoints = line.userData.linePoints;
+            const uuid1 = linePoints[0][1];
+            const uuid2 = linePoints[1][1];
+            if (uuid1 === pointUUID || uuid2 === pointUUID) {
+                isConnected = true;
+            }
+        });
+
+        if (!isConnected) {
+            floorPlanGroupPoint.current.children.forEach((point: any) => {
+                if (point.uuid === pointUUID) {
+                    (<any>point.material).dispose();
+                    (<any>point.geometry).dispose();
+                    floorPlanGroupPoint.current.remove(point);
+                }
+            });
+        }
+    });
+
+    echo.success("Line Removed!");
+}
+
+export default deleteLine;

app/src/modules/builder/geomentries/lines/distanceText/distanceText.tsx

@@ -0,0 +1,223 @@
+import { useEffect, useState } from "react";
+import { getLines } from "../../../../../services/factoryBuilder/lines/getLinesApi";
+import * as THREE from "three";
+import {
+  useActiveLayer,
+  useDeletedLines,
+  useNewLines,
+  useRoomsState,
+  useToggleView,
+} from "../../../../../store/builder/store";
+import objectLinesToArray from "../lineConvertions/objectLinesToArray";
+import { Html } from "@react-three/drei";
+import { Vector2 } from "three";
+import * as Types from "../../../../../types/world/worldTypes";
+import getRoomsFromLines from "../getRoomsFromLines";
+import * as turf from '@turf/turf';
+import { useParams } from "react-router-dom";
+
+const DistanceText = () => {
+  const [lines, setLines] = useState<
+    {
+      distance: string;
+      position: THREE.Vector3;
+      userData: Types.Line;
+      layer: string;
+    }[]
+  >([]);
+  const { activeLayer } = useActiveLayer();
+  const { toggleView } = useToggleView();
+  const { newLines, setNewLines } = useNewLines();
+  const { deletedLines, setDeletedLines } = useDeletedLines();
+  const [linesState, setLinesState] = useState<Types.Lines>([]);
+  const { roomsState, setRoomsState } = useRoomsState();
+  const { projectId } = useParams();
+
+  useEffect(() => {
+
+    if (linesState.length === 0) return;
+    const getLines = async () => {
+      const points3D = linesState.map(line => {
+        const startPoint = line[0][0]; // First point of each wall line
+        return [startPoint.x, 0, startPoint.z];
+      });
+
+      // Ensure the polygon is closed
+      if (
+        points3D[0][0] !== points3D[points3D.length - 1][0] ||
+        points3D[0][1] !== points3D[points3D.length - 1][1]
+      ) {
+        points3D.push(points3D[0]);
+      }
+
+      // Convert to 2D for turf (x, z)
+      const coords2D = points3D.map(p => [p[0], p[1]]);
+
+      const projected = points3D.map((p: any) => new Vector2(p[0], p[1]));
+
+      // Shoelace formula for 2D polygon
+      let area = 0;
+      const n = projected.length;
+      for (let i = 0; i < n - 1; i++) {
+        const curr = projected[i];
+        const next = projected[i + 1];
+        area += curr.x * next.y - next.x * curr.y;
+
+      }
+
+      // return Math.abs(area) / 2;
+
+      // Build polygon and compute area
+      // const polygon = turf.polygon([coords2D]);
+      // const area = turf.area(polygon);
+      // const area = computeAreaFrom3DPoints(coords2D)
+
+      // 
+      if (lines.length > 2) {
+        const linesByLayer = linesState.reduce((acc: { [key: number]: any[] }, pair) => {
+          const layer = pair[0][2];
+          if (!acc[layer]) acc[layer] = [];
+          acc[layer].push(pair);
+          return acc;
+        }, {});
+
+
+        for (const layer in linesByLayer) {
+          const rooms: Types.Rooms = await getRoomsFromLines({ current: linesByLayer[layer] });
+          setRoomsState(rooms)
+        }
+      }
+    }
+    getLines();
+  }, [linesState, roomsState])
+
+
+  useEffect(() => {
+    const email = localStorage.getItem("email");
+    if (!email) return;
+    const organization = email.split("@")[1].split(".")[0];
+
+    getLines(organization,projectId).then((data) => {
+      data = objectLinesToArray(data);
+      setLinesState(data);
+
+      const lines = data
+        .filter((line: Types.Line) => line[0][2] === activeLayer)
+        .map((line: Types.Line) => {
+          const point1 = new THREE.Vector3(
+            line[0][0].x,
+            line[0][0].y,
+            line[0][0].z
+          );
+          const point2 = new THREE.Vector3(
+            line[1][0].x,
+            line[1][0].y,
+            line[1][0].z
+          );
+          const distance = point1.distanceTo(point2);
+          const midpoint = new THREE.Vector3()
+            .addVectors(point1, point2)
+            .divideScalar(2);
+          return {
+            distance: distance.toFixed(1),
+            position: midpoint,
+            userData: line,
+            layer: activeLayer,
+          };
+        });
+      setLines(lines);
+    });
+  }, [activeLayer]);
+
+  useEffect(() => {
+    if (newLines.length > 0) {
+      if (newLines[0][0][2] !== activeLayer) return;
+      const newLinesData = newLines.map((line: Types.Line) => {
+        const point1 = new THREE.Vector3(
+          line[0][0].x,
+          line[0][0].y,
+          line[0][0].z
+        );
+        const point2 = new THREE.Vector3(
+          line[1][0].x,
+          line[1][0].y,
+          line[1][0].z
+        );
+        const distance = point1.distanceTo(point2);
+        const midpoint = new THREE.Vector3()
+          .addVectors(point1, point2)
+          .divideScalar(2);
+
+        return {
+          distance: distance.toFixed(1),
+          position: midpoint,
+          userData: line,
+          layer: activeLayer,
+        };
+      });
+      setLines((prevLines) => [...prevLines, ...newLinesData]);
+      setLinesState((prevLines) => [...prevLines, ...newLines]);
+      setNewLines([]);
+    }
+  }, [newLines, activeLayer]);
+
+  useEffect(() => {
+    if ((deletedLines as Types.Lines).length > 0) {
+      setLines((prevLines) =>
+        prevLines.filter(
+          (line) =>
+            !deletedLines.some(
+              (deletedLine: any) =>
+                deletedLine[0][1] === line.userData[0][1] &&
+                deletedLine[1][1] === line.userData[1][1]
+            )
+        )
+      );
+
+      setLinesState(prev =>
+        prev.filter(line =>
+          !(deletedLines as Types.Lines).some(
+            deleted =>
+              line[0][1] === deleted[0][1] && line[1][1] === deleted[1][1]
+          )
+        )
+      );
+
+      setDeletedLines([]);
+      setRoomsState([])
+    }
+  }, [deletedLines]);
+
+  return (
+    <>
+      {toggleView && (
+        <group name="Distance_Text">
+          {lines.map((text) => (
+            <Html
+              // data
+              key={`${text.userData[0][1]}_${text.userData[1][1]}`}
+              userData={text.userData}
+              position={[text.position.x, 1, text.position.z]}
+              // class
+              wrapperClass="distance-text-wrapper"
+              className="distance-text"
+              // other
+              zIndexRange={[1, 0]}
+              prepend
+              sprite
+            >
+              <div
+                key={`${text.userData[0][1]}_${text.userData[1][1]}`}
+                className={`distance line-${text.userData[0][1]}_${text.userData[1][1]}_${text.layer}`}
+              >
+                {text.distance} m
+              </div>
+            </Html>
+          ))}
+        </group>
+      )}
+    </>
+  );
+};
+
+export default DistanceText;

app/src/modules/builder/geomentries/lines/distanceText/referenceDistanceText.tsx

@@ -0,0 +1,71 @@
+import * as THREE from "three";
+import { Html } from "@react-three/drei";
+import { useState, useEffect } from "react";
+import { useActiveLayer } from "../../../../../store/builder/store";
+
+const ReferenceDistanceText = ({ line }: { line: any }) => {
+  interface TextState {
+    distance: string;
+    position: THREE.Vector3;
+    userData: any;
+    layer: any;
+  }
+
+  const [text, setTexts] = useState<TextState | null>(null);
+  const { activeLayer } = useActiveLayer();
+
+  useEffect(() => {
+    if (line) {
+      if (line.parent === null) {
+        setTexts(null);
+        return;
+      }
+      const distance = line.userData.linePoints.cursorPosition.distanceTo(
+        line.userData.linePoints.startPoint
+      );
+      const midpoint = new THREE.Vector3()
+        .addVectors(
+          line.userData.linePoints.cursorPosition,
+          line.userData.linePoints.startPoint
+        )
+        .divideScalar(2);
+      const newTexts = {
+        distance: distance.toFixed(1),
+        position: midpoint,
+        userData: line,
+        layer: activeLayer,
+      };
+      setTexts(newTexts);
+    }
+  });
+
+  return (
+    <group name="Reference_Distance_Text">
+      <mesh>
+        {text !== null && (
+          <Html
+            // data
+            key={text.distance}
+            userData={text.userData}
+            position={[text.position.x, 1, text.position.z]}
+            // class
+            wrapperClass="distance-text-wrapper"
+            className="distance-text"
+            // other
+            zIndexRange={[1, 0]}
+            prepend
+            sprite
+          >
+            <div
+              className={`Reference_Distance line-${text.userData.userData}`}
+            >
+              {text.distance} m
+            </div>
+          </Html>
+        )}
+      </mesh>
+    </group>
+  );
+};
+
+export default ReferenceDistanceText;

app/src/modules/builder/geomentries/lines/drawWall.ts

@@ -0,0 +1,176 @@
+import * as THREE from 'three';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+import addPointToScene from '../points/addPointToScene';
+import addLineToScene from './addLineToScene';
+import splitLine from './splitLine';
+import removeReferenceLine from './removeReferenceLine';
+import getClosestIntersection from './getClosestIntersection';
+
+import * as Types from "../../../../types/world/worldTypes";
+import arrayLineToObject from './lineConvertions/arrayLineToObject';
+// import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
+import { Socket } from 'socket.io-client';
+
+async function drawWall(
+    raycaster: THREE.Raycaster,
+    plane: Types.RefMesh,
+    floorPlanGroupPoint: Types.RefGroup,
+    snappedPoint: Types.RefVector3,
+    isSnapped: Types.RefBoolean,
+    isSnappedUUID: Types.RefString,
+    line: Types.RefLine,
+    ispreSnapped: Types.RefBoolean,
+    anglesnappedPoint: Types.RefVector3,
+    isAngleSnapped: Types.RefBoolean,
+    lines: Types.RefLines,
+    floorPlanGroupLine: Types.RefGroup,
+    floorPlanGroup: Types.RefGroup,
+    ReferenceLineMesh: Types.RefMesh,
+    LineCreated: Types.RefBoolean,
+    currentLayerPoint: Types.RefMeshArray,
+    dragPointControls: Types.RefDragControl,
+    setNewLines: any,
+    setDeletedLines: any,
+    activeLayer: Types.Number,
+    socket: Socket<any>,
+    projectId?: string
+): Promise<void> {
+
+    //////////  Creating lines Based on the positions clicked  //////////
+
+    //////////  Allows the user lines that represents walls and roof, floor if forms a polygon  //////////
+
+
+    if (!plane.current) return
+    let intersects = raycaster.intersectObject(plane.current, true);
+
+    let intersectsLines = raycaster.intersectObjects(floorPlanGroupLine.current.children, true);
+    let intersectsPoint = raycaster.intersectObjects(floorPlanGroupPoint.current.children, true);
+
+    const VisibleintersectsPoint = intersectsPoint.find(intersect => intersect.object.visible);
+    const visibleIntersect = intersectsLines.find(intersect => intersect.object.visible && intersect.object.name !== CONSTANTS.lineConfig.referenceName && intersect.object.userData.linePoints[0][3] === CONSTANTS.lineConfig.wallName);
+
+    if ((intersectsPoint.length === 0 || VisibleintersectsPoint === undefined) && intersectsLines.length > 0 && !isSnapped.current && !ispreSnapped.current) {
+
+        //////////  Clicked on a preexisting Line  //////////
+
+        if (visibleIntersect && intersects) {
+            let IntersectsPoint = new THREE.Vector3(intersects[0].point.x, 0.01, intersects[0].point.z);
+
+            if (isAngleSnapped.current && anglesnappedPoint.current) {
+                IntersectsPoint = anglesnappedPoint.current;
+            }
+            if (visibleIntersect.object instanceof THREE.Mesh) {
+                const ThroughPoint = (visibleIntersect.object.geometry.parameters.path).getPoints(CONSTANTS.lineConfig.lineIntersectionPoints);
+                let intersectionPoint = getClosestIntersection(ThroughPoint, IntersectsPoint);
+
+                if (intersectionPoint) {
+
+                    const newLines = splitLine(visibleIntersect, intersectionPoint, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lines, setDeletedLines, floorPlanGroupLine, socket, CONSTANTS.pointConfig.wallOuterColor, CONSTANTS.lineConfig.wallColor, CONSTANTS.lineConfig.wallName,projectId);
+                    setNewLines([newLines[0], newLines[1]]);
+
+                    (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
+
+                    if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+                        const data = arrayLineToObject(line.current as Types.Line);
+
+                        const email = localStorage.getItem('email')
+                        const organization = (email!.split("@")[1]).split(".")[0];
+                        const userId = localStorage.getItem("userId");
+
+                        //REST
+
+                        // setLine(organization, data.layer!, data.line!, data.type!);
+
+                        //SOCKET
+
+                        const input = {
+                            organization: organization,
+                            layer: data.layer,
+                            line: data.line,
+                            type: data.type,
+                            socketId: socket.id,
+                            projectId,
+                            userId
+                        }
+
+                        console.log('input: ', input);
+                        socket.emit('v1:Line:create', input);
+
+                        setNewLines([newLines[0], newLines[1], line.current]);
+                        lines.current.push(line.current as Types.Line);
+                        addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
+                        let lastPoint = line.current[line.current.length - 1];
+                        line.current = [lastPoint];
+                    }
+                    return;
+                }
+            }
+        }
+    }
+
+    if (intersects && intersects.length > 0) {
+
+        //////////  Clicked on a emply place or a point  //////////
+
+        let intersectionPoint = intersects[0].point;
+
+        if (isAngleSnapped.current && line.current.length > 0 && anglesnappedPoint.current) {
+            intersectionPoint = anglesnappedPoint.current;
+        }
+        if (isSnapped.current && line.current.length > 0 && snappedPoint.current) {
+            intersectionPoint = snappedPoint.current;
+        }
+        if (ispreSnapped.current && snappedPoint.current) {
+            intersectionPoint = snappedPoint.current;
+        }
+
+        if (!isSnapped.current && !ispreSnapped.current) {
+            addPointToScene(intersectionPoint, CONSTANTS.pointConfig.wallOuterColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, CONSTANTS.lineConfig.wallName);
+        } else {
+            ispreSnapped.current = false;
+            isSnapped.current = false;
+        }
+
+        (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
+
+        if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+            const data = arrayLineToObject(line.current as Types.Line);
+
+            const email = localStorage.getItem('email')
+            const organization = (email!.split("@")[1]).split(".")[0];
+            const userId = localStorage.getItem("userId");
+
+            //REST
+
+            // setLine(organization, data.layer!, data.line!, data.type!);
+
+            //SOCKET
+
+            const input = {
+                organization: organization,
+                layer: data.layer,
+                line: data.line,
+                type: data.type,
+                socketId: socket.id,
+                projectId,
+                userId
+            }
+
+            console.log('input: ', input);
+            socket.emit('v1:Line:create', input);
+
+            setNewLines([line.current])
+            lines.current.push(line.current as Types.Line);
+            addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
+            let lastPoint = line.current[line.current.length - 1];
+            line.current = [lastPoint];
+        }
+        if (isSnapped.current) {
+            removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
+        }
+    }
+}
+
+export default drawWall;

app/src/modules/builder/geomentries/lines/getClosestIntersection.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function getClosestIntersection(
+    intersects: Types.Vector3Array,
+    point: Types.Vector3
+): Types.Vector3 | null {
+
+    //////////  A function that finds which point is closest from the intersects points that is given, Used in finding which point in a line is closest when clicked on a line during drawing  ////////// 
+
+    let closestNewPoint: THREE.Vector3 | null = null;
+    let minDistance = Infinity;
+
+    for (const intersect of intersects) {
+        const distance = point.distanceTo(intersect);
+        if (distance < minDistance) {
+            minDistance = distance;
+            closestNewPoint = intersect;
+        }
+    }
+
+    return closestNewPoint;
+}
+
+export default getClosestIntersection;

app/src/modules/builder/geomentries/lines/getRoomsFromLines.ts

@@ -0,0 +1,86 @@
+import * as THREE from 'three';
+import * as turf from '@turf/turf';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+async function getRoomsFromLines(lines: Types.RefLines) {
+    const rooms: Types.Rooms = [];
+
+    if (lines.current.length > 2) {
+        const linesByLayer = lines.current.reduce((acc: { [key: number]: any[] }, pair) => {
+            const layer = pair[0][2];
+            if (!acc[layer]) acc[layer] = [];
+            acc[layer].push(pair);
+            return acc;
+        }, {});
+
+        //////////  Use turf.polygonize to create polygons from the line points  //////////
+
+        for (const layer in linesByLayer) {
+
+            let linesInLayer = linesByLayer[layer];
+            linesInLayer = linesInLayer.filter(line => line[0][3] && line[1][3] === CONSTANTS.lineConfig.wallName);
+            const result = linesInLayer.map((pair: [THREE.Vector3, string, number, string][]) =>
+                pair.map((point) => ({
+                    position: [point[0].x, point[0].z],
+                    uuid: point[1]
+                }))
+            );
+            const lineFeatures = result.map(line => turf.lineString(line.map(p => p.position)));
+            const polygons = turf.polygonize(turf.featureCollection(lineFeatures));
+
+            let union: any[] = [];
+
+            polygons.features.forEach((feature) => {
+                union.push(feature);
+            });
+
+            if (union.length > 1) {
+                const unionResult = turf.union(turf.featureCollection(union));
+                if (unionResult?.geometry.type === "MultiPolygon") {
+                    unionResult?.geometry.coordinates.forEach((poly) => {
+                        const Coordinates = poly[0].map(([x, z]) => {
+                            const matchingPoint = result.flat().find(r =>
+                                r.position[0].toFixed(10) === x.toFixed(10) &&
+                                r.position[1].toFixed(10) === z.toFixed(10)
+                            );
+                            return {
+                                position: new THREE.Vector3(x, 0, z),
+                                uuid: matchingPoint ? matchingPoint.uuid : ''
+                            };
+                        });
+                        rooms.push({ coordinates: Coordinates.reverse(), layer: parseInt(layer) });
+                    });
+                } else if (unionResult?.geometry.type === "Polygon") {
+                    const Coordinates = unionResult?.geometry.coordinates[0].map(([x, z]) => {
+                        const matchingPoint = result.flat().find(r =>
+                            r.position[0].toFixed(10) === x.toFixed(10) &&
+                            r.position[1].toFixed(10) === z.toFixed(10)
+                        );
+                        return {
+                            position: new THREE.Vector3(x, 0, z),
+                            uuid: matchingPoint ? matchingPoint.uuid : ''
+                        };
+                    });
+                    rooms.push({ coordinates: Coordinates.reverse(), layer: parseInt(layer) });
+                }
+            } else if (union.length === 1) {
+                const Coordinates = union[0].geometry.coordinates[0].map(([x, z]: [number, number]) => {
+                    const matchingPoint = result.flat().find(r =>
+                        r.position[0].toFixed(10) === x.toFixed(10) &&
+                        r.position[1].toFixed(10) === z.toFixed(10)
+                    );
+                    return {
+                        position: new THREE.Vector3(x, 0, z),
+                        uuid: matchingPoint ? matchingPoint.uuid : ''
+                    };
+                });
+                rooms.push({ coordinates: Coordinates, layer: parseInt(layer) });
+            }
+        }
+    }
+
+    return rooms;
+}
+
+export default getRoomsFromLines;

app/src/modules/builder/geomentries/lines/lineConvertions/arrayLineToObject.ts

@@ -0,0 +1,24 @@
+import * as Types from "../../../../../types/world/worldTypes";
+
+export default function arrayLineToObject(array: Types.Line) {
+    if (!Array.isArray(array)) {
+        return {};
+    }
+
+    // Extract common properties from the first point
+    const commonLayer = array[0][2];
+    const commonType = array[0][3];
+
+    // Map points into a structured format
+    const line = array.map(([position, uuid]) => ({
+        position,
+        uuid,
+    }));
+
+    // Create the final structured object
+    return {
+        layer: commonLayer,
+        type: commonType,
+        line,
+    };
+}

app/src/modules/builder/geomentries/lines/lineConvertions/arrayLinesToObject.ts

@@ -0,0 +1,30 @@
+import * as Types from "../../../../../types/world/worldTypes";
+
+export default function arrayLinesToObject(array: Array<Types.Line>) {
+    if (!Array.isArray(array)) {
+        return [];
+    }
+
+    return array.map((lineArray) => {
+        if (!Array.isArray(lineArray)) {
+            return null;
+        }
+
+        // Extract common properties from the first point
+        const commonLayer = lineArray[0][2];
+        const commonType = lineArray[0][3];
+
+        // Map points into a structured format
+        const line = lineArray.map(([position, uuid]) => ({
+            position,
+            uuid,
+        }));
+
+        // Create the final structured object
+        return {
+            layer: commonLayer,
+            type: commonType,
+            line,
+        };
+    }).filter((item) => item !== null); // Filter out invalid entries
+}

app/src/modules/builder/geomentries/lines/lineConvertions/objectLineToArray.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+
+export default function objectLineToArray(structuredObject: any) {
+    if (!structuredObject || !structuredObject.line) {
+        return [];
+    }
+
+    // Destructure common properties
+    const { layer, type, line } = structuredObject;
+
+    // Map points back to the original array format
+    return line.map(({ position, uuid }: any) => [new THREE.Vector3(position.x, position.y, position.z), uuid, layer, type]);
+}

app/src/modules/builder/geomentries/lines/lineConvertions/objectLinesToArray.ts

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+
+export default function objectLinesToArray(structuredObjects: any): any {
+    if (!Array.isArray(structuredObjects)) {
+        return [];
+    }
+
+    return structuredObjects.map((structuredObject) => {
+        if (!structuredObject || !structuredObject.line) {
+            return [];
+        }
+
+        const { layer, type, line } = structuredObject;
+
+        return line.map(({ position, uuid }: any) => {
+            const vector = new THREE.Vector3(position.x, position.y, position.z);
+            return [vector, uuid, layer, type];
+        });
+    });
+}

app/src/modules/builder/geomentries/lines/removeConnectedLines.ts

@@ -0,0 +1,66 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function RemoveConnectedLines(
+    DeletedPointUUID: Types.String,
+    floorPlanGroupLine: Types.RefGroup,
+    floorPlanGroupPoint: Types.RefGroup,
+    setDeletedLines: any,
+    lines: Types.RefLines,
+): void {
+
+    //////////  Check if any and how many lines are connected to the deleted point  //////////
+
+    const removableLines: THREE.Mesh[] = [];
+    const connectedpoints: string[] = [];
+
+    const removedLinePoints: [number, string, number][][] = []; // Array to hold linePoints of removed lines
+
+    floorPlanGroupLine.current.children.forEach((line) => {
+        const linePoints = line.userData.linePoints as [number, string, number][];
+        const uuid1 = linePoints[0][1];
+        const uuid2 = linePoints[1][1];
+
+        if (uuid1 === DeletedPointUUID || uuid2 === DeletedPointUUID) {
+            connectedpoints.push(uuid1 === DeletedPointUUID ? uuid2 : uuid1);
+            removableLines.push(line as THREE.Mesh);
+            removedLinePoints.push(linePoints);
+        }
+    });
+
+    if (removableLines.length > 0) {
+        removableLines.forEach((line) => {
+            lines.current = lines.current.filter(item => item !== line.userData.linePoints);
+            (<any>line.material).dispose();
+            (<any>line.geometry).dispose();
+            floorPlanGroupLine.current.remove(line);
+        });
+    }
+    setDeletedLines(removedLinePoints)
+
+    //////////  Check and Remove point that are no longer connected to any lines  //////////
+
+    connectedpoints.forEach((pointUUID) => {
+        let isConnected = false;
+        floorPlanGroupLine.current.children.forEach((line) => {
+            const linePoints = line.userData.linePoints as [number, string, number][];
+            const uuid1 = linePoints[0][1];
+            const uuid2 = linePoints[1][1];
+            if (uuid1 === pointUUID || uuid2 === pointUUID) {
+                isConnected = true;
+            }
+        });
+        if (!isConnected) {
+            floorPlanGroupPoint.current.children.forEach((point: any) => {
+                if (point.uuid === pointUUID) {
+                    (<any>point.material).dispose();
+                    (<any>point.geometry).dispose();
+                    floorPlanGroupPoint.current.remove(point);
+                }
+            });
+        }
+    });
+}
+
+export default RemoveConnectedLines;

app/src/modules/builder/geomentries/lines/removeReferenceLine.ts

@@ -0,0 +1,22 @@
+import * as Types from "../../../../types/world/worldTypes";
+
+function removeReferenceLine(
+    floorPlanGroup: Types.RefGroup,
+    ReferenceLineMesh: Types.RefMesh,
+    LineCreated: Types.RefBoolean,
+    line: Types.RefLine
+): void {
+
+    //////////  Removes Dangling reference line if the draw mode is ended or any other case  //////////
+
+    line.current = [];
+    if (ReferenceLineMesh.current) {
+        (<any>ReferenceLineMesh.current.material).dispose();
+        (<any>ReferenceLineMesh.current.geometry).dispose();
+        floorPlanGroup.current.remove(ReferenceLineMesh.current);
+        LineCreated.current = false;
+        ReferenceLineMesh.current = undefined;
+    }
+}
+
+export default removeReferenceLine;

app/src/modules/builder/geomentries/lines/splitLine.ts

@@ -0,0 +1,132 @@
+import * as THREE from 'three';
+
+import addLineToScene from './addLineToScene';
+import addPointToScene from '../points/addPointToScene';
+
+import * as Types from "../../../../types/world/worldTypes";
+import arrayLineToObject from '../lines/lineConvertions/arrayLineToObject';
+import { Socket } from 'socket.io-client';
+// import { deleteLineApi } from '../../../../services/factoryBuilder/lines/deleteLineApi';
+// import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
+
+function splitLine(
+    visibleIntersect: Types.IntersectionEvent,
+    intersectionPoint: Types.Vector3,
+    currentLayerPoint: Types.RefMeshArray,
+    floorPlanGroupPoint: Types.RefGroup,
+    dragPointControls: Types.RefDragControl,
+    isSnappedUUID: Types.RefString,
+    lines: Types.RefLines,
+    setDeletedLines: any,
+    floorPlanGroupLine: { current: THREE.Group },
+    socket: Socket<any>,
+    pointColor: Types.String,
+    lineColor: Types.String,
+    lineType: Types.String,
+    projectId?: string
+): [Types.Line, Types.Line] {
+
+    //////////  Removing the clicked line and splitting it with the clicked position adding a new point and two new lines  //////////
+
+
+    ((visibleIntersect.object as any).material).dispose();
+    ((visibleIntersect.object as any).geometry).dispose();
+    floorPlanGroupLine.current.remove(visibleIntersect.object);
+    setDeletedLines([visibleIntersect.object.userData.linePoints]);
+
+    const email = localStorage.getItem('email')
+    const organization = (email!.split("@")[1]).split(".")[0];
+    const userId = localStorage.getItem("userId");
+
+    //REST
+
+    // deleteLineApi(
+    //     organization,
+    //     [
+    //         { "uuid": visibleIntersect.object.userData.linePoints[0][1] },
+    //         { "uuid": visibleIntersect.object.userData.linePoints[1][1] }
+    //     ]
+    // )
+
+    //SOCKET
+
+
+    const data = {
+        organization: organization,
+        line: [
+            { "uuid": visibleIntersect.object.userData.linePoints[0][1] },
+            { "uuid": visibleIntersect.object.userData.linePoints[1][1] }
+        ],
+        socketId: socket.id,
+        projectId,
+        userId
+    }
+
+    socket.emit('v1:Line:delete', data);
+
+    const point = addPointToScene(intersectionPoint, pointColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lineType);
+
+    const oldLinePoints = visibleIntersect.object.userData.linePoints;
+    lines.current = lines.current.filter(item => item !== oldLinePoints);
+
+    const clickedPoint: Types.Point = [
+        new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z),
+        point.uuid,
+        oldLinePoints[0][2],
+        lineType
+    ];
+
+    const start = oldLinePoints[0];
+    const end = oldLinePoints[1];
+
+    const newLine1: Types.Line = [start, clickedPoint];
+    const newLine2: Types.Line = [clickedPoint, end];
+
+    const line1 = arrayLineToObject(newLine1);
+    const line2 = arrayLineToObject(newLine2);
+
+    //REST
+
+    // setLine(organization, line1.layer!, line1.line!, line1.type!);
+
+    //SOCKET
+
+    const input1 = {
+        organization: organization,
+        layer: line1.layer,
+        line: line1.line,
+        type: line1.type,
+        socketId: socket.id,
+        projectId,
+        userId
+    }
+
+    socket.emit('v1:Line:create', input1);
+
+    //REST
+
+    // setLine(organization, line2.layer!, line2.line!, line2.type!);
+
+    //SOCKET
+
+    const input2 = {
+        organization: organization,
+        layer: line2.layer,
+        line: line2.line,
+        type: line2.type,
+        socketId: socket.id,
+        projectId,
+        userId
+    }
+
+    socket.emit('v1:Line:create', input2);
+
+    lines.current.push(newLine1, newLine2);
+
+    addLineToScene(newLine1[0][0], newLine1[1][0], lineColor, newLine1, floorPlanGroupLine);
+    addLineToScene(newLine2[0][0], newLine2[1][0], lineColor, newLine2, floorPlanGroupLine);
+
+    return [newLine1, newLine2];
+}
+
+export default splitLine;

app/src/modules/builder/geomentries/lines/updateDistanceText.ts

@@ -0,0 +1,42 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function updateDistanceText(
+    scene: THREE.Scene,
+    floorPlanGroupLine: Types.RefGroup,
+    affectedLines: Types.NumberArray
+): void {
+
+    //////////  Updating the Distance Texts of the lines that are affected during drag //////////
+
+    const DistanceGroup = scene.getObjectByName('Distance_Text') as THREE.Group;
+
+    affectedLines.forEach((lineIndex) => {
+        const mesh = floorPlanGroupLine.current.children[lineIndex] as THREE.Mesh;
+        const linePoints = mesh.userData.linePoints;
+
+        if (linePoints) {
+            const distance = linePoints[0][0].distanceTo(linePoints[1][0]).toFixed(1);
+            const position = new THREE.Vector3().addVectors(linePoints[0][0], linePoints[1][0]).divideScalar(2);
+
+            if (!DistanceGroup || !linePoints) {
+                return
+            }
+
+            DistanceGroup.children.forEach((text) => {
+                const textMesh = text as THREE.Mesh;
+                if (textMesh.userData[0][1] === linePoints[0][1] && textMesh.userData[1][1] === linePoints[1][1]) {
+                    textMesh.position.set(position.x, 1, position.z);
+                    const className = `distance line-${textMesh.userData[0][1]}_${textMesh.userData[1][1]}_${linePoints[0][2]}`;
+                    const element = document.getElementsByClassName(className)[0] as HTMLElement;
+                    if (element) {
+                        element.innerHTML = `${distance} m`;
+                    }
+                }
+            });
+        }
+    });
+}
+
+export default updateDistanceText;

app/src/modules/builder/geomentries/lines/updateLines.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import * as Types from "../../../../types/world/worldTypes";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+function updateLines(
+    floorPlanGroupLine: Types.RefGroup,
+    affectedLines: Types.NumberArray
+): void {
+
+    ////////// Updating the positions for the affected lines only based on the updated positions //////////
+
+    affectedLines.forEach((lineIndex) => {
+        const mesh = floorPlanGroupLine.current.children[lineIndex] as Types.Mesh;
+        const linePoints = mesh.userData.linePoints as Types.Line;
+        if (linePoints) {
+            const newPositions = linePoints.map(([pos]) => pos);
+            const newPath = new THREE.CatmullRomCurve3(newPositions);
+            mesh.geometry.dispose();
+            mesh.geometry = new THREE.TubeGeometry(newPath, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+        }
+    });
+}
+
+export default updateLines;

app/src/modules/builder/geomentries/lines/updateLinesPositions.ts

@@ -0,0 +1,32 @@
+import * as Types from "../../../../types/world/worldTypes";
+
+function updateLinesPositions(
+    DragedPoint: Types.Mesh | { uuid: string, position: Types.Vector3 },
+    lines: Types.RefLines
+): Types.NumberArray {
+
+    ////////// Updating the lines position based on the dragged point's position //////////
+
+    const objectUUID = DragedPoint.uuid;
+    const affectedLines: Types.NumberArray = [];
+
+    lines.current.forEach((line, index) => {
+        let lineUpdated = false;
+        line.forEach((point) => {
+            const [position, uuid] = point;
+            if (uuid === objectUUID) {
+                position.x = DragedPoint.position.x;
+                position.y = 0.01;
+                position.z = DragedPoint.position.z;
+                lineUpdated = true;
+            }
+        });
+        if (lineUpdated) {
+            affectedLines.push(index);
+        }
+    });
+
+    return affectedLines;
+}
+
+export default updateLinesPositions;

app/src/modules/builder/geomentries/lines/vectorizeLinesCurrent.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function vectorizeLinesCurrent(
+    lines: Types.Lines
+): Types.Lines {
+
+    //////////  Storing a vector3 array in localstorage makes the prototype functions go puff. This function brings back the prototype functions by creating it again  //////////
+
+    return lines.map((line) => {
+        const p1: Types.Point = [new THREE.Vector3(line[0][0].x, line[0][0].y, line[0][0].z), line[0][1], line[0][2], line[0][3],];
+        const p2: Types.Point = [new THREE.Vector3(line[1][0].x, line[1][0].y, line[1][0].z), line[1][1], line[0][2], line[1][3],];
+        return [p1, p2];
+    });
+}
+
+export default vectorizeLinesCurrent;