1009 lines
38 KiB
JavaScript
1009 lines
38 KiB
JavaScript
import { useRecoilState, useRecoilValue, useResetRecoilState } from 'recoil'
|
|
import { canvasState, currentAngleTypeSelector, currentObjectState } from '@/store/canvasAtom'
|
|
import { useContext, useEffect, useState } from 'react'
|
|
import { useAxios } from '@/hooks/useAxios'
|
|
import { useSwal } from '@/hooks/useSwal'
|
|
import { usePolygon } from '@/hooks/usePolygon'
|
|
import {
|
|
addedRoofsState,
|
|
basicSettingState,
|
|
correntObjectNoState,
|
|
corridorDimensionSelector,
|
|
outlineDisplaySelector,
|
|
roofDisplaySelector,
|
|
roofMaterialsSelector,
|
|
selectedRoofMaterialSelector,
|
|
} from '@/store/settingAtom'
|
|
import { usePopup } from '@/hooks/usePopup'
|
|
import { POLYGON_TYPE } from '@/common/common'
|
|
import { v4 as uuidv4 } from 'uuid'
|
|
import ActualSizeSetting from '@/components/floor-plan/modal/roofAllocation/ActualSizeSetting'
|
|
import { useMessage } from '@/hooks/useMessage'
|
|
import { useCanvasMenu } from '@/hooks/common/useCanvasMenu'
|
|
import { useRoofFn } from '@/hooks/common/useRoofFn'
|
|
import { globalLocaleStore } from '@/store/localeAtom'
|
|
import { getChonByDegree, getDegreeByChon } from '@/util/canvas-util'
|
|
import { moduleSelectionDataState } from '@/store/selectedModuleOptions'
|
|
import { useCanvasPopupStatusController } from '@/hooks/common/useCanvasPopupStatusController'
|
|
import { outerLinePointsState } from '@/store/outerLineAtom'
|
|
import { QcastContext } from '@/app/QcastProvider'
|
|
import { usePlan } from '@/hooks/usePlan'
|
|
import { roofsState } from '@/store/roofAtom'
|
|
import { useText } from '@/hooks/useText'
|
|
import { QLine } from '@/components/fabric/QLine'
|
|
import { calcLineActualSize2 } from '@/util/qpolygon-utils'
|
|
|
|
export function useRoofAllocationSetting(id) {
|
|
const canvas = useRecoilValue(canvasState)
|
|
const [correntObjectNo, setCorrentObjectNo] = useRecoilState(correntObjectNoState)
|
|
const roofDisplay = useRecoilValue(roofDisplaySelector)
|
|
const { drawDirectionArrow, addLengthText, splitPolygonWithLines, splitPolygonWithSeparate } = usePolygon()
|
|
const [popupId, setPopupId] = useState(uuidv4())
|
|
const { addPopup, closePopup, closeAll } = usePopup()
|
|
const currentObject = useRecoilValue(currentObjectState)
|
|
const { setSelectedMenu } = useCanvasMenu()
|
|
const roofMaterials = useRecoilValue(roofMaterialsSelector)
|
|
const selectedRoofMaterial = useRecoilValue(selectedRoofMaterialSelector)
|
|
const [basicSetting, setBasicSetting] = useRecoilState(basicSettingState)
|
|
const [currentRoofMaterial, setCurrentRoofMaterial] = useState(roofMaterials[0])
|
|
/** 팝업 내 기준 지붕재 */
|
|
const [roofList, setRoofList] = useRecoilState(addedRoofsState)
|
|
/** 배치면 초기설정에서 선택한 지붕재 배열 */
|
|
const [editingLines, setEditingLines] = useState([])
|
|
const [currentRoofList, setCurrentRoofList] = useState([])
|
|
const currentAngleType = useRecoilValue(currentAngleTypeSelector)
|
|
const globalLocaleState = useRecoilValue(globalLocaleStore)
|
|
const [basicInfo, setBasicInfo] = useState(null)
|
|
const { get, post } = useAxios(globalLocaleState)
|
|
const { getMessage } = useMessage()
|
|
const { swalFire } = useSwal()
|
|
const { setIsGlobalLoading } = useContext(QcastContext)
|
|
const { setSurfaceShapePattern } = useRoofFn()
|
|
const { saveCanvas } = usePlan()
|
|
const [roofsStore, setRoofsStore] = useRecoilState(roofsState)
|
|
const [moduleSelectionData, setModuleSelectionData] = useRecoilState(moduleSelectionDataState)
|
|
const outerLinePoints = useRecoilValue(outerLinePointsState)
|
|
const resetPoints = useResetRecoilState(outerLinePointsState)
|
|
const [corridorDimension, setCorridorDimension] = useRecoilState(corridorDimensionSelector)
|
|
const { changeCorridorDimensionText } = useText()
|
|
const outlineDisplay = useRecoilValue(outlineDisplaySelector)
|
|
|
|
useEffect(() => {
|
|
/** 배치면 초기설정에서 선택한 지붕재 배열 설정 */
|
|
setCurrentRoofList(roofList)
|
|
}, [])
|
|
|
|
useEffect(() => {
|
|
/** 지붕면 조회 */
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF) /** roofPolygon.innerLines */
|
|
|
|
roofBases.forEach((roof) => {
|
|
roof.innerLines.forEach((line) => {
|
|
/** 실측값이 없는 경우 라인 두께 4로 설정 */
|
|
if (!line.attributes.actualSize || line.attributes?.actualSize === 0) {
|
|
line.set({ strokeWidth: 4, stroke: 'black', selectable: true })
|
|
}
|
|
|
|
/** 현재 선택된 라인인 경우 라인 두께 2로 설정 */
|
|
if (editingLines.includes(line)) {
|
|
line.set({ strokeWidth: 2, stroke: 'black', selectable: true })
|
|
}
|
|
})
|
|
})
|
|
|
|
/** 현재 선택된 객체가 보조라인, 피라미드, 힙인 경우 두께 4로 설정 */
|
|
if (currentObject && currentObject.name && ['auxiliaryLine', 'ridge', 'hip'].includes(currentObject.name)) {
|
|
currentObject.set({ strokeWidth: 4, stroke: '#EA10AC' })
|
|
}
|
|
}, [currentObject])
|
|
|
|
useEffect(() => {
|
|
/** 현재 선택된 객체가 보조라인, 피라미드, 힙인 경우 두께 4로 설정 */
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF)
|
|
if (roofBases.length === 0) {
|
|
swalFire({ text: getMessage('roofAllocation.not.found'), icon: 'warning' })
|
|
closePopup(id)
|
|
}
|
|
|
|
/** 배치면 초기설정 조회 */
|
|
fetchBasicSettings(basicSetting.planNo)
|
|
}, [])
|
|
|
|
/**
|
|
* 배치면 초기설정 조회
|
|
*/
|
|
const fetchBasicSettings = async (planNo) => {
|
|
try {
|
|
const response = await get({ url: `/api/canvas-management/canvas-basic-settings/by-object/${correntObjectNo}/${planNo}` })
|
|
|
|
let roofsArray = []
|
|
|
|
// API에서 데이터를 성공적으로 가져온 경우
|
|
if (response && response.length > 0) {
|
|
roofsArray = response.map((item, index) => ({
|
|
planNo: item.planNo,
|
|
roofApply: item.roofApply,
|
|
roofSeq: item.roofSeq || index,
|
|
roofMatlCd: item.roofMatlCd,
|
|
roofWidth: item.roofWidth,
|
|
roofHeight: item.roofHeight,
|
|
roofHajebichi: item.roofHajebichi,
|
|
roofGap: item.roofGap,
|
|
roofLayout: item.roofLayout,
|
|
roofPitch: item.roofPitch,
|
|
roofAngle: item.roofAngle,
|
|
selected: index === 0, // 첫 번째 항목을 기본 선택으로 설정
|
|
index: index,
|
|
}))
|
|
}
|
|
// API에서 데이터가 없고 기존 roofList가 있는 경우
|
|
else if (roofList && roofList.length > 0) {
|
|
roofsArray = roofList.map((roof, index) => ({
|
|
...roof,
|
|
selected: index === 0, // 첫 번째 항목을 기본 선택으로 설정
|
|
}))
|
|
}
|
|
// 둘 다 없는 경우 기본값 설정
|
|
else {
|
|
roofsArray = [
|
|
{
|
|
planNo: planNo,
|
|
roofApply: true,
|
|
roofSeq: 0,
|
|
roofMatlCd: 'ROOF_ID_WA_53A',
|
|
roofWidth: 265,
|
|
roofHeight: 235,
|
|
roofHajebichi: 0,
|
|
roofGap: 'HEI_455',
|
|
roofLayout: 'P',
|
|
roofPitch: 4,
|
|
roofAngle: 21.8,
|
|
},
|
|
]
|
|
}
|
|
|
|
/**
|
|
* 데이터 설정
|
|
*/
|
|
const selectRoofs = []
|
|
for (let i = 0; i < roofsArray.length; i++) {
|
|
roofMaterials?.map((material) => {
|
|
if (material.roofMatlCd === roofsArray[i].roofMatlCd) {
|
|
selectRoofs.push({
|
|
...material,
|
|
selected: roofsArray[i].roofApply,
|
|
index: roofsArray[i].roofSeq,
|
|
id: roofsArray[i].roofMatlCd,
|
|
width: roofsArray[i].roofWidth,
|
|
length: roofsArray[i].roofHeight,
|
|
hajebichi: roofsArray[i].roofHajebichi,
|
|
raft: roofsArray[i].roofGap,
|
|
layout: roofsArray[i].roofLayout,
|
|
pitch: roofsArray[i].roofPitch,
|
|
angle: roofsArray[i].roofAngle,
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
const firstRes = Array.isArray(response) && response.length > 0 ? response[0] : null
|
|
|
|
setBasicSetting({
|
|
...basicSetting,
|
|
planNo: firstRes?.planNo ?? planNo,
|
|
roofSizeSet: firstRes?.roofSizeSet ?? 0,
|
|
roofAngleSet: firstRes?.roofAngleSet ?? 0,
|
|
roofsData: roofsArray,
|
|
selectedRoofMaterial: selectRoofs.find((roof) => roof.selected),
|
|
})
|
|
|
|
setBasicInfo({
|
|
planNo: '' + (firstRes?.planNo ?? planNo),
|
|
roofSizeSet: '' + (firstRes?.roofSizeSet ?? 0),
|
|
roofAngleSet: '' + (firstRes?.roofAngleSet ?? 0),
|
|
})
|
|
// 데이터 동기화: 렌더링용 필드 기본값 보정
|
|
const normalizedRoofs = selectRoofs.map((roof) => ({
|
|
...roof,
|
|
width: roof.width ?? '',
|
|
length: roof.length ?? '',
|
|
hajebichi: roof.hajebichi ?? '',
|
|
pitch: roof.pitch ?? '',
|
|
angle: roof.angle ?? '',
|
|
}))
|
|
setCurrentRoofList(normalizedRoofs)
|
|
} catch (error) {
|
|
console.error('Data fetching error:', error)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지붕면 할당 저장
|
|
*/
|
|
const basicSettingSave = async () => {
|
|
try {
|
|
setIsGlobalLoading(true)
|
|
const patternData = {
|
|
objectNo: correntObjectNo,
|
|
planNo: Number(basicSetting.planNo),
|
|
roofSizeSet: Number(basicSetting.roofSizeSet),
|
|
roofAngleSet: basicSetting.roofAngleSet,
|
|
roofAllocationList: currentRoofList.map((item, index) => ({
|
|
planNo: Number(basicSetting.planNo),
|
|
roofApply: item.selected,
|
|
roofSeq: index,
|
|
roofMatlCd: item.roofMatlCd === null || item.roofMatlCd === undefined ? 'ROOF_ID_WA_53A' : item.roofMatlCd,
|
|
roofWidth: item.width === null || item.width === undefined ? 0 : Number(item.width),
|
|
roofHeight: item.length === null || item.length === undefined ? 0 : Number(item.length),
|
|
roofHajebichi: item.hajebichi === null || item.hajebichi === undefined ? 0 : Number(item.hajebichi),
|
|
roofGap: !item.raft ? item.raftBaseCd : item.raft,
|
|
roofLayout: item.layout === null || item.layout === undefined ? 'P' : item.layout,
|
|
roofPitch: item.pitch === null || item.pitch === undefined ? 4 : Number(item.pitch),
|
|
roofAngle: item.angle === null || item.angle === undefined ? 21.8 : Number(item.angle),
|
|
})),
|
|
}
|
|
|
|
await post({ url: `/api/canvas-management/roof-allocation-settings`, data: patternData }).then((res) => {
|
|
setIsGlobalLoading(false)
|
|
})
|
|
|
|
//Recoil 설정
|
|
//setCanvasSetting({ ...basicSetting })
|
|
|
|
/** 배치면 초기설정 조회 */
|
|
fetchBasicSettings(basicSetting.planNo)
|
|
} catch (error) {
|
|
swalFire({ text: error.message, icon: 'error' })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지붕재 추가
|
|
*/
|
|
const onAddRoofMaterial = () => {
|
|
if (currentRoofList.length >= 4) {
|
|
swalFire({ type: 'alert', icon: 'error', text: getMessage('roof.exceed.count') })
|
|
return
|
|
}
|
|
|
|
const originCurrentRoofList = currentRoofList.map((roof) => {
|
|
return { ...roof, selected: false }
|
|
})
|
|
originCurrentRoofList.push({
|
|
...currentRoofMaterial,
|
|
selected: true,
|
|
id: currentRoofMaterial.roofMatlCd,
|
|
name: currentRoofMaterial.roofMatlNm,
|
|
index: currentRoofList.length,
|
|
})
|
|
|
|
setCurrentRoofList(originCurrentRoofList)
|
|
}
|
|
|
|
/**
|
|
* 지붕재 삭제
|
|
*/
|
|
const onDeleteRoofMaterial = (idx) => {
|
|
const roofs = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF)
|
|
|
|
for (let i = 0; i < roofs.length; i++) {
|
|
if (roofs[i].roofMaterial?.index === idx) {
|
|
swalFire({ type: 'alert', icon: 'error', text: getMessage('roof.material.can.not.delete') })
|
|
return
|
|
}
|
|
}
|
|
|
|
const isSelected = currentRoofList[idx].selected
|
|
const newRoofList = JSON.parse(JSON.stringify(currentRoofList)).filter((_, index) => index !== idx)
|
|
if (isSelected) {
|
|
newRoofList[0].selected = true
|
|
}
|
|
setCurrentRoofList(newRoofList)
|
|
setRoofsStore(newRoofList)
|
|
setModuleSelectionData({ ...moduleSelectionData, roofConstructions: newRoofList })
|
|
}
|
|
|
|
/**
|
|
* 선택한 지붕재로 할당
|
|
*/
|
|
const handleSave = () => {
|
|
/**
|
|
* 모두 actualSize 있으면 바로 적용 없으면 actualSize 설정
|
|
*/
|
|
if (checkInnerLines()) {
|
|
addPopup(popupId, 1, <ActualSizeSetting id={popupId} />)
|
|
} else {
|
|
apply()
|
|
|
|
resetPoints()
|
|
|
|
basicSettingSave()
|
|
}
|
|
//기존 지붕 선은 남겨둔다.
|
|
drawOriginRoofLine()
|
|
}
|
|
|
|
const drawOriginRoofLine = () => {
|
|
const wallLines = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.WALL)
|
|
/** 벽면 삭제 */
|
|
wallLines.forEach((wallLine) => {
|
|
wallLine.set({
|
|
stroke: 'black',
|
|
strokeDashArray: [5, 2],
|
|
strokeWidth: 1,
|
|
selectable: false,
|
|
name: 'originRoofOuterLine',
|
|
visible: outlineDisplay,
|
|
})
|
|
wallLine.texts.forEach((text) => {
|
|
canvas.remove(text)
|
|
})
|
|
})
|
|
canvas.renderAll()
|
|
}
|
|
|
|
/**
|
|
* 지붕재 오른쪽 마우스 클릭 후 단일로 지붕재 변경 필요한 경우
|
|
*/
|
|
const handleSaveContext = () => {
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (roof.index !== idx) {
|
|
// 기존 저장된 지붕재의 index 수정
|
|
const roofs = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF && obj.roofMaterial?.index === roof.index)
|
|
roofs.forEach((roof) => {
|
|
setSurfaceShapePattern(roof, roofDisplay.column, false, { ...roof, index: idx }, true)
|
|
})
|
|
}
|
|
|
|
return { ...roof, index: idx, raft: roof.raft ? roof.raft : roof.raftBaseCd }
|
|
})
|
|
|
|
setBasicSetting((prev) => {
|
|
return { ...prev, selectedRoofMaterial: newRoofList.find((roof) => roof.selected) }
|
|
})
|
|
const selectedRoofMaterial = newRoofList.find((roof) => roof.selected)
|
|
const roofs = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF && obj.roofMaterial?.index === selectedRoofMaterial.index)
|
|
|
|
roofs.forEach((roof) => {
|
|
setSurfaceShapePattern(roof, roofDisplay.column, false, { ...selectedRoofMaterial }, true)
|
|
drawDirectionArrow(roof)
|
|
})
|
|
|
|
setRoofList(newRoofList)
|
|
setRoofMaterials(newRoofList)
|
|
setRoofsStore(newRoofList)
|
|
|
|
setSurfaceShapePattern(currentObject, roofDisplay.column, false, selectedRoofMaterial, true)
|
|
drawDirectionArrow(currentObject)
|
|
modifyModuleSelectionData()
|
|
// closeAll()
|
|
closePopup(id)
|
|
basicSettingSave()
|
|
setModuleSelectionData({ ...moduleSelectionData, roofConstructions: newRoofList })
|
|
}
|
|
|
|
/**
|
|
* 기존 세팅된 지붕에 지붕재 내용을 바뀐 내용으로 수정
|
|
* @param newRoofMaterials
|
|
*/
|
|
const setRoofMaterials = (newRoofMaterials) => {
|
|
const roofs = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF)
|
|
newRoofMaterials.forEach((roofMaterial) => {
|
|
const index = roofMaterial.index
|
|
const tempRoofs = roofs.filter((roof) => roof.roofMaterial?.index === index)
|
|
tempRoofs.forEach((roof) => {
|
|
setSurfaceShapePattern(roof, roofDisplay.column, false, roofMaterial)
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* 지붕면 할당
|
|
*/
|
|
const handleAlloc = () => {
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF) // roofPolygon.innerLines
|
|
roofBases.forEach((roof) => {
|
|
if (roof.separatePolygon.length === 0) {
|
|
roof.innerLines.forEach((line) => {
|
|
if ((!line.attributes.actualSize || line.attributes?.actualSize === 0) && line.length > 1) {
|
|
// ─────────────────────────────────────────────────────────────────
|
|
// [hip actualSize fallback 2026-04-30]
|
|
// 기존: actualSize 미설정/0 시 planeSize 로 fallback → diagonal(hip)
|
|
// 까지 actualSize=planeSize 가 되어 伏せ図/配置面 라벨 토글 무효화.
|
|
// 수정: diagonal 은 pitch 로 actualSize 산출(calcLineActualSize2),
|
|
// horizontal/vertical 만 planeSize fallback 유지.
|
|
// pitch 우선순위: line.attributes.pitch → roof.attributes.pitch
|
|
// → roof.roofMaterial.pitch → 0(편평).
|
|
// ─────────────────────────────────────────────────────────────────
|
|
const dx = Math.abs((line.x2 ?? 0) - (line.x1 ?? 0))
|
|
const dy = Math.abs((line.y2 ?? 0) - (line.y1 ?? 0))
|
|
const isDiagonal = dx > 0.5 && dy > 0.5
|
|
let newActualSize
|
|
if (isDiagonal) {
|
|
const pitch =
|
|
line.attributes?.pitch ??
|
|
roof.attributes?.pitch ??
|
|
roof.roofMaterial?.pitch ??
|
|
0
|
|
newActualSize = Number(
|
|
calcLineActualSize2(
|
|
{ x1: line.x1, y1: line.y1, x2: line.x2, y2: line.y2 },
|
|
getDegreeByChon(pitch),
|
|
),
|
|
)
|
|
} else {
|
|
newActualSize = line.attributes.planeSize
|
|
}
|
|
line.set({ attributes: { ...line.attributes, actualSize: newActualSize } })
|
|
// lengthText 에 actualSize 즉시 propagate (없으면 모드 토글이 if(obj.actualSize)
|
|
// 가드에 막혀 토글 무효화).
|
|
const lengthText = canvas.getObjects().find(
|
|
(o) => o.name === 'lengthText' && o.parentId === line.id,
|
|
)
|
|
if (lengthText) {
|
|
lengthText.set({ actualSize: newActualSize })
|
|
}
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
apply()
|
|
}
|
|
|
|
/**
|
|
* 실측값 없는 경우 체크
|
|
*/
|
|
const checkInnerLines = () => {
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF) // roofPolygon.innerLines
|
|
let result = false
|
|
|
|
roofBases.forEach((roof) => {
|
|
if (roof.separatePolygon.length === 0) {
|
|
roof.innerLines.forEach((line) => {
|
|
if ((!line.attributes.actualSize || line.attributes?.actualSize === 0) && line.length > 1) {
|
|
line.set({ strokeWidth: 4, stroke: 'black', selectable: true })
|
|
result = true
|
|
}
|
|
})
|
|
}
|
|
})
|
|
if (result) canvas?.renderAll()
|
|
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* extensionLine + 동일 직선상 SK(HIP/RIDGE/VALLEY) 1:1 통합.
|
|
* 빨강 보조선(extensionLine)과 baseLine 코너에서 같은 방향으로 뻗어나가는 SK 라인을
|
|
* 한 QLine 으로 합쳐서 roofBase.innerLines 에 둔다.
|
|
* - 대각선 길이가 단일값으로 산출됨
|
|
* - 각도 기반 면적 계산이 한 라인 단위로 가능
|
|
* - splitPolygonWithLines 의 graph 토폴로지가 정상 연결됨
|
|
* 호출 위치: apply() 내 roofBase.lines 병합 직후, split 직전.
|
|
*/
|
|
const integrateExtensionLines = (roofBase) => {
|
|
if (!roofBase?.lines || !Array.isArray(roofBase.innerLines)) return
|
|
|
|
const extLines = roofBase.lines.filter((l) => l.lineName === 'extensionLine')
|
|
if (extLines.length === 0) {
|
|
console.log(`[INTEGRATE] roofBase.id=${roofBase.id} extensionLine 없음 → skip`)
|
|
return
|
|
}
|
|
|
|
const TOL = 1.0
|
|
const isSamePt = (p1, p2) => Math.hypot(p1.x - p2.x, p1.y - p2.y) < TOL
|
|
const isCollinear = (l1, l2) => {
|
|
const v1x = l1.x2 - l1.x1, v1y = l1.y2 - l1.y1
|
|
const v2x = l2.x2 - l2.x1, v2y = l2.y2 - l2.y1
|
|
const m1 = Math.hypot(v1x, v1y) || 1
|
|
const m2 = Math.hypot(v2x, v2y) || 1
|
|
const cross = (v1x * v2y - v1y * v2x) / (m1 * m2)
|
|
return Math.abs(cross) < 0.02 // ~1.1°
|
|
}
|
|
|
|
const removedExt = []
|
|
const removedSk = []
|
|
const merged = []
|
|
// [2026-04-30] sk 가 SK 빌드 시점에 이미 ext 끝점까지 연장된 경우(sk.__extended).
|
|
// merge 하면 mergedLine 이 sk 의 옛(축소된) 좌표로 되돌아가므로 스킵.
|
|
// ext 는 roofBase.lines 에서만 제거하고 canvas 에는 invisible 데이터로 그대로 둠.
|
|
const extLinesOnly = []
|
|
|
|
extLines.forEach((ext) => {
|
|
const extP1 = { x: ext.x1, y: ext.y1 }
|
|
const extP2 = { x: ext.x2, y: ext.y2 }
|
|
|
|
const sk = roofBase.innerLines.find((sl) => {
|
|
if (removedSk.includes(sl)) return false
|
|
// [auxiliaryLine 제외 2026-04-30] integrateExtensionLines 는 SK auto-build
|
|
// hip stub + ext 의 1:1 통합용. 사용자가 그린 auxiliaryLine 은 이미 완전한
|
|
// 분할선이므로 ext 와 병합하면 좌표가 어긋남(코너 끝점 손실).
|
|
if (sl.name === 'auxiliaryLine') return false
|
|
const skP1 = { x: sl.x1, y: sl.y1 }
|
|
const skP2 = { x: sl.x2, y: sl.y2 }
|
|
const sharesP1 = isSamePt(extP1, skP1) || isSamePt(extP1, skP2)
|
|
const sharesP2 = isSamePt(extP2, skP1) || isSamePt(extP2, skP2)
|
|
if ((sharesP1 ? 1 : 0) + (sharesP2 ? 1 : 0) !== 1) return false
|
|
return isCollinear(ext, sl)
|
|
})
|
|
|
|
if (!sk) {
|
|
console.log(
|
|
`[INTEGRATE] ext 짝없음 ` +
|
|
`(${extP1.x.toFixed(1)},${extP1.y.toFixed(1)})→(${extP2.x.toFixed(1)},${extP2.y.toFixed(1)})`
|
|
)
|
|
return
|
|
}
|
|
|
|
// [2026-04-30] sk 가 이미 SK 빌드 단계에서 연장된 경우 → merge 스킵.
|
|
if (sk.__extended) {
|
|
console.log(
|
|
`[INTEGRATE] sk 이미 연장됨(id=${sk.id}) → merge 스킵, ext 는 lines 에서만 제거(canvas 유지)`
|
|
)
|
|
extLinesOnly.push(ext)
|
|
return
|
|
}
|
|
|
|
const skP1 = { x: sk.x1, y: sk.y1 }
|
|
const skP2 = { x: sk.x2, y: sk.y2 }
|
|
const sharedPt = (isSamePt(extP1, skP1) || isSamePt(extP1, skP2)) ? extP1 : extP2
|
|
const extOuter = isSamePt(extP1, sharedPt) ? extP2 : extP1
|
|
const skOuter = isSamePt(skP1, sharedPt) ? skP2 : skP1
|
|
|
|
const extLen = Math.hypot(extP2.x - extP1.x, extP2.y - extP1.y)
|
|
const skLen = Math.hypot(skP2.x - skP1.x, skP2.y - skP1.y)
|
|
const totalLen = extLen + skLen
|
|
|
|
// SK 의 planeSize/actualSize 를 비율로 확장 (SK 길이가 0 이면 그대로)
|
|
// [정밀도 0.01 유지] 저장값 소수점 2자리 (면적 계산 정확도). 표시는 addLengthText 에서 round.
|
|
const skPlane = sk.attributes?.planeSize ?? 0
|
|
const skActual = sk.attributes?.actualSize ?? 0
|
|
const ratio = skLen > 0 ? totalLen / skLen : 1
|
|
const newPlane = Math.round(skPlane * ratio * 100) / 100
|
|
const newActual = Math.round(skActual * ratio * 100) / 100
|
|
|
|
const mergedLine = new QLine([extOuter.x, extOuter.y, skOuter.x, skOuter.y], {
|
|
parentId: sk.parentId,
|
|
parent: sk.parent,
|
|
stroke: sk.stroke,
|
|
strokeWidth: sk.strokeWidth,
|
|
fontSize: sk.fontSize,
|
|
visible: sk.visible,
|
|
selectable: sk.selectable,
|
|
name: sk.name,
|
|
lineName: sk.lineName,
|
|
direction: sk.direction,
|
|
roofId: sk.roofId,
|
|
attributes: {
|
|
...(sk.attributes || {}),
|
|
planeSize: newPlane,
|
|
actualSize: newActual,
|
|
},
|
|
})
|
|
mergedLine.length = totalLen
|
|
|
|
console.log(
|
|
`[INTEGRATE] merge ` +
|
|
`ext=(${extP1.x.toFixed(1)},${extP1.y.toFixed(1)})→(${extP2.x.toFixed(1)},${extP2.y.toFixed(1)}) len=${extLen.toFixed(1)} ` +
|
|
`sk[${sk.lineName || sk.name}]=(${skP1.x.toFixed(1)},${skP1.y.toFixed(1)})→(${skP2.x.toFixed(1)},${skP2.y.toFixed(1)}) len=${skLen.toFixed(1)} ` +
|
|
`→ total=${totalLen.toFixed(1)} (plane ${skPlane}→${newPlane}, actual ${skActual}→${newActual})`
|
|
)
|
|
|
|
removedExt.push(ext)
|
|
removedSk.push(sk)
|
|
merged.push(mergedLine)
|
|
})
|
|
|
|
if (merged.length === 0 && extLinesOnly.length === 0) {
|
|
console.log(`[INTEGRATE] 통합 대상 없음 ext=${extLines.length}`)
|
|
return
|
|
}
|
|
|
|
// roofBase.lines 에서: 기존 merge 로 제거할 ext + __extended 케이스의 ext 둘 다 제외
|
|
// → split 단계에서 ext 가 외곽 처마처럼 처리되는 것 방지.
|
|
roofBase.lines = roofBase.lines.filter((l) => !removedExt.includes(l) && !extLinesOnly.includes(l))
|
|
roofBase.innerLines = roofBase.innerLines.filter((l) => !removedSk.includes(l))
|
|
roofBase.innerLines = [...roofBase.innerLines, ...merged]
|
|
|
|
// canvas 정리:
|
|
// - 기존 merge 케이스: 원본 ext + 원본 sk 둘 다 canvas 제거 (mergedLine 이 대체)
|
|
// - __extended 케이스: ext 는 invisible 데이터로 canvas 에 그대로 유지 (디버그용), sk 는 이미 연장됨
|
|
removedExt.forEach((l) => canvas.remove(l))
|
|
removedSk.forEach((l) => canvas.remove(l))
|
|
|
|
console.log(
|
|
`[INTEGRATE] 완료 roofBase.id=${roofBase.id} ` +
|
|
`ext제거=${removedExt.length} sk제거=${removedSk.length} merged=${merged.length} ` +
|
|
`extKeptInCanvas=${extLinesOnly.length} ` +
|
|
`→ lines=${roofBase.lines.length} innerLines=${roofBase.innerLines.length}`
|
|
)
|
|
}
|
|
|
|
/**
|
|
* 지붕면 할당
|
|
*/
|
|
const apply = () => {
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF && !obj.roofMaterial)
|
|
const wallLines = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.WALL)
|
|
console.log(`[ALLOC] apply() 진입. roofBases=${roofBases.length}`)
|
|
roofBases.forEach((roofBase) => {
|
|
try {
|
|
// 지붕 할당 로직에 extensionLine 추가
|
|
const roofEaveHelpLines = canvas.getObjects().filter((obj) =>
|
|
(obj.lineName === 'eaveHelpLine' || obj.lineName === 'extensionLine') &&
|
|
obj.roofId === roofBase.id
|
|
)
|
|
// [ALLOC-DEBUG] canvas 픽업 스냅샷 (삭제 직전 상태)
|
|
const snapByLineName = {}
|
|
const snapByName = {}
|
|
roofEaveHelpLines.forEach((o) => {
|
|
snapByLineName[o.lineName] = (snapByLineName[o.lineName] || 0) + 1
|
|
snapByName[o.name || '?'] = (snapByName[o.name || '?'] || 0) + 1
|
|
})
|
|
console.log(
|
|
`[ALLOC-DEBUG] roofBase.id=${roofBase.id} ` +
|
|
`roofBase.lines=${roofBase.lines?.length || 0} ` +
|
|
`roofBase.innerLines=${roofBase.innerLines?.length || 0} ` +
|
|
`canvas픽업=${roofEaveHelpLines.length} ` +
|
|
`byLineName=${JSON.stringify(snapByLineName)} ` +
|
|
`byName=${JSON.stringify(snapByName)}`
|
|
)
|
|
roofEaveHelpLines.forEach((o, i) => {
|
|
console.log(
|
|
` [ALLOC-DEBUG] picked[${i}] name=${o.name} lineName=${o.lineName} ` +
|
|
`(${o.x1?.toFixed(1)},${o.y1?.toFixed(1)})→(${o.x2?.toFixed(1)},${o.y2?.toFixed(1)}) ` +
|
|
`len=${Math.hypot((o.x2 || 0) - (o.x1 || 0), (o.y2 || 0) - (o.y1 || 0)).toFixed(1)}`
|
|
)
|
|
})
|
|
// console.log('roofBase.id:', roofBase.id)
|
|
// console.log('roofEaveHelpLines:', roofEaveHelpLines)
|
|
// console.log('extensionLines found:', roofEaveHelpLines.filter(l => l.lineName === 'extensionLine'))
|
|
if (roofEaveHelpLines.length > 0) {
|
|
if (roofBase.lines) {
|
|
// Filter out any eaveHelpLines that are already in lines to avoid duplicates
|
|
const existingEaveLineIds = new Set(roofBase.lines.map((line) => line.id))
|
|
const newEaveLines = roofEaveHelpLines.filter((line) => !existingEaveLineIds.has(line.id))
|
|
// Filter out lines from roofBase.lines that share any points with newEaveLines
|
|
|
|
// extensionLine과 일반 eaveHelpLine 분리
|
|
const extensionLines = newEaveLines.filter(line => line.lineName === 'extensionLine')
|
|
const normalEaveLines = newEaveLines.filter(line => line.lineName === 'eaveHelpLine')
|
|
// console.log('extensionLines count:', extensionLines.length)
|
|
// console.log('normalEaveLines count:', normalEaveLines.length)
|
|
|
|
// 일반 eaveHelpLine만 Overlap 판단에 사용
|
|
const linesToKeep = roofBase.lines.filter(roofLine => {
|
|
const shouldRemove = normalEaveLines.some(eaveLine => {
|
|
// 1. 기본적인 포인트 일치 확인
|
|
const rX1 = roofLine.x1, rY1 = roofLine.y1, rX2 = roofLine.x2, rY2 = roofLine.y2;
|
|
const eX1 = eaveLine.x1, eY1 = eaveLine.y1, eX2 = eaveLine.x2, eY2 = eaveLine.y2;
|
|
|
|
const isP1Matched = (Math.abs(rX1 - eX1) < 0.1 && Math.abs(rY1 - eY1) < 0.1) || (Math.abs(rX1 - eX2) < 0.1 && Math.abs(rY1 - eY2) < 0.1);
|
|
const isP2Matched = (Math.abs(rX2 - eX1) < 0.1 && Math.abs(rY2 - eY1) < 0.1) || (Math.abs(rX2 - eX2) < 0.1 && Math.abs(rY2 - eY2) < 0.1);
|
|
|
|
if (isP1Matched || isP2Matched) {
|
|
// 2. 일직선(평행)인지 확인
|
|
const dx1 = rX2 - rX1;
|
|
const dy1 = rY2 - rY1;
|
|
const dx2 = eX2 - eX1;
|
|
const dy2 = eY2 - eY1;
|
|
const crossProduct = Math.abs(dx1 * dy2 - dy1 * dx2);
|
|
const mag1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
|
|
const mag2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
|
|
const isStraight = (mag1 * mag2) === 0 ? true : (crossProduct / (mag1 * mag2) < 0.01);
|
|
|
|
if (isStraight) {
|
|
// 3. [핵심] 몸통이 포개지는지(Overlap) 확인
|
|
// 한 선의 끝점이 다른 선의 "내부"에 들어와 있는지 체크
|
|
const isPointInside = (x, y, x1, y1, x2, y2) => {
|
|
const dotProduct = (x - x1) * (x2 - x1) + (y - y1) * (y2 - y1);
|
|
if (dotProduct < 0.1) return false; // 시작점 바깥쪽
|
|
const squaredLength = (x2 - x1) ** 2 + (y2 - y1) ** 2;
|
|
if (dotProduct > squaredLength - 0.1) return false; // 끝점 바깥쪽
|
|
return true; // 선의 내부(몸통)에 있음
|
|
};
|
|
|
|
// roofLine의 끝점 중 하나가 eaveLine의 몸통 안에 있거나,
|
|
// eaveLine의 끝점 중 하나가 roofLine의 몸통 안에 있으면 "포개짐"으로 판단
|
|
const isOverlapping =
|
|
isPointInside(rX1, rY1, eX1, eY1, eX2, eY2) ||
|
|
isPointInside(rX2, rY2, eX1, eY1, eX2, eY2) ||
|
|
isPointInside(eX1, eY1, rX1, rY1, rX2, rY2) ||
|
|
isPointInside(eX2, eY2, rX1, rY1, rX2, rY2);
|
|
|
|
if (isOverlapping) {
|
|
console.log('Removing overlapping line:', roofLine);
|
|
return true; // 포개지는 경우에만 삭제
|
|
}
|
|
}
|
|
}
|
|
return false; // 끝점만 닿아 있거나 직각인 경우는 살림
|
|
});
|
|
return !shouldRemove;
|
|
});
|
|
// Combine remaining lines with newEaveLines
|
|
roofBase.lines = [...linesToKeep, ...normalEaveLines, ...extensionLines];
|
|
// [ALLOC-DEBUG] 병합 결과 breakdown
|
|
console.log(
|
|
`[ALLOC-DEBUG] 병합완료 roofBase.id=${roofBase.id} ` +
|
|
`linesToKeep=${linesToKeep.length} ` +
|
|
`normalEave=${normalEaveLines.length} ` +
|
|
`extension=${extensionLines.length} ` +
|
|
`total=${roofBase.lines.length}`
|
|
)
|
|
roofBase.lines.forEach((ln, i) => {
|
|
console.log(
|
|
` [ALLOC-DEBUG] merged[${i}] name=${ln.name || '?'} lineName=${ln.lineName || '?'} ` +
|
|
`(${ln.x1?.toFixed(1)},${ln.y1?.toFixed(1)})→(${ln.x2?.toFixed(1)},${ln.y2?.toFixed(1)})`
|
|
)
|
|
})
|
|
} else {
|
|
roofBase.lines = [...roofEaveHelpLines]
|
|
}
|
|
if (!roofBase.innerLines) {
|
|
roofBase.innerLines = []
|
|
}
|
|
}
|
|
|
|
if (roofBase.adjustRoofLines.length > 0) {
|
|
const newRoofLines = []
|
|
let lineIndex = 1
|
|
roofBase.lines.forEach((line, idx) => {
|
|
const adjustLines = roofBase.adjustRoofLines.filter((adjustLine) => adjustLine.roofIdx === line.idx)
|
|
if (adjustLines.length === 0) {
|
|
line.idx = lineIndex
|
|
newRoofLines.push(line)
|
|
lineIndex++
|
|
} else {
|
|
adjustLines.forEach(({ point, roofIdx }) => {
|
|
const newLine = new QLine(point, {
|
|
idx: lineIndex,
|
|
selectable: false,
|
|
parentId: line.parentId,
|
|
parent: line.parent,
|
|
fontSize: line.fontSize,
|
|
stroke: line.stroke,
|
|
strokeWidth: line.strokeWidth,
|
|
attributes: line.attributes,
|
|
})
|
|
newRoofLines.push(newLine)
|
|
lineIndex++
|
|
})
|
|
}
|
|
})
|
|
roofBase.lines = newRoofLines
|
|
}
|
|
// extensionLine + 동일직선 SK 1:1 통합 (대각선 단일길이/각도 면적 산출)
|
|
integrateExtensionLines(roofBase)
|
|
|
|
// [ALLOC-DEBUG] split 직전 최종 입력
|
|
console.log(
|
|
`[ALLOC-DEBUG] split 직전 roofBase.id=${roofBase.id} ` +
|
|
`separatePolygon=${roofBase.separatePolygon?.length || 0} ` +
|
|
`lines=${roofBase.lines?.length || 0} ` +
|
|
`innerLines=${roofBase.innerLines?.length || 0} ` +
|
|
`points=${roofBase.points?.length || 0} ` +
|
|
`→ ${roofBase.separatePolygon?.length > 0 ? 'splitPolygonWithSeparate' : 'splitPolygonWithLines'}`
|
|
)
|
|
if (roofBase.separatePolygon.length > 0) {
|
|
splitPolygonWithSeparate(roofBase.separatePolygon)
|
|
} else {
|
|
splitPolygonWithLines(roofBase)
|
|
}
|
|
} catch (e) {
|
|
console.log(e)
|
|
canvas.discardActiveObject()
|
|
return
|
|
}
|
|
|
|
/** 라인 삭제 */
|
|
roofBase.innerLines.forEach((line) => {
|
|
canvas.remove(line)
|
|
})
|
|
|
|
canvas.remove(roofBase)
|
|
})
|
|
|
|
/** 데이터 설정 */
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
return { ...roof, index: idx, ...basicInfo, raft: roof.raft ? roof.raft : roof.raftBaseCd }
|
|
})
|
|
|
|
setBasicSetting((prev) => {
|
|
return { ...prev, selectedRoofMaterial: newRoofList.find((roof) => roof.selected) }
|
|
})
|
|
setRoofList(newRoofList)
|
|
|
|
const roofs = canvas.getObjects().filter((obj) => obj.name === 'roof')
|
|
|
|
roofs.forEach((roof) => {
|
|
if (roof.isFixed) return
|
|
roof.set({ isFixed: true })
|
|
|
|
/** 모양 패턴 설정 */
|
|
setSurfaceShapePattern(
|
|
roof,
|
|
roofDisplay.column,
|
|
false,
|
|
currentRoofList.find((roof) => roof.selected),
|
|
)
|
|
drawDirectionArrow(roof)
|
|
})
|
|
|
|
setRoofMaterials(newRoofList)
|
|
setRoofsStore(newRoofList)
|
|
/** 외곽선 삭제 */
|
|
const removeTargets = canvas.getObjects().filter((obj) => obj.name === 'outerLinePoint' || obj.name === 'outerLine' || obj.name === 'pitchText')
|
|
removeTargets.forEach((obj) => {
|
|
canvas.remove(obj)
|
|
})
|
|
setEditingLines([])
|
|
closeAll()
|
|
setSelectedMenu('surface')
|
|
//지붕면 완성 후 실측치 로 보이도록 수정
|
|
setCorridorDimension(1)
|
|
|
|
/** 모듈 선택 데이터 초기화 */
|
|
// modifyModuleSelectionData()
|
|
setModuleSelectionData({ ...moduleSelectionData, roofConstructions: newRoofList })
|
|
|
|
setTimeout(() => {
|
|
changeCorridorDimensionText('realDimension')
|
|
}, 500)
|
|
}
|
|
|
|
/**
|
|
* 라인 사이즈 설정
|
|
*/
|
|
const setLineSize = (id, size) => {
|
|
const roofBases = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF)
|
|
roofBases.forEach((roof) => {
|
|
roof.innerLines.forEach((line) => {
|
|
if (id === line.id) {
|
|
setEditingLines([...editingLines.filter((editLine) => editLine.id !== line.id), line])
|
|
line.attributes.actualSize = size
|
|
line.set({ strokeWidth: 2, stroke: 'black' })
|
|
}
|
|
})
|
|
})
|
|
|
|
canvas?.renderAll()
|
|
}
|
|
|
|
/**
|
|
* 지붕재 변경
|
|
*/
|
|
const handleChangeRoofMaterial = (value, index) => {
|
|
const selectedRoofMaterial = roofMaterials.find((roof) => roof.roofMatlCd === value.id)
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (idx === index) {
|
|
return { ...selectedRoofMaterial, selected: roof.selected, index }
|
|
}
|
|
return roof
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 기본 지붕재 radio값 변경
|
|
*/
|
|
const handleDefaultRoofMaterial = (index) => {
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
return { ...roof, selected: idx === index }
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 서까래 변경
|
|
*/
|
|
const handleChangeRaft = (e, index) => {
|
|
const raftValue = e.clCode
|
|
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (idx === index) {
|
|
return { ...roof, raft: raftValue }
|
|
}
|
|
return roof
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 레이아웃 변경
|
|
*/
|
|
const handleChangeLayout = (layoutValue, index) => {
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (idx === index) {
|
|
return { ...roof, layout: layoutValue }
|
|
}
|
|
return roof
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 치수 입력방법(복시도입력/실측값입력/육지붕)
|
|
*/
|
|
const handleChangeInput = (e, type = '', index) => {
|
|
const value = e.target.value
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (idx === index) {
|
|
return { ...roof, [type]: value }
|
|
}
|
|
return roof
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 피치 변경
|
|
*/
|
|
const handleChangePitch = (e, index) => {
|
|
let value = e //e.target.value
|
|
|
|
const reg = /^[0-9]+(\.[0-9]{0,1})?$/
|
|
if (!reg.test(value)) {
|
|
value = value.substring(0, value.length - 1)
|
|
}
|
|
const newRoofList = currentRoofList.map((roof, idx) => {
|
|
if (idx === index) {
|
|
const result =
|
|
currentAngleType === 'slope'
|
|
? {
|
|
pitch: value,
|
|
angle: getDegreeByChon(value),
|
|
}
|
|
: { pitch: getChonByDegree(value), angle: value }
|
|
return { ...roof, ...result }
|
|
}
|
|
return roof
|
|
})
|
|
|
|
setCurrentRoofList(newRoofList)
|
|
}
|
|
|
|
/**
|
|
* 모듈 선택에서 선택한 데이터 초기화
|
|
*/
|
|
const modifyModuleSelectionData = () => {
|
|
if (moduleSelectionData.roofConstructions?.length > 0) {
|
|
setModuleSelectionData({ ...moduleSelectionData, roofConstructions: [] })
|
|
moduleSelectedDataTrigger({ ...moduleSelectionData, roofConstructions: [] })
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 모듈 선택 데이터 트리거
|
|
*/
|
|
const { trigger: moduleSelectedDataTrigger } = useCanvasPopupStatusController(2)
|
|
|
|
return {
|
|
handleSave,
|
|
onAddRoofMaterial,
|
|
onDeleteRoofMaterial,
|
|
handleAlloc,
|
|
setLineSize,
|
|
roofMaterials,
|
|
selectedRoofMaterial,
|
|
basicSetting,
|
|
setBasicSetting,
|
|
currentRoofMaterial,
|
|
setCurrentRoofMaterial,
|
|
handleDefaultRoofMaterial,
|
|
handleChangeRoofMaterial,
|
|
handleChangeRaft,
|
|
handleChangeLayout,
|
|
handleSaveContext,
|
|
currentRoofList,
|
|
handleChangeInput,
|
|
handleChangePitch,
|
|
}
|
|
}
|