diff --git a/src/components/floor-plan/modal/basic/step/Module.jsx b/src/components/floor-plan/modal/basic/step/Module.jsx
index 2402b3e0..426724eb 100644
--- a/src/components/floor-plan/modal/basic/step/Module.jsx
+++ b/src/components/floor-plan/modal/basic/step/Module.jsx
@@ -11,6 +11,7 @@ import { moduleSelectionDataState } from '@/store/selectedModuleOptions'
 import { useCanvasPopupStatusController } from '@/hooks/common/useCanvasPopupStatusController'
 import { isObjectNotEmpty } from '@/util/common-utils'
 import { normalizeDecimal} from '@/util/input-utils'
+import { CalculatorInput } from '@/components/common/input/CalcInput'
 
 export default function Module({ setTabNum }) {
   const { getMessage } = useMessage()
@@ -185,11 +186,23 @@ export default function Module({ setTabNum }) {
                   <div className="eaves-keraba-td">
                     <div className="outline-form">
                       <div className="grid-select mr10">
-                        <input
-                          type="text"
+                        {/*<input*/}
+                        {/*  type="text"*/}
+                        {/*  className="input-origin block"*/}
+                        {/*  value={inputInstallHeight}*/}
+                        {/*  onChange={(e) => setInputInstallHeight(normalizeDecimal(e.target.value))}*/}
+                        {/*/>*/}
+                        <CalculatorInput
+                          id=""
+                          name=""
+                          label=""
                           className="input-origin block"
                           value={inputInstallHeight}
-                          onChange={(e) => setInputInstallHeight(normalizeDecimal(e.target.value))}
+                          onChange={(value) => setInputInstallHeight(value)}
+                          options={{
+                            allowNegative: false,
+                            allowDecimal: false
+                          }}
                         />
                       </div>
                       <span className="thin">m</span>
diff --git a/src/components/floor-plan/modal/basic/step/Orientation.jsx b/src/components/floor-plan/modal/basic/step/Orientation.jsx
index 6359163f..fdf599be 100644
--- a/src/components/floor-plan/modal/basic/step/Orientation.jsx
+++ b/src/components/floor-plan/modal/basic/step/Orientation.jsx
@@ -10,6 +10,7 @@ import { useModuleBasicSetting } from '@/hooks/module/useModuleBasicSetting'
 import { useCommonCode } from '@/hooks/common/useCommonCode'
 import Swal from 'sweetalert2'
 import { normalizeDecimal} from '@/util/input-utils'
+import { CalculatorInput } from '@/components/common/input/CalcInput'
 
 export const Orientation = forwardRef((props, ref) => {
   const { getMessage } = useMessage()
@@ -436,13 +437,26 @@ export const Orientation = forwardRef((props, ref) => {
                     <label htmlFor="ch99">{getMessage('modal.module.basic.setting.orientation.setting.angle.passivity')}</label>
                   </div>
                   <div className="input-grid mr10" style={{ width: '60px' }}>
-                    <input
-                      type="text"
+                    {/*<input*/}
+                    {/*  type="text"*/}
+                    {/*  className="input-origin block"*/}
+                    {/*  value={inputCompasDeg}*/}
+                    {/*  readOnly={!hasAnglePassivity}*/}
+                    {/*  placeholder={0}*/}
+                    {/*  onChange={(e) => checkDegree(e.target.value)}*/}
+                    {/*/>*/}
+                    <CalculatorInput
+                      id=""
+                      name=""
+                      label=""
                       className="input-origin block"
                       value={inputCompasDeg}
                       readOnly={!hasAnglePassivity}
-                      placeholder={0}
-                      onChange={(e) => checkDegree(e.target.value)}
+                      onChange={(value) => setInputCompasDeg(value)}
+                      options={{
+                        allowNegative: true,
+                        allowDecimal: false
+                      }}
                     />
                   </div>
                   <span className="thin">°</span>
@@ -533,7 +547,19 @@ export const Orientation = forwardRef((props, ref) => {
                   <div className="outline-form mt15">
                     <span>{getMessage('modal.module.basic.setting.module.placement.area')}</span>
                     <div className="input-grid mr10" style={{ width: '60px' }}>
-                      <input type="text" className="input-origin block" value={inputMargin} onChange={(e) => setInputMargin(normalizeDecimal(e.target.value))} />
+                      {/*<input type="text" className="input-origin block" value={inputMargin} onChange={(e) => setInputMargin(normalizeDecimal(e.target.value))} />*/}
+                      <CalculatorInput
+                        id=""
+                        name=""
+                        label=""
+                        className="input-origin block"
+                        value={inputMargin}
+                        onChange={(value) => setInputMargin(value)}
+                        options={{
+                          allowNegative: false,
+                          allowDecimal: false
+                        }}
+                      />
                     </div>
                     <span className="thin">m</span>
                   </div>
@@ -561,11 +587,23 @@ export const Orientation = forwardRef((props, ref) => {
                     <div className="outline-form">
                       <span>{getMessage('modal.module.basic.setting.module.fitting.height')}</span>
                       <div className="input-grid mr10">
-                        <input
-                          type="text"
+                        {/*<input*/}
+                        {/*  type="text"*/}
+                        {/*  className="input-origin block"*/}
+                        {/*  value={inputInstallHeight}*/}
+                        {/*  onChange={(e) => handleChangeInstallHeight(normalizeDecimal(e.target.value))}*/}
+                        {/*/>*/}
+                        <CalculatorInput
+                          id=""
+                          name=""
+                          label=""
                           className="input-origin block"
                           value={inputInstallHeight}
-                          onChange={(e) => handleChangeInstallHeight(normalizeDecimal(e.target.value))}
+                          onChange={(value) => handleChangeInstallHeight(value)}
+                          options={{
+                            allowNegative: false,
+                            allowDecimal: false
+                          }}
                         />
                       </div>
                       <span className="thin">m</span>
@@ -589,11 +627,23 @@ export const Orientation = forwardRef((props, ref) => {
                     <div className="outline-form">
                       <span>{getMessage('modal.module.basic.setting.module.standard.snowfall.amount')}</span>
                       <div className="input-grid mr10">
-                        <input
-                          type="text"
+                        {/*<input*/}
+                        {/*  type="text"*/}
+                        {/*  className="input-origin block"*/}
+                        {/*  value={inputVerticalSnowCover}*/}
+                        {/*  onChange={(e) => handleChangeVerticalSnowCover(normalizeDecimal(e.target.value))}*/}
+                        {/*/>*/}
+                        <CalculatorInput
+                          id=""
+                          name=""
+                          label=""
                           className="input-origin block"
-                          value={inputVerticalSnowCover}
-                          onChange={(e) => handleChangeVerticalSnowCover(normalizeDecimal(e.target.value))}
+                          value={inputInstallHeight}
+                          onChange={(value) => handleChangeVerticalSnowCover(value)}
+                          options={{
+                            allowNegative: false,
+                            allowDecimal: false
+                          }}
                         />
                       </div>
                       <span className="thin">cm</span>
diff --git a/src/components/floor-plan/modal/basic/step/Trestle.jsx b/src/components/floor-plan/modal/basic/step/Trestle.jsx
index 13f46a31..a1061a87 100644
--- a/src/components/floor-plan/modal/basic/step/Trestle.jsx
+++ b/src/components/floor-plan/modal/basic/step/Trestle.jsx
@@ -10,6 +10,7 @@ import { forwardRef, useContext, useEffect, useImperativeHandle, useRef, useStat
 import { useRecoilState, useRecoilValue } from 'recoil'
 import Swal from 'sweetalert2'
 import { normalizeDigits } from '@/util/input-utils'
+import { CalculatorInput } from '@/components/common/input/CalcInput'
 
 const Trestle = forwardRef((props, ref) => {
   const { tabNum, setTabNum, trestleTrigger, roofs, setRoofs, moduleSelectionData, setModuleSelectionData, setRoofsStore } = props
@@ -885,12 +886,24 @@ const Trestle = forwardRef((props, ref) => {
               <div className="outline-form mr15">
                 <span>{getMessage('modal.module.basic.setting.module.placement.area.eaves')}</span>
                 <div className="input-grid mr10">
-                  <input
-                    type="number"
+                  {/*<input*/}
+                  {/*  type="number"*/}
+                  {/*  className="input-origin block"*/}
+                  {/*  value={eavesMargin ?? 0}*/}
+                  {/*  // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, eavesMargin: e.target.value } })}*/}
+                  {/*  onChange={(e) => setEavesMargin(+e.target.value)}*/}
+                  {/*/>*/}
+                  <CalculatorInput
+                    id=""
+                    name=""
+                    label=""
                     className="input-origin block"
                     value={eavesMargin ?? 0}
-                    // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, eavesMargin: e.target.value } })}
-                    onChange={(e) => setEavesMargin(+e.target.value)}
+                    onChange={(value) => setEavesMargin(value)}
+                    options={{
+                      allowNegative: false,
+                      allowDecimal: false
+                    }}
                   />
                 </div>
                 <span className="thin">mm</span>
@@ -898,12 +911,24 @@ const Trestle = forwardRef((props, ref) => {
               <div className="outline-form mr15">
                 <span>{getMessage('modal.module.basic.setting.module.placement.area.ridge')}</span>
                 <div className="input-grid mr10">
-                  <input
-                    type="number"
+                  {/*<input*/}
+                  {/*  type="number"*/}
+                  {/*  className="input-origin block"*/}
+                  {/*  value={ridgeMargin ?? 0}*/}
+                  {/*  // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, ridgeMargin: e.target.value } })}*/}
+                  {/*  onChange={(e) => setRidgeMargin(+e.target.value)}*/}
+                  {/*/>*/}
+                  <CalculatorInput
+                    id=""
+                    name=""
+                    label=""
                     className="input-origin block"
                     value={ridgeMargin ?? 0}
-                    // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, ridgeMargin: e.target.value } })}
-                    onChange={(e) => setRidgeMargin(+e.target.value)}
+                    onChange={(value) => setRidgeMargin(value)}
+                    options={{
+                      allowNegative: false,
+                      allowDecimal: false
+                    }}
                   />
                 </div>
                 <span className="thin">mm</span>
@@ -911,12 +936,24 @@ const Trestle = forwardRef((props, ref) => {
               <div className="outline-form ">
                 <span>{getMessage('modal.module.basic.setting.module.placement.area.keraba')}</span>
                 <div className="input-grid mr10">
-                  <input
-                    type="number"
+                  {/*<input*/}
+                  {/*  type="number"*/}
+                  {/*  className="input-origin block"*/}
+                  {/*  value={kerabaMargin ?? 0}*/}
+                  {/*  // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, kerabaMargin: e.target.value } })}*/}
+                  {/*  onChange={(e) => setKerabaMargin(+e.target.value)}*/}
+                  {/*/>*/}
+                  <CalculatorInput
+                    id=""
+                    name=""
+                    label=""
                     className="input-origin block"
                     value={kerabaMargin ?? 0}
-                    // onChange={(e) => dispatch({ type: 'SET_TRESTLE_DETAIL', roof: { ...trestleState, kerabaMargin: e.target.value } })}
-                    onChange={(e) => setKerabaMargin(+e.target.value)}
+                    onChange={(value) => setKerabaMargin(value)}
+                    options={{
+                      allowNegative: false,
+                      allowDecimal: false
+                    }}
                   />
                 </div>
                 <span className="thin">mm</span>
diff --git a/src/hooks/usePolygon.js b/src/hooks/usePolygon.js
index fe8fbd78..011b8852 100644
--- a/src/hooks/usePolygon.js
+++ b/src/hooks/usePolygon.js
@@ -851,12 +851,15 @@ export const usePolygon = () => {
     // innerLines와 polygonLines의 겹침을 확인하고 type 변경
     innerLines.forEach((innerLine) => {
       polygonLines.forEach((polygonLine) => {
+        if (polygonLine.attributes.type === LINE_TYPE.WALLLINE.EAVES) {
+          return
+        }
         if (checkLineOverlap(innerLine, polygonLine)) {
           // innerLine의 type을 polygonLine의 type으로 변경
           if (innerLine.attributes && polygonLine.attributes.type) {
             // innerLine이 polygonLine보다 긴 경우 polygonLine.need를 false로 변경
             if (polygonLine.length < innerLine.length) {
-              if (polygonLine.lineName !== 'eaveHelpLine') {
+              if (polygonLine.lineName !== 'eaveHelpLine' || polygonLine.lineName !== 'eaveHelpLine') {
                 polygonLine.need = false
               }
             }
@@ -1014,6 +1017,7 @@ export const usePolygon = () => {
       canvas.add(line)
     })
     canvas.renderAll()*/
+
     polygonLines = polygonLines.filter((line) => line.need)
 
     polygonLines.forEach((line) => {
@@ -1377,7 +1381,6 @@ export const usePolygon = () => {
     let newRoofs = getSplitRoofsPoints(allLines)
 
     newRoofs = newRoofs.filter((roof) => roof.length !== 0)
-
     newRoofs.forEach((roofPoint, index) => {
       let defense, pitch
 
@@ -1411,6 +1414,124 @@ export const usePolygon = () => {
         }
       })
 
+      // representLines가 없다면 A,B타입중 하나임
+      if (representLines.length === 0) {
+        // 1. roofPoint로 폴리곤의 라인들을 생성
+        const roofPolygonLines = []
+        for (let i = 0; i < roofPoint.length; i++) {
+          const nextIndex = (i + 1) % roofPoint.length
+          const startPt = roofPoint[i]
+          const endPt = roofPoint[nextIndex]
+          roofPolygonLines.push({
+            x1: startPt.x,
+            y1: startPt.y,
+            x2: endPt.x,
+            y2: endPt.y,
+            startPoint: startPt,
+            endPoint: endPt,
+          })
+        }
+
+        // 3. 평행 여부 확인 함수
+        const checkParallel = (line1, line2) => {
+          const v1x = line1.x2 - line1.x1
+          const v1y = line1.y2 - line1.y1
+          const v2x = line2.x2 - line2.x1
+          const v2y = line2.y2 - line2.y1
+
+          const length1 = Math.sqrt(v1x ** 2 + v1y ** 2)
+          const length2 = Math.sqrt(v2x ** 2 + v2y ** 2)
+
+          if (length1 === 0 || length2 === 0) return false
+
+          const norm1x = v1x / length1
+          const norm1y = v1y / length1
+          const norm2x = v2x / length2
+          const norm2y = v2y / length2
+
+          const EPSILON = 0.01
+          const crossProduct = Math.abs(norm1x * norm2y - norm1y * norm2x)
+          const dotProduct = norm1x * norm2x + norm1y * norm2y
+
+          return crossProduct < EPSILON || Math.abs(Math.abs(dotProduct) - 1) < EPSILON
+        }
+
+        // 4. 점에서 라인까지의 거리 계산 함수
+        const getDistanceFromPointToLine = (point, lineP1, lineP2) => {
+          const A = point.x - lineP1.x
+          const B = point.y - lineP1.y
+          const C = lineP2.x - lineP1.x
+          const D = lineP2.y - lineP1.y
+
+          const dot = A * C + B * D
+          const lenSq = C * C + D * D
+          let param = -1
+
+          if (lenSq !== 0) {
+            param = dot / lenSq
+          }
+
+          let xx, yy
+
+          if (param < 0) {
+            xx = lineP1.x
+            yy = lineP1.y
+          } else if (param > 1) {
+            xx = lineP2.x
+            yy = lineP2.y
+          } else {
+            xx = lineP1.x + param * C
+            yy = lineP1.y + param * D
+          }
+
+          const dx = point.x - xx
+          const dy = point.y - yy
+
+          return Math.sqrt(dx * dx + dy * dy)
+        }
+
+        // 5. 두 평행한 라인 사이의 거리 계산 (한 라인의 중점에서 다른 라인까지의 거리)
+        const getDistanceBetweenParallelLines = (line1, line2) => {
+          const midPoint = {
+            x: (line1.x1 + line1.x2) / 2,
+            y: (line1.y1 + line1.y2) / 2,
+          }
+          return getDistanceFromPointToLine(midPoint, { x: line2.x1, y: line2.y1 }, { x: line2.x2, y: line2.y2 })
+        }
+
+        // 6. roofPolygonLines의 모든 라인에서 평행하면서 가장 가까운 EAVES 라인 찾기
+        let closestLine = null
+        let minDistance = Infinity
+
+        roofPolygonLines.forEach((roofLine) => {
+          ;[...polygonLines, ...innerLines].forEach((line) => {
+            // EAVES 타입만 필터링
+            if (line.attributes?.type !== LINE_TYPE.WALLLINE.EAVES && line.attributes?.type !== LINE_TYPE.WALLLINE.EAVE_HELP_LINE) {
+              return
+            }
+
+            const lineObj = {
+              x1: line.startPoint.x,
+              y1: line.startPoint.y,
+              x2: line.endPoint.x,
+              y2: line.endPoint.y,
+            }
+
+            if (checkParallel(roofLine, lineObj)) {
+              const distance = getDistanceBetweenParallelLines(roofLine, lineObj)
+              if (distance < minDistance && distance > 0) {
+                minDistance = distance
+                closestLine = line
+              }
+            }
+          })
+        })
+
+        if (closestLine) {
+          representLines.push(closestLine)
+        }
+      }
+
       // representLines중 가장 긴 line을 찾는다.
       representLines.forEach((line) => {
         if (!representLine) {
diff --git a/src/util/skeleton-utils.js b/src/util/skeleton-utils.js
index 383c82e0..32d8bd9e 100644
--- a/src/util/skeleton-utils.js
+++ b/src/util/skeleton-utils.js
@@ -596,9 +596,6 @@ const createInnerLinesFromSkeleton = (roofId, canvas, skeleton, textMode) => {
       });
 
 
-
-
-
     }else{
 
 
@@ -608,8 +605,7 @@ const createInnerLinesFromSkeleton = (roofId, canvas, skeleton, textMode) => {
     canvas.renderAll();
   });
 
-  if((roof.moveUpDown??0 > 0) || (roof.moveFlowLine??0 > 0)  ) {
-
+  if (Math.abs(roof.moveUpDown ?? 0) > 0 || Math.abs(roof.moveFlowLine ?? 0) > 0) {
     const getMoveUpDownLine = () => {
   // 같은 라인이 없으므로 새 다각형 라인 생성
   //라인 편집
@@ -657,7 +653,8 @@ const createInnerLinesFromSkeleton = (roofId, canvas, skeleton, textMode) => {
     });
   }
 
-    // 각 라인 집합 정렬
+
+  // 각 라인 집합 정렬
 
   // roofLines의 방향에 맞춰 currentRoofLines의 방향을 조정
   const alignLineDirection = (sourceLines, targetLines) => {
@@ -711,12 +708,13 @@ const createInnerLinesFromSkeleton = (roofId, canvas, skeleton, textMode) => {
     });
   };
 
+  console.log("wallBaseLines", wall.baseLines)
   // const sortedWallLines = sortCurrentRoofLines(wall.lines);
   // roofLines의 방향에 맞춰 currentRoofLines 조정 후 정렬
   const alignedCurrentRoofLines = alignLineDirection(currentRoofLines, roofLines);
-  const sortedCurrentRoofLines = sortCurrentRoofLines(alignedCurrentRoofLines);
+  const sortedCurrentRoofLines = sortCurrentRoofLines(alignedCurrentRoofLines)
   // const sortedRoofLines = sortCurrentRoofLines(roofLines);
-  const sortedWallBaseLines = sortCurrentRoofLines(wall.baseLines);
+  const sortedWallBaseLines = sortCurrentRoofLines(wall.baseLines)
   // const sortedBaseLines = sortBaseLinesByWallLines(wall.baseLines, wallLines);
   const sortRoofLines = sortBaseLinesByWallLines(roofLines, wallLines);
 
@@ -730,771 +728,751 @@ const createInnerLinesFromSkeleton = (roofId, canvas, skeleton, textMode) => {
   const movedLines = []
 
   // 조건에 맞는 라인들만 필터링
-  const validWallLines = wallLines.filter((wallLine, index) => wallLine.idx - 1 === index);
+      const validWallLines = [...wallLines]
+        .sort((a, b) => a.idx - b.idx)
+        .filter((wallLine, index) => wallLine.idx - 1 === index);
 
+      wallLines.length > 3 && wallLines.forEach((wallLine, index) => {
+        const originalIndex = wallLines.indexOf(wallLine)
+        const roofLine = sortRoofLines[originalIndex]
+        const currentRoofLine = currentRoofLines[originalIndex]
+        const moveLine = wall.baseLines[originalIndex]
+        const wallBaseLine = wall.baseLines[originalIndex]
 
-  validWallLines.forEach((wallLine, index) => {
+        //  const roofLine = sortRoofLines[index];
 
-    const originalIndex = wallLines.indexOf(wallLine);
-    const roofLine = sortRoofLines[originalIndex];
-    const currentRoofLine = currentRoofLines[originalIndex];
-    const moveLine = wall.baseLines[originalIndex];
-    const wallBaseLine = wall.baseLines[originalIndex];
+        // if (roofLine.attributes.wallLine !== wallLine.id || (roofLine.idx - 1) !== index) {
+        //   console.log("wallLine2::::", wallLine.id)
+        //   console.log('roofLine:::', roofLine.attributes.wallLine)
+        //   console.log("w:::", wallLine.startPoint, wallLine.endPoint)
+        //   console.log("R:::", roofLine.startPoint, roofLine.endPoint)
+        //   console.log("not matching roofLine", roofLine);
+        //   return false
+        // }//roofLines.find(line => line.attributes.wallLineId === wallLine.attributes.wallId);
 
-    //  const roofLine = sortRoofLines[index];
+        //  const currentRoofLine = currentRoofLines[index];
+        //  const moveLine = wall.baseLines[index]
+        //  const wallBaseLine = wall.baseLines[index]
+        //console.log("wallBaseLine", wallBaseLine);
 
-    if (roofLine.attributes.wallLine !== wallLine.id || (roofLine.idx - 1) !== index) {
-      console.log("wallLine2::::", wallLine.id)
-      console.log('roofLine:::', roofLine.attributes.wallLine)
-      console.log("w:::", wallLine.startPoint, wallLine.endPoint)
-      console.log("R:::", roofLine.startPoint, roofLine.endPoint)
-      console.log("not matching roofLine", roofLine);
-      return false
-    }//roofLines.find(line => line.attributes.wallLineId === wallLine.attributes.wallId);
+        //roofline 외곽선 설정
+        console.log('index::::', index)
+        console.log('roofLine:::', roofLine)
+        console.log('wallLine', wallLine)
+        console.log('wallBaseLine', wallBaseLine)
 
-    //  const currentRoofLine = currentRoofLines[index];
-    //  const moveLine = wall.baseLines[index]
-    //  const wallBaseLine = wall.baseLines[index]
-    //console.log("wallBaseLine", wallBaseLine);
+        const origin = moveLine.attributes?.originPoint
+        if (!origin) return
 
-    //roofline 외곽선 설정
-    console.log("index::::", index)
-    console.log('roofLine:::', roofLine)
-    console.log('wallLine', wallLine)
-    console.log('wallBaseLine', wallBaseLine)
+        console.log('moveLine:', moveLine.x1, moveLine.y1, moveLine.x2, moveLine.y2)
+        console.log('wallLine:', wallLine.x1, wallLine.y1, wallLine.x2, wallLine.y2)
+        console.log('isSamePoint result:', isSameLine2(moveLine, wallLine))
 
-
-    const origin = moveLine.attributes?.originPoint
-    if (!origin) return
-
-    if (isSamePoint(moveLine, wallLine)) {
-
-      return false
-    }
-
-    const movedStart = Math.abs(moveLine.x1 - wallLine.x1) > EPSILON || Math.abs(moveLine.y1 - origin.y1) > EPSILON
-    const movedEnd = Math.abs(moveLine.x2 - wallLine.x2) > EPSILON || Math.abs(moveLine.y2 - origin.y2) > EPSILON
-
-
-    const fullyMoved = movedStart && movedEnd
-
-
-//반시계 방향
-    let newPStart //= {x:roofLine.x1, y:roofLine.y1}
-    let newPEnd  //=  {x:movedLines.x2, y:movedLines.y2}
-
-//현재 roof는 무조건 시계방향
-
-    const getAddLine = (p1, p2, stroke = '') => {
-      movedLines.push({ index, p1, p2 })
-
-// Usage:
-      // let mergeLines = mergeMovedLines(movedLines);
-      //console.log("mergeLines:::::::", mergeLines);
-      const line = new QLine([p1.x, p1.y, p2.x, p2.y], {
-        parentId   : roof.id,
-        fontSize   : roof.fontSize,
-        stroke     : '#3FBAE6',
-        strokeWidth: 4,
-        name       : 'eaveHelpLine',
-        lineName   : 'eaveHelpLine',
-        visible    : true,
-        roofId     : roofId,
-        selectable: true,
-        hoverCursor: 'pointer',
-        attributes : {
-          type   : 'eaveHelpLine',
-          isStart: true,
-          pitch  : wallLine.attributes.pitch,
+        if (isSameLine2(moveLine, wallLine)) {
+          return
         }
+
+        const movedStart = Math.abs(moveLine.x1 - wallLine.x1) > EPSILON || Math.abs(moveLine.y1 - origin.y1) > EPSILON
+        const movedEnd = Math.abs(moveLine.x2 - wallLine.x2) > EPSILON || Math.abs(moveLine.y2 - origin.y2) > EPSILON
+
+        const fullyMoved = movedStart && movedEnd
+
+        //반시계 방향
+        let newPStart //= {x:roofLine.x1, y:roofLine.y1}
+        let newPEnd //=  {x:movedLines.x2, y:movedLines.y2}
+
+        //현재 roof는 무조건 시계방향
+
+        const getAddLine = (p1, p2, stroke = '') => {
+          movedLines.push({ index, p1, p2 })
+
+          // Usage:
+          // let mergeLines = mergeMovedLines(movedLines);
+          //console.log("mergeLines:::::::", mergeLines);
+          const line = new QLine([p1.x, p1.y, p2.x, p2.y], {
+            parentId: roof.id,
+            fontSize: roof.fontSize,
+            stroke: 'black',
+            strokeWidth: 4,
+            name: 'eaveHelpLine',
+            lineName: 'eaveHelpLine',
+            visible: true,
+            roofId: roofId,
+            selectable: true,
+            hoverCursor: 'pointer',
+            attributes: {
+              type: 'eaveHelpLine',
+              isStart: true,
+              pitch: wallLine.attributes.pitch,
+            },
+          })
+
+          coordinateText(line)
+          canvas.add(line)
+          line.bringToFront()
+          canvas.renderAll()
+          return line
+        }
+
+        //getAddLine(roofLine.startPoint, roofLine.endPoint, ) //외곽선을 그린다
+
+        newPStart = { x: roofLine.x1, y: roofLine.y1 }
+        newPEnd = { x: roofLine.x2, y: roofLine.y2 }
+
+        const getInnerLines = (lines, point) => {}
+        let isIn = false
+        let isOut = false
+
+        //두 포인트가 변경된 라인인
+        if (fullyMoved) {
+          //반시계방향향
+
+          const mLine = getSelectLinePosition(wall, wallBaseLine)
+
+          if (getOrientation(roofLine) === 'vertical') {
+            if (['left', 'right'].includes(mLine.position)) {
+              if (Math.abs(wallLine.x1 - wallBaseLine.x1) < 0.1 || Math.abs(wallLine.x2 - wallBaseLine.x2) < 0.1) {
+                return false
+              }
+              const isLeftPosition = mLine.position === 'left'
+              const isRightPosition = mLine.position === 'right'
+              const isInPosition =
+                (isLeftPosition && wallLine.x1 < wallBaseLine.x1) ||
+                (isRightPosition && wallLine.x1 > wallBaseLine.x1) ||
+                (isLeftPosition && wallLine.x2 < wallBaseLine.x2) ||
+                (isRightPosition && wallLine.x2 > wallBaseLine.x2)
+
+              const positionType = isInPosition ? 'in' : 'out'
+
+              const condition = `${mLine.position}_${positionType}`
+              let isStartEnd = findInteriorPoint(wallBaseLine, sortedBaseLines)
+              let sPoint, ePoint
+              if (condition === 'left_in') {
+                isIn = true
+
+                if (isStartEnd.start) {
+                  newPEnd.y = roofLine.y2
+                  newPEnd.x = roofLine.x2
+
+                  const moveDist = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
+                  ePoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 }
+                  newPStart.y = wallBaseLine.y1
+
+                  findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'left_in_start' })
+                  const newPointX = Big(roofLine.x1).plus(moveDist).abs().toNumber()
+                  const pDist = Big(wallLine.x1).minus(roofLine.x1).toNumber()
+                  const pLineY = Big(roofLine.y1).minus(0).abs().toNumber()
+                  let idx = 0 > index - 1 ? roofLines.length : index
+                  const pLineX = roofLines[idx - 1].x1
+
+                  getAddLine({ x: newPStart.x, y: newPStart.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
+                  getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
+
+                  if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
+                    getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
+                  }
+                }
+
+                if (isStartEnd.end) {
+                  newPStart.y = roofLine.y1
+                  newPStart.x = roofLine.x1
+
+                  const moveDist = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
+                  ePoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 }
+                  newPEnd.y = wallBaseLine.y2
+
+                  findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'left_in_end' })
+                  const newPointX = Big(roofLine.x1).plus(moveDist).toNumber()
+                  const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
+                  const pLineY = Big(roofLine.y2).minus(0).toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const pLineX = roofLines[idx + 1].x2
+
+                  getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
+                  getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: newPointX, y: roofLine.y1 }, 'orange')
+
+                  if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
+                    getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
+                  }
+                  //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
+                }
+              } else if (condition === 'left_out') {
+                console.log('left_out::::isStartEnd:::::', isStartEnd)
+                if (isStartEnd.start) {
+                  const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
+                  const aStartY = Big(roofLine.y1).minus(moveDist).abs().toNumber()
+                  const bStartY = Big(wallLine.y1).minus(moveDist).abs().toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x2 })
+
+                  const eLineY = Big(bStartY).minus(wallLine.y1).abs().toNumber()
+                  newPStart.y = aStartY
+                  newPEnd.y = roofLine.y2 //Big(roofLine.y2).minus(eLineY).toNumber()
+                  let idx = 0 >= index - 1 ? roofLines.length : index
+                  const newLine = roofLines[idx - 1]
+
+                  if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
+                    if (inLine) {
+                      if (inLine.x1 < inLine.x2) {
+                        getAddLine({ y: bStartY, x: wallLine.x2 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
+                      } else {
+                        getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: bStartY, x: wallLine.x2 }, 'pink')
+                      }
+                    }
+                    getAddLine({ y: bStartY, x: wallLine.x2 }, { y: roofLine.y1, x: wallLine.x1 }, 'magenta')
+                    getAddLine({ y: newLine.y1, x: newLine.x1 }, { y: newLine.y2, x: wallLine.x2 }, 'Gray')
+                    findPoints.push({ y: aStartY, x: newPStart.x, position: 'left_out_start' })
+                  } else {
+                    const cLineY = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
+                    newPStart.y = Big(newPStart.y).minus(cLineY).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                    if (inLine) {
+                      if (inLine.x1 < inLine.x2) {
+                        getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                      }
+                    } else {
+                      //newPStart.y = wallLine.y1;
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber()
+                      newPStart.y = Big(wallBaseLine.y1).minus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                      if (inLine) {
+                        if (inLine.x2 > inLine.x1) {
+                          getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
+                  const aStartY = Big(roofLine.y2).plus(moveDist).toNumber()
+                  const bStartY = Big(wallLine.y2).plus(moveDist).toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
+                  console.log('startLines:::::::', inLine)
+                  const eLineY = Big(bStartY).minus(wallLine.y2).abs().toNumber()
+                  newPEnd.y = aStartY
+                  newPStart.y = roofLine.y1 //Big(roofLine.y1).plus(eLineY).toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const newLine = roofLines[idx + 1]
+
+                  if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
+                    if (inLine) {
+                      if (inLine.x1 < inLine.x2) {
+                        getAddLine({ y: bStartY, x: wallLine.x1 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x1 }, 'pink')
+                      }
+                    }
+                    getAddLine({ y: bStartY, x: wallLine.x1 }, { y: roofLine.y2, x: wallLine.x2 }, 'magenta')
+                    getAddLine({ y: newLine.y2, x: newLine.x2 }, { y: newLine.y1, x: wallLine.x1 }, 'Gray')
+                    findPoints.push({ y: aStartY, x: newPEnd.x, position: 'left_out_end' })
+                  } else {
+                    const cLineY = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
+                    newPEnd.y = Big(newPEnd.y).plus(cLineY).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                    if (inLine) {
+                      if (inLine.x1 < inLine.x2) {
+                        getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                      }
+                    } else {
+                      // newPEnd.y = wallLine.y2
+
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber()
+                      newPEnd.y = Big(wallBaseLine.y2).plus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                      if (inLine) {
+                        if (inLine.x2 > inLine.x1) {
+                          getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                  findPoints.push({ y: newPStart.y, x: newPEnd.x, position: 'left_out_end' })
+                }
+              } else if (condition === 'right_in') {
+                if (isStartEnd.start) {
+                  newPEnd.y = roofLine.y2
+                  newPEnd.x = roofLine.x2
+
+                  const moveDist = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
+                  ePoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 }
+                  newPStart.y = wallBaseLine.y1
+
+                  findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'right_in_start' })
+                  const newPointX = Big(roofLine.x1).minus(moveDist).abs().toNumber()
+                  const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
+                  const pLineY = Big(roofLine.y1).minus(0).abs().toNumber()
+                  let idx = 0 >= index - 1 ? roofLines.length : index
+                  const pLineX = roofLines[idx - 1].x1
+
+                  getAddLine({ x: newPStart.x, y: newPStart.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
+                  //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
+
+                  if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
+                    getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
+                  }
+                }
+
+                if (isStartEnd.end) {
+                  newPStart.y = roofLine.y1
+                  newPStart.x = roofLine.x1
+
+                  const moveDist = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
+                  ePoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 }
+                  newPEnd.y = wallBaseLine.y2
+
+                  findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'right_in_end' })
+                  const newPointX = Big(roofLine.x1).minus(moveDist).toNumber()
+                  const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
+                  const pLineY = Big(roofLine.y2).minus(0).abs().toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const pLineX = roofLines[idx + 1].x2
+
+                  getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
+                  getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: newPointX, y: roofLine.y1 }, 'orange')
+
+                  if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
+                    getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
+                  }
+                  getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
+                }
+              } else if (condition === 'right_out') {
+                console.log('right_out::::isStartEnd:::::', isStartEnd)
+                if (isStartEnd.start) {
+                  //x1 inside
+                  const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
+                  const aStartY = Big(roofLine.y1).plus(moveDist).abs().toNumber()
+                  const bStartY = Big(wallLine.y1).plus(moveDist).abs().toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
+                  console.log('startLines:::::::', inLine)
+                  const eLineY = Big(bStartY).minus(wallLine.y1).abs().toNumber()
+                  newPStart.y = aStartY
+                  newPEnd.y = roofLine.y2 //Big(roofLine.y2).plus(eLineY).toNumber()
+                  let idx = 0 >= index - 1 ? roofLines.length : index
+                  const newLine = roofLines[idx - 1]
+
+                  if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
+                    if (inLine) {
+                      if (inLine.x2 < inLine.x1) {
+                        getAddLine({ y: bStartY, x: wallLine.x2 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x2 }, 'pink')
+                      }
+                    }
+                    getAddLine({ y: bStartY, x: wallLine.x2 }, { y: roofLine.y1, x: wallLine.x1 }, 'magenta')
+                    getAddLine({ y: newLine.y1, x: newLine.x1 }, { y: newLine.y2, x: wallLine.x2 }, 'Gray')
+                    findPoints.push({ y: aStartY, x: newPEnd.x, position: 'right_out_start' })
+                  } else {
+                    const cLineY = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
+                    newPStart.y = Big(newPStart.y).plus(cLineY).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                    if (inLine) {
+                      if (inLine.x2 < inLine.x1) {
+                        getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                      }
+                    } else {
+                      //newPStart.y = wallLine.y1;
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.x1).minus(roofLine.x1).abs().toNumber()
+                      newPStart.y = Big(wallBaseLine.y1).plus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                      if (inLine) {
+                        if (inLine.x2 > inLine.x1) {
+                          getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
+                  const aStartY = Big(roofLine.y2).minus(moveDist).abs().toNumber()
+                  const bStartY = Big(wallLine.y2).minus(moveDist).abs().toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
+                  console.log('startLines:::::::', inLine)
+                  const eLineY = Big(bStartY).minus(wallLine.y2).abs().toNumber()
+                  newPEnd.y = aStartY
+                  newPStart.y = roofLine.y1 //Big(roofLine.y1).minus(eLineY).toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const newLine = roofLines[idx + 1]
+                  if (inLine) {
+                    if (inLine.x2 < inLine.x1) {
+                      getAddLine({ y: bStartY, x: wallLine.x1 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
+                    } else {
+                      getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x1 }, 'pink')
+                    }
+                  }
+                  if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
+                    getAddLine({ y: bStartY, x: wallLine.x1 }, { y: roofLine.y2, x: wallLine.x2 }, 'magenta')
+                    getAddLine({ y: newLine.y2, x: newLine.x2 }, { y: newLine.y1, x: wallLine.x1 }, 'Gray')
+                    findPoints.push({ y: aStartY, x: newPEnd.x, position: 'right_out_end' })
+                  } else {
+                    const cLineY = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
+                    newPEnd.y = Big(newPEnd.y).minus(cLineY).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                    if (inLine) {
+                      if (inLine.x2 < inLine.x1) {
+                        getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                      }
+                    } else {
+                      //newPEnd.y = wallLine.y2;
+
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber()
+                      newPEnd.y = Big(wallBaseLine.y2).minus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                      if (inLine) {
+                        if (inLine.x2 > inLine.x1) {
+                          getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else if (getOrientation(roofLine) === 'horizontal') {
+            //red
+
+            if (['top', 'bottom'].includes(mLine.position)) {
+              if (Math.abs(wallLine.y1 - wallBaseLine.y1) < 0.1 || Math.abs(wallLine.y2 - wallBaseLine.y2) < 0.1) {
+                return false
+              }
+              const isTopPosition = mLine.position === 'top'
+              const isBottomPosition = mLine.position === 'bottom'
+              const isInPosition =
+                (isTopPosition && wallLine.y1 < wallBaseLine.y1) ||
+                (isBottomPosition && wallLine.y1 > wallBaseLine.y1) ||
+                (isTopPosition && wallLine.y2 < wallBaseLine.y2) ||
+                (isBottomPosition && wallLine.y2 > wallBaseLine.y2)
+
+              const positionType = isInPosition ? 'in' : 'out'
+              const condition = `${mLine.position}_${positionType}`
+              let isStartEnd = findInteriorPoint(wallBaseLine, sortedBaseLines)
+
+              let sPoint, ePoint
+
+              if (condition === 'top_in') {
+                if (isStartEnd.start) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  sPoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 }
+                  newPStart.x = wallBaseLine.x1
+
+                  const newPointY = Big(roofLine.y2).plus(moveDist).toNumber()
+
+                  const pDist = Big(wallLine.y2).minus(roofLine.y2).abs().toNumber()
+                  const pLineX = Big(roofLine.x1).minus(0).toNumber()
+                  let idx = 0 >= index - 1 ? roofLines.length : index
+                  const pLineY = roofLines[idx - 1].y1
+                  getAddLine({ x: newPStart.x, y: newPStart.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
+                  findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'top_in_start' })
+
+                  if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
+                    getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
+                  }
+                  //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: roofLine.x2, y: newPointY }, 'orange')
+                }
+
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
+                  sPoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 }
+                  newPEnd.x = wallBaseLine.x2
+
+                  const newPointY = Big(roofLine.y1).plus(moveDist).toNumber()
+
+                  const pDist = Big(wallLine.y1).minus(roofLine.y1).abs().toNumber()
+                  const pLineX = Big(roofLine.x2).minus(0).abs().toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const pLineY = roofLines[idx + 1].y2
+                  getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
+                  findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'top_in_end' })
+
+                  if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
+                    getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
+                  }
+
+                  //getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: roofLine.x1, y: newPointY }, 'orange')
+                }
+              } else if (condition === 'top_out') {
+                console.log('top_out isStartEnd:::::::', isStartEnd)
+
+                if (isStartEnd.start) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  const aStartX = Big(roofLine.x1).plus(moveDist).toNumber()
+                  const bStartX = Big(wallLine.x1).plus(moveDist).toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: newPEnd.y })
+
+                  const eLineX = Big(bStartX).minus(wallLine.x1).abs().toNumber()
+                  newPEnd.x = roofLine.x2 //Big(newPEnd.x).plus(eLineX).toNumber()
+                  newPStart.x = aStartX
+                  let idx = 0 > index - 1 ? roofLines.length : index
+                  const newLine = roofLines[idx - 1]
+
+                  if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
+                    if (inLine) {
+                      if (inLine.y2 > inLine.y1) {
+                        getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
+                      } else {
+                        getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
+                      }
+                    }
+                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x1, y: wallLine.y1 }, 'magenta')
+                    getAddLine({ x: newLine.x1, y: newLine.y1 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
+                    findPoints.push({ x: aStartX, y: newPEnd.y, position: 'top_out_start' })
+                  } else {
+                    const cLineX = Big(wallBaseLine.y1).minus(wallLine.y1).abs().toNumber()
+                    newPStart.x = Big(newPStart.x).plus(cLineX).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                    if (inLine) {
+                      if (inLine.y2 > inLine.y1) {
+                        getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                      }
+                    } else {
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.y1).minus(roofLine.y1).abs().toNumber()
+                      newPStart.x = Big(wallBaseLine.x1).plus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                      if (inLine) {
+                        if (inLine.y2 > inLine.y1) {
+                          getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  const aStartX = Big(roofLine.x2).minus(moveDist).abs().toNumber()
+                  const bStartX = Big(wallLine.x2).minus(moveDist).abs().toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: newPEnd.y })
+                  console.log('startLines:::::::', inLine)
+                  const eLineX = Big(bStartX).minus(wallLine.x2).abs().toNumber()
+                  newPStart.x = roofLine.x1 //Big(newPStart.x).minus(eLineX).abs().toNumber()
+                  newPEnd.x = aStartX
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const newLine = roofLines[idx + 1]
+
+                  if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
+                    if (inLine) {
+                      if (inLine.y2 > inLine.y1) {
+                        getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
+                      } else {
+                        getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
+                      }
+                    }
+                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x2, y: wallLine.y2 }, 'magenta')
+                    getAddLine({ x: newLine.x2, y: newLine.y2 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
+                    findPoints.push({ x: aStartX, y: newPEnd.y, position: 'top_out_end' })
+                  } else {
+                    const cLineX = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
+                    newPEnd.x = Big(newPEnd.x).minus(cLineX).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                    if (inLine) {
+                      if (inLine.y2 > inLine.y1) {
+                        getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                      }
+                    } else {
+                      //newPEnd.x = wallLine.x2;
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.y2).minus(roofLine.y2).abs().toNumber()
+                      newPEnd.x = Big(wallBaseLine.x2).minus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                      if (inLine) {
+                        if (inLine.y1 > inLine.y2) {
+                          getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+              } else if (condition === 'bottom_in') {
+                if (isStartEnd.start) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  sPoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 }
+                  newPStart.x = wallBaseLine.x1
+
+                  const newPointY = Big(roofLine.y2).minus(moveDist).toNumber()
+
+                  const pDist = Big(wallLine.y2).minus(roofLine.y2).abs().toNumber()
+                  const pLineX = Big(roofLine.x1).minus(0).abs().toNumber()
+                  let idx = 0 > index - 1 ? roofLines.length : index
+                  const pLineY = roofLines[idx - 1].y1
+                  getAddLine({ x: newPStart.x, y: newPStart.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
+                  findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'bottom_in_start' })
+
+                  if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
+                    getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
+                  }
+                  getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: roofLine.x2, y: newPointY }, 'orange')
+                }
+
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
+                  sPoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 }
+                  newPEnd.x = wallBaseLine.x2
+
+                  const newPointY = Big(roofLine.y1).minus(moveDist).toNumber()
+
+                  const pDist = Big(wallLine.y1).minus(roofLine.y1).abs().toNumber()
+                  const pLineX = Big(roofLine.x2).minus(0).abs().toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const pLineY = roofLines[idx + 1].y2
+                  getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
+                  findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'bottom_in_end' })
+
+                  if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
+                    getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
+                    getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
+                  }
+                  getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: roofLine.x1, y: newPointY }, 'orange')
+                }
+              } else if (condition === 'bottom_out') {
+                console.log('bottom_out isStartEnd:::::::', isStartEnd)
+                if (isStartEnd.start) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  const aStartX = Big(roofLine.x1).minus(moveDist).abs().toNumber()
+                  const bStartX = Big(wallLine.x1).minus(moveDist).abs().toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: roofLine.y1 })
+                  console.log('startLines:::::::', inLine)
+                  const eLineX = Big(bStartX).minus(wallLine.x1).abs().toNumber()
+                  newPEnd.x = roofLine.x2 //Big(roofLine.x2).minus(eLineX).toNumber()
+                  newPStart.x = aStartX
+                  let idx = 0 > index - 1 ? roofLines.length : index
+                  const newLine = roofLines[idx - 1]
+
+                  if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
+                    if (inLine) {
+                      if (inLine.y2 < inLine.y1) {
+                        getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
+                      } else {
+                        getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
+                      }
+                    }
+                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x1, y: wallLine.y1 }, 'magenta')
+                    getAddLine({ x: newLine.x1, y: newLine.y1 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
+                    findPoints.push({ x: aStartX, y: newPEnd.y, position: 'bottom_out_start' })
+                  } else {
+                    const cLineX = Big(wallBaseLine.y1).minus(wallLine.y1).abs().toNumber()
+                    newPStart.x = Big(newPStart.x).minus(cLineX).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                    if (inLine) {
+                      if (inLine.y2 < inLine.y1) {
+                        getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                      }
+                    } else {
+                      //newPStart.x = wallLine.x1;
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.y1).minus(roofLine.y1).abs().toNumber()
+                      newPStart.x = Big(wallBaseLine.x1).minus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
+                      if (inLine) {
+                        if (inLine.y2 > inLine.y1) {
+                          getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPStart.y, x: newPStart.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+
+                if (isStartEnd.end) {
+                  const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
+                  const aStartX = Big(roofLine.x2).plus(moveDist).toNumber()
+                  const bStartX = Big(wallLine.x2).plus(moveDist).toNumber()
+                  const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: roofLine.y1 })
+                  console.log('startLines:::::::', inLine)
+                  const eLineX = Big(bStartX).minus(wallLine.x2).abs().toNumber()
+                  newPEnd.x = aStartX
+                  newPStart.x = roofLine.x1 //Big(roofLine.x1).plus(eLineX).toNumber()
+                  let idx = roofLines.length < index + 1 ? 0 : index
+                  const newLine = roofLines[idx + 1]
+
+                  if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
+                    if (inLine) {
+                      if (inLine.y2 < inLine.y1) {
+                        getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
+                      } else {
+                        getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
+                      }
+                    }
+                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x2, y: wallLine.y2 }, 'magenta')
+                    getAddLine({ x: newLine.x2, y: newLine.y2 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
+                    findPoints.push({ x: aStartX, y: newPEnd.y, position: 'bottom_out_end' })
+                  } else {
+                    const cLineX = Big(wallBaseLine.y2).minus(wallLine.y2).abs().toNumber()
+                    newPEnd.x = Big(newPEnd.x).plus(cLineX).toNumber()
+                    const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                    if (inLine) {
+                      if (inLine.y2 < inLine.y1) {
+                        getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                      } else {
+                        getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                      }
+                    } else {
+                      //newPEnd.x = wallLine.x2;
+                      //외곽 라인 그리기
+                      const rLineM = Big(wallBaseLine.y2).minus(roofLine.y2).abs().toNumber()
+                      newPEnd.x = Big(wallBaseLine.x2).plus(rLineM).abs().toNumber()
+                      const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
+                      if (inLine) {
+                        if (inLine.y1 > inLine.y2) {
+                          getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
+                        } else {
+                          getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          getAddLine(newPStart, newPEnd, 'red')
+          //canvas.remove(roofLine)
+        } else {
+          getAddLine(roofLine.startPoint, roofLine.endPoint)
+        }
+
+        canvas.renderAll()
       });
-
-      //coordinateText(line)
-      canvas.add(line)
-      line.bringToFront()
-      canvas.renderAll();
-      return line
-    }
-
-    //getAddLine(roofLine.startPoint, roofLine.endPoint, ) //외곽선을 그린다
-
-    newPStart = { x: roofLine.x1, y: roofLine.y1 }
-    newPEnd = { x: roofLine.x2, y: roofLine.y2 }
-
-    const getInnerLines = (lines, point) => {
-
-    }
-    let isIn = false
-    let isOut = false
-
-//두 포인트가 변경된 라인인
-    if (fullyMoved) {
-      //반시계방향향
-
-      const mLine = getSelectLinePosition(wall, wallBaseLine)
-
-      if (getOrientation(roofLine) === 'vertical') {
-
-        if (['left', 'right'].includes(mLine.position)) {
-          if (Math.abs(wallLine.x1 - wallBaseLine.x1) < 0.1 || Math.abs(wallLine.x2 - wallBaseLine.x2) < 0.1) {
-            return false
-          }
-          const positionType =
-            (mLine.position === 'left' && wallLine.x1 < wallBaseLine.x1) ||
-            (mLine.position === 'right' && wallLine.x1 > wallBaseLine.x1)
-              ? 'in' : 'out';
-          const condition = `${mLine.position}_${positionType}`;
-          let isStartEnd = findInteriorPoint(wallBaseLine, sortedBaseLines)
-          let sPoint, ePoint;
-          if (condition === 'left_in') {
-            isIn = true
-
-            if (isStartEnd.start) {
-              newPEnd.y = roofLine.y2;
-              newPEnd.x = roofLine.x2;
-
-              const moveDist = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
-              ePoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 };
-              newPStart.y = wallBaseLine.y1
-
-              findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'left_in_start' });
-              const newPointX = Big(roofLine.x1).plus(moveDist).abs().toNumber()
-              const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
-              const pLineY = Big(roofLine.y1).minus(0).abs().toNumber()
-              let idx = (0 > index - 1) ? roofLines.length : index
-              const pLineX = roofLines[idx - 1].x1
-
-              getAddLine({ x: newPStart.x, y: newPStart.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
-              getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
-
-              if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
-                getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
-              }
-            }
-
-            if (isStartEnd.end) {
-              newPStart.y = roofLine.y1;
-              newPStart.x = roofLine.x1;
-
-              const moveDist = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
-              ePoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 };
-              newPEnd.y = wallBaseLine.y2
-
-              findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'left_in_end' });
-              const newPointX = Big(roofLine.x1).plus(moveDist).toNumber()
-              const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
-              const pLineY = Big(roofLine.y2).minus(0).abs().toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const pLineX = roofLines[idx + 1].x2
-
-              getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
-              getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: newPointX, y: roofLine.y1 }, 'orange')
-
-              if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
-                getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
-              }
-              //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
-            }
-
-          } else if (condition === 'left_out') {
-            console.log("left_out::::isStartEnd:::::", isStartEnd);
-            if (isStartEnd.start) {
-
-              const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
-              const aStartY = Big(roofLine.y1).minus(moveDist).abs().toNumber()
-              const bStartY = Big(wallLine.y1).minus(moveDist).abs().toNumber()
-              const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x2 })
-
-              const eLineY = Big(bStartY).minus(wallLine.y1).abs().toNumber()
-              newPStart.y = aStartY
-              newPEnd.y = roofLine.y2 //Big(roofLine.y2).minus(eLineY).toNumber()
-              let idx = (0 >= index - 1) ? roofLines.length : index
-              const newLine = roofLines[idx - 1];
-
-              if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
-                if (inLine) {
-                  if (inLine.x1 < inLine.x2) {
-                    getAddLine({ y: bStartY, x: wallLine.x2 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
-                  } else {
-                    getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: bStartY, x: wallLine.x2 }, 'pink')
-                  }
-
-                }
-                getAddLine({ y: bStartY, x: wallLine.x2 }, { y: roofLine.y1, x: wallLine.x1 }, 'magenta')
-                getAddLine({ y: newLine.y1, x: newLine.x1 }, { y: newLine.y2, x: wallLine.x2 }, 'Gray')
-                findPoints.push({ y: aStartY, x: newPStart.x, position: 'left_out_start' });
-              } else {
-                const cLineY = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
-                newPStart.y = Big(newPStart.y).minus(cLineY).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                if (inLine) {
-                  if (inLine.x1 < inLine.x2) {
-                    getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                  }
-                } else {
-                  //newPStart.y = wallLine.y1;
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber();
-                  newPStart.y = Big(wallBaseLine.y1).minus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                  if (inLine) {
-                    if (inLine.x2 > inLine.x1) {
-                      getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-            }
-
-
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
-              const aStartY = Big(roofLine.y2).plus(moveDist).toNumber()
-              const bStartY = Big(wallLine.y2).plus(moveDist).toNumber()
-              const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
-              console.log("startLines:::::::", inLine);
-              const eLineY = Big(bStartY).minus(wallLine.y2).abs().toNumber()
-              newPEnd.y = aStartY
-              newPStart.y = roofLine.y1//Big(roofLine.y1).plus(eLineY).toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const newLine = roofLines[idx + 1];
-
-              if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
-                if (inLine) {
-                  if (inLine.x1 < inLine.x2) {
-                    getAddLine({ y: bStartY, x: wallLine.x1 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x1 }, 'pink')
-                  }
-                }
-                getAddLine({ y: bStartY, x: wallLine.x1 }, { y: roofLine.y2, x: wallLine.x2 }, 'magenta')
-                getAddLine({ y: newLine.y2, x: newLine.x2 }, { y: newLine.y1, x: wallLine.x1 }, 'Gray')
-                findPoints.push({ y: aStartY, x: newPEnd.x, position: 'left_out_end' });
-              } else {
-                const cLineY = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
-                newPEnd.y = Big(newPEnd.y).plus(cLineY).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                if (inLine) {
-                  if (inLine.x1 < inLine.x2) {
-                    getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                  }
-                } else {
-
-                  // newPEnd.y = wallLine.y2
-
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber();
-                  newPEnd.y = Big(wallBaseLine.y2).plus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                  if (inLine) {
-                    if (inLine.x2 > inLine.x1) {
-                      getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-              findPoints.push({ y: newPStart.y, x: newPEnd.x, position: 'left_out_end' });
-            }
-          } else if (condition === 'right_in') {
-            if (isStartEnd.start) {
-
-              newPEnd.y = roofLine.y2;
-              newPEnd.x = roofLine.x2;
-
-              const moveDist = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
-              ePoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 };
-              newPStart.y = wallBaseLine.y1
-
-              findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'right_in_start' });
-              const newPointX = Big(roofLine.x1).minus(moveDist).abs().toNumber()
-              const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
-              const pLineY = Big(roofLine.y1).minus(0).abs().toNumber()
-              let idx = (0 >= index - 1) ? roofLines.length : index
-              const pLineX = roofLines[idx - 1].x1
-
-              getAddLine({ x: newPStart.x, y: newPStart.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
-              //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
-
-              if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
-                getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
-              }
-            }
-
-            if (isStartEnd.end) {
-              newPStart.y = roofLine.y1;
-              newPStart.x = roofLine.x1;
-
-              const moveDist = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
-              ePoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 };
-              newPEnd.y = wallBaseLine.y2
-
-              findPoints.push({ x: ePoint.x, y: ePoint.y, position: 'right_in_end' });
-              const newPointX = Big(roofLine.x1).minus(moveDist).toNumber()
-              const pDist = Big(wallLine.x1).minus(roofLine.x1).abs().toNumber()
-              const pLineY = Big(roofLine.y2).minus(0).abs().toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const pLineX = roofLines[idx + 1].x2
-
-              getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: ePoint.x, y: ePoint.y }, 'blue')
-              getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: newPointX, y: roofLine.y1 }, 'orange')
-
-              if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: newPointX, y: pLineY }, 'green')
-                getAddLine({ x: newPointX, y: pLineY }, { x: ePoint.x, y: ePoint.y }, 'pink')
-              }
-              getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: newPointX, y: roofLine.y2 }, 'orange')
-            }
-
-          } else if (condition === 'right_out') {
-            console.log("right_out::::isStartEnd:::::", isStartEnd);
-            if (isStartEnd.start) { //x1 inside
-              const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
-              const aStartY = Big(roofLine.y1).plus(moveDist).abs().toNumber()
-              const bStartY = Big(wallLine.y1).plus(moveDist).abs().toNumber()
-              const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
-              console.log("startLines:::::::", inLine);
-              const eLineY = Big(bStartY).minus(wallLine.y1).abs().toNumber()
-              newPStart.y = aStartY
-              newPEnd.y = roofLine.y2//Big(roofLine.y2).plus(eLineY).toNumber()
-              let idx = (0 >= index - 1) ? roofLines.length : index
-              const newLine = roofLines[idx - 1];
-
-              if (Math.abs(wallBaseLine.y1 - wallLine.y1) < 0.1) {
-                if (inLine) {
-                  if (inLine.x2 < inLine.x1) {
-                    getAddLine({ y: bStartY, x: wallLine.x2 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x2 }, 'pink')
-                  }
-                }
-                getAddLine({ y: bStartY, x: wallLine.x2 }, { y: roofLine.y1, x: wallLine.x1 }, 'magenta')
-                getAddLine({ y: newLine.y1, x: newLine.x1 }, { y: newLine.y2, x: wallLine.x2 }, 'Gray')
-                findPoints.push({ y: aStartY, x: newPEnd.x, position: 'right_out_start' });
-              } else {
-                const cLineY = Big(wallBaseLine.x1).minus(wallLine.x1).abs().toNumber()
-                newPStart.y = Big(newPStart.y).plus(cLineY).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                if (inLine) {
-                  if (inLine.x2 < inLine.x1) {
-                    getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                  }
-                } else {
-                  //newPStart.y = wallLine.y1;
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.x1).minus(roofLine.x1).abs().toNumber();
-                  newPStart.y = Big(wallBaseLine.y1).plus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                  if (inLine) {
-                    if (inLine.x2 > inLine.x1) {
-                      getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                    }
-                  }
-
-                }
-
-              }
-
-            }
-
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.x1).minus(wallBaseLine.x1).abs().toNumber()
-              const aStartY = Big(roofLine.y2).minus(moveDist).abs().toNumber()
-              const bStartY = Big(wallLine.y2).minus(moveDist).abs().toNumber()
-              const inLine = findLineContainingPoint(innerLines, { y: aStartY, x: roofLine.x1 })
-              console.log("startLines:::::::", inLine);
-              const eLineY = Big(bStartY).minus(wallLine.y2).abs().toNumber()
-              newPEnd.y = aStartY
-              newPStart.y = roofLine.y1//Big(roofLine.y1).minus(eLineY).toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const newLine = roofLines[idx + 1];
-              if (inLine) {
-                if (inLine.x2 < inLine.x1) {
-                  getAddLine({ y: bStartY, x: wallLine.x1 }, { y: inLine.y2, x: inLine.x2 }, 'pink')
-                } else {
-                  getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: bStartY, x: wallLine.x1 }, 'pink')
-                }
-              }
-              if (Math.abs(wallBaseLine.y2 - wallLine.y2) < 0.1) {
-                getAddLine({ y: bStartY, x: wallLine.x1 }, { y: roofLine.y2, x: wallLine.x2 }, 'magenta')
-                getAddLine({ y: newLine.y2, x: newLine.x2 }, { y: newLine.y1, x: wallLine.x1 }, 'Gray')
-                findPoints.push({ y: aStartY, x: newPEnd.x, position: 'right_out_end' });
-              } else {
-                const cLineY = Big(wallBaseLine.x2).minus(wallLine.x2).abs().toNumber()
-                newPEnd.y = Big(newPEnd.y).minus(cLineY).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                if (inLine) {
-                  if (inLine.x2 < inLine.x1) {
-                    getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                  }
-                } else {
-                  //newPEnd.y = wallLine.y2;
-
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.x2).minus(roofLine.x2).abs().toNumber();
-                  newPEnd.y = Big(wallBaseLine.y2).minus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                  if (inLine) {
-                    if (inLine.x2 > inLine.x1) {
-                      getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                    }
-                  }
-
-                }
-
-              }
-            }
-          }
-        }
-      } else if (getOrientation(roofLine) === 'horizontal') { //red
-
-        if (['top', 'bottom'].includes(mLine.position)) {
-          if (Math.abs(wallLine.y1 - wallBaseLine.y1) < 0.1 || Math.abs(wallLine.y2 - wallBaseLine.y2) < 0.1) {
-            return false
-          }
-          const positionType =
-            (mLine.position === 'top' && wallLine.y1 < wallBaseLine.y1) ||
-            (mLine.position === 'bottom' && wallLine.y1 > wallBaseLine.y1)
-              ? 'in' : 'out';
-
-          const condition = `${mLine.position}_${positionType}`;
-          let isStartEnd = findInteriorPoint(wallBaseLine, sortedBaseLines)
-
-          let sPoint, ePoint;
-
-          if (condition === 'top_in') {
-            if (isStartEnd.start) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              sPoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 };
-              newPStart.x = wallBaseLine.x1;
-
-
-              const newPointY = Big(roofLine.y2).plus(moveDist).toNumber()
-
-              const pDist = Big(wallLine.y2).minus(roofLine.y2).abs().toNumber()
-              const pLineX = Big(roofLine.x1).minus(0).abs().toNumber()
-              let idx = (0 >= index - 1) ? roofLines.length : index
-              const pLineY = roofLines[idx - 1].y1
-              getAddLine({ x: newPStart.x, y: newPStart.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
-              findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'top_in_start' });
-
-              if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
-                getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
-              }
-              //getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: roofLine.x2, y: newPointY }, 'orange')
-
-            }
-
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
-              sPoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 }
-              newPEnd.x = wallBaseLine.x2
-
-              const newPointY = Big(roofLine.y1).plus(moveDist).toNumber()
-
-              const pDist = Big(wallLine.y1).minus(roofLine.y1).abs().toNumber()
-              const pLineX = Big(roofLine.x2).minus(0).abs().toNumber()
-              let idx = roofLines.length < index + 1 ? 0 : index
-              const pLineY = roofLines[idx + 1].y2
-              getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
-              findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'top_in_end' });
-
-              if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
-                getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
-              }
-
-
-              //getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: roofLine.x1, y: newPointY }, 'orange')
-            }
-
-          } else if (condition === 'top_out') {
-            console.log("top_out isStartEnd:::::::", isStartEnd);
-
-            if (isStartEnd.start) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              const aStartX = Big(roofLine.x1).plus(moveDist).toNumber()
-              const bStartX = Big(wallLine.x1).plus(moveDist).toNumber()
-              const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: newPEnd.y })
-
-              const eLineX = Big(bStartX).minus(wallLine.x1).abs().toNumber()
-              newPEnd.x = roofLine.x2 //Big(newPEnd.x).plus(eLineX).toNumber()
-              newPStart.x = aStartX
-              let idx = (0 > index - 1) ? roofLines.length : index
-              const newLine = roofLines[idx - 1];
-
-              if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
-                if (inLine) {
-                  if (inLine.y2 > inLine.y1) {
-                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
-                  } else {
-                    getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
-                  }
-                }
-                getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x1, y: wallLine.y1 }, 'magenta')
-                getAddLine({ x: newLine.x1, y: newLine.y1 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
-                findPoints.push({ x: aStartX, y: newPEnd.y, position: 'top_out_start' });
-              } else {
-                const cLineX = Big(wallBaseLine.y1).minus(wallLine.y1).abs().toNumber()
-                newPStart.x = Big(newPStart.x).plus(cLineX).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                if (inLine) {
-                  if (inLine.y2 > inLine.y1) {
-                    getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                  }
-
-                } else {
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.y1).minus(roofLine.y1).abs().toNumber();
-                  newPStart.x = Big(wallBaseLine.x1).plus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                  if (inLine) {
-                    if (inLine.y2 > inLine.y1) {
-                      getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-            }
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              const aStartX = Big(roofLine.x2).minus(moveDist).abs().toNumber()
-              const bStartX = Big(wallLine.x2).minus(moveDist).abs().toNumber()
-              const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: newPEnd.y })
-              console.log("startLines:::::::", inLine);
-              const eLineX = Big(bStartX).minus(wallLine.x2).abs().toNumber()
-              newPStart.x = roofLine.x1;//Big(newPStart.x).minus(eLineX).abs().toNumber()
-              newPEnd.x = aStartX
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const newLine = roofLines[idx + 1];
-
-              if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
-                if (inLine) {
-                  if (inLine.y2 > inLine.y1) {
-                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
-                  } else {
-                    getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
-                  }
-
-                }
-                getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x2, y: wallLine.y2 }, 'magenta')
-                getAddLine({ x: newLine.x2, y: newLine.y2 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
-                findPoints.push({ x: aStartX, y: newPEnd.y, position: 'top_out_end' });
-              } else {
-                const cLineX = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
-                newPEnd.x = Big(newPEnd.x).minus(cLineX).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                if (inLine) {
-                  if (inLine.y2 > inLine.y1) {
-                    getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                  }
-                } else {
-                  //newPEnd.x = wallLine.x2;
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.y2).minus(roofLine.y2).abs().toNumber();
-                  newPEnd.x = Big(wallBaseLine.x2).minus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                  if (inLine) {
-                    if (inLine.y1 > inLine.y2) {
-                      getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-            }
-          } else if (condition === 'bottom_in') {
-            if (isStartEnd.start) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              sPoint = { x: wallBaseLine.x1, y: wallBaseLine.y1 };
-              newPStart.x = wallBaseLine.x1;
-
-
-              const newPointY = Big(roofLine.y2).minus(moveDist).toNumber()
-
-              const pDist = Big(wallLine.y2).minus(roofLine.y2).abs().toNumber()
-              const pLineX = Big(roofLine.x1).minus(0).abs().toNumber()
-              let idx = (0 > index - 1) ? roofLines.length : index
-              const pLineY = roofLines[idx - 1].y1
-              getAddLine({ x: newPStart.x, y: newPStart.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
-              findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'bottom_in_start' });
-
-              if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
-                getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
-              }
-              getAddLine({ x: roofLine.x2, y: roofLine.y2 }, { x: roofLine.x2, y: newPointY }, 'orange')
-            }
-
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.y2).minus(wallBaseLine.y2).abs().toNumber()
-              sPoint = { x: wallBaseLine.x2, y: wallBaseLine.y2 };
-              newPEnd.x = wallBaseLine.x2;
-
-
-              const newPointY = Big(roofLine.y1).minus(moveDist).toNumber()
-
-              const pDist = Big(wallLine.y1).minus(roofLine.y1).abs().toNumber()
-              const pLineX = Big(roofLine.x2).minus(0).abs().toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const pLineY = roofLines[idx + 1].y2
-              getAddLine({ x: newPEnd.x, y: newPEnd.y }, { x: sPoint.x, y: sPoint.y }, 'blue')
-              findPoints.push({ x: sPoint.x, y: sPoint.y, position: 'bottom_in_end' });
-
-              if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
-                getAddLine({ x: pLineX, y: pLineY }, { x: pLineX, y: newPointY }, 'green')
-                getAddLine({ x: pLineX, y: newPointY }, { x: sPoint.x, y: sPoint.y }, 'pink')
-              }
-              getAddLine({ x: roofLine.x1, y: roofLine.y1 }, { x: roofLine.x1, y: newPointY }, 'orange')
-
-            }
-          } else if (condition === 'bottom_out') {
-            console.log("bottom_out isStartEnd:::::::", isStartEnd);
-            if (isStartEnd.start) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              const aStartX = Big(roofLine.x1).minus(moveDist).abs().toNumber()
-              const bStartX = Big(wallLine.x1).minus(moveDist).abs().toNumber()
-              const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: roofLine.y1 })
-              console.log("startLines:::::::", inLine);
-              const eLineX = Big(bStartX).minus(wallLine.x1).abs().toNumber()
-              newPEnd.x = roofLine.x2//Big(roofLine.x2).minus(eLineX).toNumber()
-              newPStart.x = aStartX
-              let idx = (0 > index - 1) ? roofLines.length : index
-              const newLine = roofLines[idx - 1];
-
-
-              if (Math.abs(wallBaseLine.x1 - wallLine.x1) < 0.1) {
-                if (inLine) {
-                  if (inLine.y2 < inLine.y1) {
-                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
-                  } else {
-                    getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
-                  }
-                }
-                getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x1, y: wallLine.y1 }, 'magenta')
-                getAddLine({ x: newLine.x1, y: newLine.y1 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
-                findPoints.push({ x: aStartX, y: newPEnd.y, position: 'bottom_out_start' });
-              } else {
-                const cLineX = Big(wallBaseLine.y1).minus(wallLine.y1).abs().toNumber()
-                newPStart.x = Big(newPStart.x).minus(cLineX).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                if (inLine) {
-                  if (inLine.y2 < inLine.y1) {
-                    getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                  }
-                } else {
-                  //newPStart.x = wallLine.x1;
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.y1).minus(roofLine.y1).abs().toNumber();
-                  newPStart.x = Big(wallBaseLine.x1).minus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPStart.y, x: newPStart.x })
-                  if (inLine) {
-                    if (inLine.y2 > inLine.y1) {
-                      getAddLine({ y: newPStart.y, x: newPStart.x }, { y: inLine.y1, x: inLine.x1 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y2, x: inLine.x2 }, { y: newPStart.y, x: newPStart.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-            }
-
-            if (isStartEnd.end) {
-              const moveDist = Big(wallLine.y1).minus(wallBaseLine.y1).abs().toNumber()
-              const aStartX = Big(roofLine.x2).plus(moveDist).toNumber()
-              const bStartX = Big(wallLine.x2).plus(moveDist).toNumber()
-              const inLine = findLineContainingPoint(innerLines, { x: aStartX, y: roofLine.y1 })
-              console.log("startLines:::::::", inLine);
-              const eLineX = Big(bStartX).minus(wallLine.x2).abs().toNumber()
-              newPEnd.x = aStartX
-              newPStart.x = roofLine.x1;//Big(roofLine.x1).plus(eLineX).toNumber()
-              let idx = (roofLines.length < index + 1) ? 0 : index
-              const newLine = roofLines[idx + 1];
-
-              if (Math.abs(wallBaseLine.x2 - wallLine.x2) < 0.1) {
-                if (inLine) {
-                  if (inLine.y2 < inLine.y1) {
-                    getAddLine({ x: bStartX, y: wallLine.y1 }, { x: inLine.x2, y: inLine.y2 }, 'pink')
-                  } else {
-                    getAddLine({ x: inLine.x1, y: inLine.y1 }, { x: bStartX, y: wallLine.y1 }, 'pink')
-                  }
-                }
-                getAddLine({ x: bStartX, y: wallLine.y1 }, { x: roofLine.x2, y: wallLine.y2 }, 'magenta')
-                getAddLine({ x: newLine.x2, y: newLine.y2 }, { x: newLine.x1, y: wallLine.y1 }, 'Gray')
-                findPoints.push({ x: aStartX, y: newPEnd.y, position: 'bottom_out_end' });
-              } else {
-                const cLineX = Big(wallBaseLine.y2).minus(wallLine.y2).abs().toNumber()
-                newPEnd.x = Big(newPEnd.x).plus(cLineX).toNumber();
-                const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                if (inLine) {
-                  if (inLine.y2 < inLine.y1) {
-                    getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                  } else {
-                    getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                  }
-                } else {
-                  //newPEnd.x = wallLine.x2;
-                  //외곽 라인 그리기
-                  const rLineM = Big(wallBaseLine.y2).minus(roofLine.y2).abs().toNumber();
-                  newPEnd.x = Big(wallBaseLine.x2).plus(rLineM).abs().toNumber();
-                  const inLine = findLineContainingPoint(innerLines, { y: newPEnd.y, x: newPEnd.x })
-                  if (inLine) {
-                    if (inLine.y1 > inLine.y2) {
-                      getAddLine({ y: newPEnd.y, x: newPEnd.x }, { y: inLine.y2, x: inLine.x2 }, 'purple')
-                    } else {
-                      getAddLine({ y: inLine.y1, x: inLine.x1 }, { y: newPEnd.y, x: newPEnd.x }, 'purple')
-                    }
-                  }
-                }
-
-              }
-            }
-          }
-        }
-      }
-
-      getAddLine(newPStart, newPEnd, 'red')
-      //canvas.remove(roofLine)
-    } else {
-      getAddLine(roofLine.startPoint, roofLine.endPoint,)
-    }
-
-
-    canvas.renderAll()
-  });
 }
     getMoveUpDownLine()
 
@@ -2360,6 +2338,14 @@ function isSamePoint(p1, p2, tolerance = 0.1) {
   return Math.abs(p1.x - p2.x) < tolerance && Math.abs(p1.y - p2.y) < tolerance;
 }
 
+function isSameLine2(line1, line2, tolerance = 0.1) {
+  return (
+    Math.abs(line1.x1 - line2.x1) < tolerance &&
+    Math.abs(line1.y1 - line2.y1) < tolerance &&
+    Math.abs(line1.x2 - line2.x2) < tolerance &&
+    Math.abs(line1.y2 - line2.y2) < tolerance
+  );
+}
 // 두 점을 지나는 직선의 기울기 계산
 function calculateSlope(p1, p2) {
   // 수직선인 경우 (기울기 무한대)