813 lines
36 KiB
C#
813 lines
36 KiB
C#
using Autodesk.Revit.DB;
|
|
using Autodesk.Revit.DB.Plumbing;
|
|
using Autodesk.Revit.UI;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
//using COME4Revit.WinForm;
|
|
using System.Diagnostics;
|
|
using Autodesk.Revit.UI.Selection;
|
|
using System;
|
|
using System.Windows.Forms;
|
|
using KDCS.Utils;
|
|
using View = Autodesk.Revit.DB.View;
|
|
using Autodesk.Revit.DB.Structure;
|
|
using Autodesk.Revit.Creation;
|
|
using KMBIM.Revit.Tools;
|
|
|
|
namespace KMBIM
|
|
{
|
|
public class LevelComparer : IComparer<Level>
|
|
{
|
|
public int Compare(Level a, Level b)
|
|
{
|
|
double diff = a.Elevation - b.Elevation;
|
|
if (Math.Abs(diff) < 0.0001) return 0;
|
|
else if (diff > 0.0001) return 1;
|
|
else if (diff < 0.0001) return -1;
|
|
else return 0;
|
|
|
|
}
|
|
}
|
|
[Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
|
|
public class DrawUpperPipeRack : IExternalCommand
|
|
{
|
|
UIApplication uiapp;
|
|
UIDocument uidoc;
|
|
Autodesk.Revit.DB.Document doc;
|
|
Autodesk.Revit.Creation.Application creApp;
|
|
Autodesk.Revit.Creation.Document creDoc;
|
|
|
|
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
|
|
{
|
|
uiapp = commandData.Application;
|
|
uidoc = uiapp.ActiveUIDocument;
|
|
Autodesk.Revit.ApplicationServices.Application app = uiapp.Application;
|
|
doc = uidoc.Document;
|
|
creApp = uiapp.Application.Create;
|
|
creDoc = doc.Create;
|
|
View view = doc.ActiveView;
|
|
Level m_setLvlElem = null;
|
|
int RadType = 0;
|
|
PipeInfo pipeInfo1 = new PipeInfo();
|
|
PipeInfo pipeInfo2 = new PipeInfo();
|
|
|
|
try
|
|
{
|
|
//if (!WorkMain.GetInstance().IsValid) return Autodesk.Revit.UI.Result.Succeeded;
|
|
//파이프 선택
|
|
IList<Reference> pickrefs = commandData.Application.ActiveUIDocument.Selection.PickObjects(Autodesk.Revit.UI.Selection.ObjectType.Element, new PipeSelectionFilter(), "가대 설치할 배관 선택 : ");
|
|
|
|
if (pickrefs.Count == 0)
|
|
{
|
|
MessageBox.Show("선택한 파이프가 없습니다.", "오류");
|
|
return Result.Cancelled;
|
|
}
|
|
|
|
//파이프로 변환
|
|
List<Pipe> PipeLst = new List<Pipe>();
|
|
foreach (Reference refer in pickrefs)
|
|
{
|
|
PipeLst.Add(doc.GetElement(refer) as Pipe);
|
|
}
|
|
|
|
//가장 큰 관경 파이프 구하기
|
|
Pipe MaxDiaPipe = getMaxPipe(PipeLst);
|
|
//간격띄우기 낮은 파이프 구하기
|
|
Pipe MinOffsetPipe = getMinOffsetPipe(PipeLst);
|
|
|
|
Form_UpperPipeRack dlg = new Form_UpperPipeRack();
|
|
dlg.revit = commandData;
|
|
dlg.MaxDiaPipe = MaxDiaPipe;
|
|
dlg.MinOffPipe = MinOffsetPipe;
|
|
dlg.ShowDialog();
|
|
if (dlg.DialogResult == DialogResult.Cancel) return Result.Cancelled;
|
|
//대화상자 선택한 레벨 가져오기
|
|
FilteredElementCollector lvlCollector = new FilteredElementCollector(doc);
|
|
ICollection<Element> lvlCollection = lvlCollector.OfClass(typeof(Level)).ToElements();
|
|
|
|
foreach (Element elem in lvlCollection)
|
|
{
|
|
Level lvl = elem as Level;
|
|
if (lvl.Name == dlg.m_LvlAttach)
|
|
m_setLvlElem = lvl;
|
|
}
|
|
|
|
//볼트 타입
|
|
RadType = dlg.m_Radidx;
|
|
|
|
foreach (Pipe pipe in PipeLst)
|
|
{
|
|
if (m_setLvlElem.Elevation < pipe.ReferenceLevel.Elevation + pipe.LevelOffset)
|
|
{
|
|
MessageBox.Show("파이프가 지지대 배치 레벨과 파이프 사이가 좁습니다..", "오류");
|
|
return Result.Cancelled;
|
|
}
|
|
if (pipe.ReferenceLevel.Name == m_setLvlElem.Name)
|
|
{
|
|
MessageBox.Show("파이프 참조 레벨과 지지대 부착 레벨이 같습니다.", "오류");
|
|
return Result.Cancelled;
|
|
}
|
|
}
|
|
|
|
Level setLevel = Util.GetLevel(doc, dlg.m_LvlAttach);
|
|
Level CurLevel = null;
|
|
if (dlg.m_LvlCurrent == "Unknown")
|
|
CurLevel = Util.GetLevel(doc, dlg.m_LvlCurrent);
|
|
|
|
|
|
//가대 심볼 로드되어 있지 않으면 로드
|
|
FamilySymbol fs = Util.LoadFamilys(doc, "Chanel_Support_upper.rfa", "PipeRack");
|
|
|
|
if (fs == null)
|
|
fs = Util.getNameByFamily(doc, "Chanel_Support_upper");
|
|
//U볼트 패밀리 로드
|
|
FamilySymbol bolt = Util.LoadFamilys(doc, "U_bolt.rfa", "PipeRack");
|
|
if (bolt == null)
|
|
bolt = Util.getNameByFamily(doc, "U_bolt");
|
|
//가이드 슈 패밀리 로드
|
|
FamilySymbol shoe = Util.LoadFamilys(doc, "Guide_Shoe.rfa", "PipeRack");
|
|
if (shoe == null)
|
|
shoe = Util.getNameByFamily(doc, "Guide_Shoe");
|
|
|
|
|
|
while (true)
|
|
{
|
|
//가대 위치 지정
|
|
Reference pickref = commandData.Application.ActiveUIDocument.Selection.PickObject(Autodesk.Revit.UI.Selection.ObjectType.Element, new PipeSelectionFilter(), "가대 위치 지정 : ");
|
|
//위치 포인트
|
|
XYZ insertPt = pickref.GlobalPoint;
|
|
|
|
//위치포인트에서 양 쪽 가장 먼 파이프 두개를 찾아 교차점 구하기
|
|
//XYZ SideInterPt1 = null, SideInterPt2 = null;
|
|
List<PipeInfo> pipeInfoLst = new List<PipeInfo>();
|
|
if (PipeLst.Count == 1)
|
|
{
|
|
pipeInfo1.pipe = doc.GetElement(pickref) as Pipe;
|
|
Line line = (pipeInfo1.pipe.Location as LocationCurve).Curve as Line;
|
|
IntersectionResult interRes = line.Project(insertPt);
|
|
pipeInfo1.InterPt = interRes.XYZPoint;
|
|
pipeInfoLst.Add(pipeInfo1);
|
|
}
|
|
else
|
|
{
|
|
pipeInfoLst = getSidePipe(PipeLst, insertPt, ref pipeInfo1, ref pipeInfo2);
|
|
}
|
|
|
|
//심볼이 로드되지 않으면 실행 X
|
|
if (fs == null) break;
|
|
|
|
using (Transaction trans = new Transaction(doc))
|
|
{
|
|
trans.Start("symbol");
|
|
|
|
if (fs.IsActive == false)
|
|
fs.Activate();
|
|
if (bolt.IsActive == false)
|
|
bolt.Activate();
|
|
if (shoe.IsActive == false)
|
|
shoe.Activate();
|
|
|
|
|
|
XYZ sp = null, ep = null;
|
|
Util.GetStartEndPoint(PipeLst.First(), ref sp, ref ep);
|
|
XYZ PipeVec = (ep - sp).Normalize();
|
|
XYZ RotVec = Util.RotateVector(PipeVec, Util.DTR(90));
|
|
|
|
FamilyInstance Rack = null;
|
|
FamilyInstance TypeFamily = null;
|
|
|
|
//파이프 1개 선택 시
|
|
if (PipeLst.Count == 1)
|
|
{
|
|
XYZ locPt = null;
|
|
if (MinOffsetPipe != null)
|
|
locPt = new XYZ(pipeInfo1.InterPt.X, pipeInfo1.InterPt.Y, MinOffsetPipe.LevelOffset + MinOffsetPipe.ReferenceLevel.Elevation);
|
|
else
|
|
locPt = new XYZ(pipeInfo1.InterPt.X, pipeInfo1.InterPt.Y, MaxDiaPipe.LevelOffset + MaxDiaPipe.ReferenceLevel.Elevation);
|
|
|
|
//가대 설치
|
|
Rack = doc.Create.NewFamilyInstance(locPt, fs, RotVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
|
|
if (RadType == 0)
|
|
{
|
|
//파이프가 1개일 때 가이드 슈
|
|
TypeFamily = doc.Create.NewFamilyInstance(locPt, shoe, PipeVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
pipeInfoLst.First().family = TypeFamily;
|
|
}
|
|
else if (RadType == 1)
|
|
{
|
|
//파이프가 1개일 때 U볼트
|
|
TypeFamily = doc.Create.NewFamilyInstance(locPt, bolt, PipeVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
pipeInfoLst.First().family = TypeFamily;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//파이프 여러개 선택 시 양 끝 파이프 센터점에 가대 설치
|
|
XYZ centerPt = Util.Polar(pipeInfo1.InterPt, pipeInfo1.InterPt, pipeInfo2.InterPt, pipeInfo1.InterPt.DistanceTo(pipeInfo2.InterPt) / 2.0);
|
|
if (MinOffsetPipe != null)
|
|
centerPt = new XYZ(centerPt.X, centerPt.Y, MinOffsetPipe.LevelOffset + MinOffsetPipe.ReferenceLevel.Elevation);
|
|
else
|
|
centerPt = new XYZ(centerPt.X, centerPt.Y, MaxDiaPipe.LevelOffset + MaxDiaPipe.ReferenceLevel.Elevation);
|
|
|
|
//SelectLevel.Elevation - MinOffsetPipe.LevelOffset - MinOffsetPipe.ReferenceLevel.Elevation + (MinOffsetPipe.Diameter / 2) + Unit.MMToFeet(150)
|
|
Rack = doc.Create.NewFamilyInstance(centerPt, fs, RotVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
//Util.Pyosi(doc, centerPt, 0);
|
|
//U볼트 가이드 슈 삽입
|
|
foreach (PipeInfo info in pipeInfoLst)
|
|
{
|
|
XYZ locPt = null;
|
|
//locPt = new XYZ(info.InterPt.X, info.InterPt.Y, info.pipe.LevelOffset + MinOffsetPipe.ReferenceLevel.Elevation);
|
|
|
|
if (RadType == 0)
|
|
{
|
|
if (MinOffsetPipe != null)
|
|
locPt = new XYZ(info.InterPt.X, info.InterPt.Y, info.pipe.LevelOffset + MinOffsetPipe.ReferenceLevel.Elevation);
|
|
else
|
|
locPt = new XYZ(info.InterPt.X, info.InterPt.Y, info.pipe.LevelOffset + MaxDiaPipe.ReferenceLevel.Elevation);
|
|
|
|
TypeFamily = doc.Create.NewFamilyInstance(locPt, shoe, PipeVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
info.family = TypeFamily;
|
|
doc.Regenerate();
|
|
List<Connector> conLst = Util.GetElementConnectors(TypeFamily);
|
|
Connector shoeCon = conLst.First();
|
|
//Util.Pyosi(doc, pipeInfo1.InterPt, 0);
|
|
doc.Regenerate();
|
|
//가이드 슈 커넥터 위치를 기준으로 파이프 중심으로 이동
|
|
XYZ translation = locPt - shoeCon.Origin;
|
|
//Util.Pyosi(doc, locPt, 0);
|
|
//ElementTransformUtils.MoveElement(doc, TypeFamily.Id, translation);
|
|
}
|
|
else if (RadType == 1)
|
|
{
|
|
if (MinOffsetPipe != null)
|
|
locPt = new XYZ(info.InterPt.X, info.InterPt.Y, MinOffsetPipe.LevelOffset + MinOffsetPipe.ReferenceLevel.Elevation);
|
|
else
|
|
locPt = new XYZ(info.InterPt.X, info.InterPt.Y, MaxDiaPipe.LevelOffset + MaxDiaPipe.ReferenceLevel.Elevation);
|
|
|
|
TypeFamily = doc.Create.NewFamilyInstance(locPt, bolt, PipeVec, doc.GetElement(pickref), StructuralType.NonStructural);
|
|
info.family = TypeFamily;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//패밀리 옵션 설정
|
|
FamilyOption(Rack, pipeInfoLst, pipeInfo1, pipeInfo2, PipeLst, setLevel, RadType);
|
|
|
|
//BoltOption(Rack, pipeInfoLst, setLevel, RadType);
|
|
|
|
trans.Commit();
|
|
}
|
|
|
|
}//while end
|
|
|
|
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
return Result.Succeeded;
|
|
}
|
|
|
|
//가대 옵션 설정
|
|
private void FamilyOption(FamilyInstance Rack, List<PipeInfo> pipeInfoLst, PipeInfo pipeInfo1, PipeInfo pipeInfo2, List<Pipe> pipeLst, Level SelectLevel, int BoltType)
|
|
{
|
|
//////////////////////////////가대 설정////////////////////////////////////
|
|
Definition df = null;
|
|
double MaxPipeOutDia = 0;
|
|
double MinOffPipeOutDia = 0;
|
|
//가장 큰 관경 구하기
|
|
Pipe MaxDiaPipe = getMaxPipe(pipeLst);
|
|
//가장 큰 관경 외경
|
|
Parameter maxOutDiaParam = MaxDiaPipe.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER);
|
|
if (maxOutDiaParam != null)
|
|
MaxPipeOutDia = maxOutDiaParam.AsDouble();
|
|
|
|
//오프셋 값이 가장 높은 값.
|
|
Pipe MinOffsetPipe = getMinOffsetPipe(pipeLst);
|
|
//파이프 단열제 두께
|
|
double MaxinsulThk = 0, MininsulThk = 0;
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
MininsulThk = Util.GetPipeInsulationThickness(doc, MinOffsetPipe);
|
|
Parameter minOutDiaParam = MinOffsetPipe.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER);
|
|
if (minOutDiaParam != null)
|
|
MinOffPipeOutDia = minOutDiaParam.AsDouble();
|
|
}
|
|
else
|
|
MaxinsulThk = Util.GetPipeInsulationThickness(doc, MaxDiaPipe);
|
|
|
|
|
|
if (Rack == null) return;
|
|
//지지대 다리 off시 on으로
|
|
df = GetDefinition(Rack, "Support1");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSupport1 = Rack.get_Parameter(df);
|
|
if (paramSupport1 != null)
|
|
paramSupport1.Set(1);
|
|
}
|
|
|
|
df = GetDefinition(Rack, "Support2");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSupport2 = Rack.get_Parameter(df);
|
|
if (paramSupport2 != null)
|
|
paramSupport2.Set(1);
|
|
}
|
|
|
|
//2단 off
|
|
df = GetDefinition(Rack, "2nd_Chanel");
|
|
if (df != null)
|
|
{
|
|
Parameter param2ndChanel = Rack.get_Parameter(df);
|
|
if (param2ndChanel != null)
|
|
param2ndChanel.Set(0);
|
|
}
|
|
|
|
|
|
df = GetDefinition(Rack, "Support_Width");
|
|
if (df != null)
|
|
{
|
|
Parameter paramWidth = Rack.get_Parameter(df);
|
|
if (paramWidth != null)
|
|
{
|
|
if (pipeInfo2.pipe == null)
|
|
{
|
|
double sidePipeDia = pipeInfo1.pipe.Diameter;
|
|
//파이프 관경 + 여유분(500)
|
|
paramWidth.Set(sidePipeDia + Unit.MMToFeet(500));
|
|
}
|
|
else
|
|
{
|
|
double sidePipeDia = pipeInfo1.pipe.Diameter;
|
|
double side2PipeDia = pipeInfo2.pipe.Diameter;
|
|
//양 쪽 사이드 파이프 관경 + 양 사이드 파이프 거리 + 여유분(500)
|
|
paramWidth.Set(sidePipeDia + side2PipeDia + pipeInfo1.InterPt.DistanceTo(pipeInfo2.InterPt) + Unit.MMToFeet(500));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//간격 띄우기 값 구하기 U볼트에만 적용
|
|
if (BoltType == 1 || BoltType == 2)
|
|
{
|
|
double m_Offset = 0, m_pipeDia = 0; ;
|
|
Parameter paramOffset = Rack.get_Parameter(BuiltInParameter.INSTANCE_FREE_HOST_OFFSET_PARAM);
|
|
if (paramOffset != null)
|
|
{
|
|
m_Offset = paramOffset.AsDouble();
|
|
|
|
if (MinOffsetPipe == null)
|
|
m_pipeDia = MaxPipeOutDia + MaxinsulThk * 2;
|
|
else
|
|
m_pipeDia = MinOffPipeOutDia + MininsulThk * 2;
|
|
|
|
paramOffset.Set(m_Offset - m_pipeDia / 2.0);
|
|
}
|
|
}
|
|
|
|
|
|
doc.Regenerate();
|
|
//
|
|
//다리 길이1
|
|
df = GetDefinition(Rack, "Support_Length");
|
|
if (df != null)
|
|
{
|
|
Parameter paramLeg1 = Rack.get_Parameter(df);
|
|
if (paramLeg1 != null)
|
|
{
|
|
|
|
//현재 뷰의 레벨만큼 빼서 다리길이 조정(대화상자 만든다면 제거할것)
|
|
//paramLeg1.Set(m_Offset - MaxPipeDia / 2.0 - view.GenLevel.Elevation);
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
paramLeg1.Set(SelectLevel.Elevation - MinOffsetPipe.ReferenceLevel.Elevation - MinOffsetPipe.LevelOffset +Unit.MMToFeet(150) + MininsulThk + MinOffPipeOutDia / 2.0);
|
|
//paramLeg1.Set(SelectLevel.Elevation - MinOffsetPipe.ReferenceLevel.Elevation - MinOffsetPipe.LevelOffset + Unit.MMToFeet(150) + MininsulThk + MinOffsetPipe.Diameter / 2.0);
|
|
}
|
|
else
|
|
{
|
|
paramLeg1.Set(SelectLevel.Elevation - MaxDiaPipe.ReferenceLevel.Elevation - MaxDiaPipe.LevelOffset + Unit.MMToFeet(150) + MaxinsulThk + MaxPipeOutDia / 2.0);
|
|
//paramLeg1.Set(SelectLevel.Elevation - MaxDiaPipe.ReferenceLevel.Elevation - MaxDiaPipe.LevelOffset + Unit.MMToFeet(150) + MaxinsulThk + MaxDiaPipe.Diameter / 2.0);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////U-볼트 가이드 슈 설정////////////////////////////////////
|
|
double m_CoverThk = 0, m_plateHgt = 0;
|
|
foreach (PipeInfo info in pipeInfoLst)
|
|
{
|
|
//파이프 단열제 두께
|
|
double insulThk = Util.GetPipeInsulationThickness(doc, info.pipe);
|
|
//파이프 외경
|
|
Parameter param = info.pipe.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER);
|
|
double m_CurPipeOutDia = 0;
|
|
if (param != null)
|
|
m_CurPipeOutDia = param.AsDouble();
|
|
|
|
if (BoltType == 0)//가이드 슈
|
|
{
|
|
if (info.family == null) continue;
|
|
|
|
//관경(외경) 변경
|
|
df = GetDefinition(info.family, "GuideShoeCoverInRad");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSteelDia = info.family.get_Parameter(df);
|
|
if (paramSteelDia != null)
|
|
paramSteelDia.Set(m_CurPipeOutDia / 2.0 + insulThk);
|
|
//paramSteelDia.Set(info.pipe.Diameter / 2.0 + insulThk);
|
|
}
|
|
|
|
//커넥터 관경 변경
|
|
df = GetDefinition(info.family, "ConRad");
|
|
if (df != null)
|
|
{
|
|
Parameter paramConRad = info.family.get_Parameter(df);
|
|
if (paramConRad != null)
|
|
paramConRad.Set(m_CurPipeOutDia / 2.0 + insulThk);
|
|
//paramConRad.Set(info.pipe.Diameter / 2.0 + insulThk);
|
|
}
|
|
|
|
|
|
//슈 폭 변경
|
|
df = GetDefinition(info.family, "HalfGuideShoeCoverWidth");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSteelHalfWidth = info.family.get_Parameter(df);
|
|
if (paramSteelHalfWidth != null)
|
|
paramSteelHalfWidth.Set(Unit.MMToFeet(25));
|
|
}
|
|
|
|
df = GetDefinition(info.family, "GuideShoeCoverGap");
|
|
if (df != null)
|
|
{
|
|
Parameter paramCoverGap = info.family.get_Parameter(df);
|
|
if (paramCoverGap != null)
|
|
paramCoverGap.Set(Unit.MMToFeet(3));
|
|
}
|
|
|
|
|
|
//가대 높이 재설정
|
|
//가이드 슈 두께
|
|
df = GetDefinition(info.family, "GuideShoeCoverThk");
|
|
if (df != null)
|
|
{
|
|
Parameter paramCoverThk = info.family.get_Parameter(df);
|
|
if (paramCoverThk != null)
|
|
{
|
|
paramCoverThk.Set(Unit.MMToFeet(5));//default value = 5
|
|
}
|
|
|
|
doc.Regenerate();
|
|
|
|
df = GetDefinition(info.family, "GuideShoeCoverThk");
|
|
if (df != null)
|
|
{
|
|
paramCoverThk = info.family.get_Parameter(df);
|
|
if (paramCoverThk != null)
|
|
{
|
|
m_CoverThk = paramCoverThk.AsDouble();
|
|
}
|
|
}
|
|
}
|
|
//받침대 두께
|
|
df = GetDefinition(info.family, "SupportThk");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSupThk = info.family.get_Parameter(df);
|
|
if (paramSupThk != null)
|
|
paramSupThk.Set(m_CoverThk);
|
|
}
|
|
|
|
|
|
//판 높이
|
|
df = GetDefinition(info.family, "SupportHeight");
|
|
if (df != null)
|
|
{
|
|
Parameter paramPlateHgt = info.family.get_Parameter(df);
|
|
if (paramPlateHgt != null)
|
|
{
|
|
m_plateHgt = paramPlateHgt.AsDouble();
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
//paramPlateHgt.Set(m_plateHgt
|
|
//+ (MinOffsetPipe.Diameter / 2.0 - info.pipe.Diameter / 2.0)
|
|
//+ (info.pipe.LevelOffset - MinOffsetPipe.LevelOffset) - insulThk);
|
|
paramPlateHgt.Set(m_plateHgt
|
|
+ (MinOffPipeOutDia / 2.0 - m_CurPipeOutDia / 2.0)
|
|
+ (info.pipe.LevelOffset - MinOffsetPipe.LevelOffset)
|
|
+ (MininsulThk - insulThk));
|
|
//paramPlateHgt.Set(m_plateHgt
|
|
//+ (MinOffsetPipe.Diameter / 2.0 - info.pipe.Diameter / 2.0)
|
|
//+ (info.pipe.LevelOffset - MinOffsetPipe.LevelOffset)
|
|
//+ (MininsulThk - insulThk));
|
|
}
|
|
else
|
|
{
|
|
//paramPlateHgt.Set(m_plateHgt + (MaxDiaPipe.Diameter / 2.0 - info.pipe.Diameter / 2.0) - insulThk);
|
|
paramPlateHgt.Set(m_plateHgt + (MaxPipeOutDia / 2.0 - m_CurPipeOutDia / 2.0) + (MaxinsulThk - insulThk));
|
|
//paramPlateHgt.Set(m_plateHgt + (MaxDiaPipe.Diameter / 2.0 - info.pipe.Diameter / 2.0) + (MaxinsulThk - insulThk));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else//U-볼트
|
|
{
|
|
if (info.family == null) continue;
|
|
|
|
//관경 변경
|
|
df = GetDefinition(info.family, "Diameter");
|
|
if (df != null)
|
|
{
|
|
Parameter paramDia = info.family.get_Parameter(df);
|
|
|
|
if (paramDia != null)
|
|
{
|
|
paramDia.Set(info.pipe.Diameter + insulThk * 2);
|
|
}
|
|
}
|
|
|
|
//외경 변경
|
|
df = GetDefinition(info.family, "OutDiameter");
|
|
if (df != null)
|
|
{
|
|
Parameter paramOutDia = info.family.get_Parameter(df);
|
|
if (paramOutDia != null)
|
|
{
|
|
Parameter p_outDia = info.pipe.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER);
|
|
if (MinOffsetPipe != null)
|
|
paramOutDia.Set(p_outDia.AsDouble() + MininsulThk * 2);
|
|
else
|
|
paramOutDia.Set(p_outDia.AsDouble() + MaxinsulThk * 2);
|
|
}
|
|
}
|
|
|
|
double boltDia = 0;
|
|
double mm_PipeDia = Unit.FeetToMM(info.pipe.Diameter);
|
|
if (mm_PipeDia >= 15 && mm_PipeDia <= 50)
|
|
boltDia = Unit.MMToFeet(10);
|
|
else if (mm_PipeDia >= 65 && mm_PipeDia <= 90)
|
|
boltDia = Unit.MMToFeet(12);
|
|
else if (mm_PipeDia >= 100 && mm_PipeDia <= 175)
|
|
boltDia = Unit.MMToFeet(16);
|
|
else if (mm_PipeDia >= 200 && mm_PipeDia <= 250)
|
|
boltDia = Unit.MMToFeet(20);
|
|
else if (mm_PipeDia >= 300 && mm_PipeDia <= 400)
|
|
boltDia = Unit.MMToFeet(24);
|
|
else if (mm_PipeDia >= 450 && mm_PipeDia <= 500)
|
|
boltDia = Unit.MMToFeet(30);
|
|
|
|
df = GetDefinition(info.family, "Bolt_Diameter");
|
|
if (df != null)
|
|
{
|
|
Parameter paramBoltDia = info.family.get_Parameter(df);
|
|
if (paramBoltDia != null)
|
|
paramBoltDia.Set(boltDia);
|
|
}
|
|
|
|
//높이 지정
|
|
df = GetDefinition(info.family, "Support_Height");
|
|
if (df != null)
|
|
{
|
|
Parameter paramSupportHgt = info.family.get_Parameter(df);
|
|
if (paramSupportHgt != null)
|
|
{
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
paramSupportHgt.Set(MinOffPipeOutDia / 2.0 + MininsulThk + (info.pipe.LevelOffset - MinOffsetPipe.LevelOffset));
|
|
}
|
|
else
|
|
paramSupportHgt.Set(MaxPipeOutDia / 2.0 + MaxinsulThk);
|
|
}
|
|
}
|
|
|
|
doc.Regenerate();
|
|
//간격 띄우기 값 구하기
|
|
double m_Offset = 0;
|
|
Parameter paramOffset = info.family.get_Parameter(BuiltInParameter.INSTANCE_FREE_HOST_OFFSET_PARAM);
|
|
if (paramOffset != null)
|
|
{
|
|
m_Offset = paramOffset.AsDouble();
|
|
//가장 큰 관경만큼 간격띄우기 조정
|
|
if (MinOffsetPipe != null)
|
|
paramOffset.Set(m_Offset - MinOffPipeOutDia / 2.0 - MininsulThk);
|
|
else
|
|
paramOffset.Set(m_Offset - MaxPipeOutDia / 2.0 - MaxinsulThk);
|
|
}
|
|
|
|
}
|
|
|
|
}//foreach end
|
|
|
|
//가대 오프셋,다리 길이 재설정 가이드 슈 일 떄
|
|
if (BoltType == 0)
|
|
{
|
|
//오프셋
|
|
Parameter paramRackOffset = Rack.get_Parameter(BuiltInParameter.INSTANCE_FREE_HOST_OFFSET_PARAM);
|
|
double rackOffset = paramRackOffset.AsDouble();
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
paramRackOffset.Set(rackOffset - MinOffPipeOutDia / 2.0 - m_plateHgt - m_CoverThk * 2 - MininsulThk);
|
|
//paramRackOffset.Set(rackOffset - MinOffsetPipe.Diameter / 2.0 - m_plateHgt - m_CoverThk * 2 - MininsulThk);
|
|
}
|
|
else
|
|
{
|
|
paramRackOffset.Set(rackOffset - MaxPipeOutDia / 2.0 - m_plateHgt - m_CoverThk * 2 - MaxinsulThk);
|
|
//paramRackOffset.Set(rackOffset - MaxDiaPipe.Diameter / 2.0 - m_plateHgt - m_CoverThk * 2 - MaxinsulThk);
|
|
}
|
|
|
|
|
|
//다리 길이
|
|
double SupLength = 0;
|
|
df = GetDefinition(Rack, "Support_Length");
|
|
if (df != null)
|
|
{
|
|
Parameter paramRackSupLen = Rack.get_Parameter(df);
|
|
SupLength = paramRackSupLen.AsDouble();
|
|
|
|
if (MinOffsetPipe != null)
|
|
{
|
|
paramRackSupLen.Set(SelectLevel.Elevation - MinOffsetPipe.ReferenceLevel.Elevation
|
|
- MinOffsetPipe.LevelOffset + m_plateHgt + m_CoverThk * 2
|
|
+ MinOffPipeOutDia / 2.0 + MininsulThk + Unit.MMToFeet(150));
|
|
//paramRackSupLen.Set(SelectLevel.Elevation - MinOffsetPipe.ReferenceLevel.Elevation
|
|
// - MinOffsetPipe.LevelOffset + m_plateHgt + m_CoverThk * 2
|
|
// + MinOffsetPipe.Diameter / 2.0 + MininsulThk + Unit.MMToFeet(150));
|
|
}
|
|
else
|
|
{
|
|
paramRackSupLen.Set(SelectLevel.Elevation - MaxDiaPipe.ReferenceLevel.Elevation
|
|
- MaxDiaPipe.LevelOffset + m_plateHgt + m_CoverThk * 2
|
|
+ MaxPipeOutDia / 2.0 + MaxinsulThk + Unit.MMToFeet(150));
|
|
//paramRackSupLen.Set(SelectLevel.Elevation - MaxDiaPipe.ReferenceLevel.Elevation
|
|
// - MaxDiaPipe.LevelOffset + m_plateHgt + m_CoverThk * 2
|
|
// + MaxDiaPipe.Diameter / 2.0 + MaxinsulThk + Unit.MMToFeet(150));
|
|
}
|
|
}
|
|
//if (MinOffsetPipe != null)
|
|
// paramRackSupLen.Set(SupLength + MinOffsetPipe.Diameter / 2.0 + m_plateHgt + m_CoverThk * 2);
|
|
//else
|
|
// paramRackSupLen.Set(SupLength + MaxDiaPipe.Diameter / 2.0 + m_plateHgt + m_CoverThk * 2);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 관경이 가장 큰 파이프 구하기
|
|
/// </summary>
|
|
/// <param name="pipeLst"></param> 파이프 리스트
|
|
/// <returns></returns>
|
|
private Pipe getMaxPipe(List<Pipe> pipeLst)
|
|
{
|
|
double MaxDia = 0;
|
|
Pipe MaxPipe = null;
|
|
|
|
foreach (Pipe pp in pipeLst)
|
|
{
|
|
double m_PipeDia = pp.Diameter;
|
|
//단열재 두께
|
|
double insulThk = Util.GetPipeInsulationThickness(doc, pp);
|
|
|
|
if (MaxDia < m_PipeDia + insulThk)
|
|
{
|
|
MaxDia = m_PipeDia + (insulThk * 2);
|
|
MaxPipe = pp;
|
|
}
|
|
}
|
|
|
|
|
|
return MaxPipe;
|
|
}
|
|
|
|
private Pipe getMinOffsetPipe(List<Pipe> pipeLst)
|
|
{
|
|
double MinOffset = double.MaxValue;
|
|
Pipe MinOffsetPipe = null;
|
|
|
|
bool b_other = false;
|
|
//파이프 간격띄우기 값이 다 같으면 null 리턴
|
|
foreach (Pipe pp in pipeLst)
|
|
{
|
|
if (pipeLst.First().LevelOffset != pp.LevelOffset)
|
|
{
|
|
b_other = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//파이프 간격띄우기 값이 다른게 있다면 실행
|
|
if (b_other)
|
|
{
|
|
foreach (Pipe pp in pipeLst)
|
|
{
|
|
double pipeOffset = pp.LevelOffset;
|
|
|
|
|
|
if (MinOffset > pipeOffset)
|
|
{
|
|
MinOffset = pipeOffset;
|
|
MinOffsetPipe = pp;
|
|
}
|
|
}
|
|
}
|
|
|
|
return MinOffsetPipe;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 기준점에서 가장 먼 파이프 구하기
|
|
/// </summary>
|
|
/// <param name="pipeList"></param> 파이프 리스트
|
|
/// <param name="DirPt"></param> 기준점
|
|
/// <param name="SideInterPt"></param> 기준점과 파이프 교차점
|
|
/// <returns></returns>
|
|
private List<PipeInfo> getSidePipe(List<Pipe> pipeList, XYZ DirPt, ref PipeInfo sideInfo1, ref PipeInfo sideInfo2)
|
|
{
|
|
|
|
double minDist = double.MaxValue;
|
|
double maxDist = 0;
|
|
|
|
List<PipeInfo> PipeInfoLst = new List<PipeInfo>();
|
|
foreach (Pipe pipe in pipeList)
|
|
{
|
|
Line line = (pipe.Location as LocationCurve).Curve as Line;
|
|
IntersectionResult interRes = line.Project(DirPt);
|
|
XYZ interPt = new XYZ(interRes.XYZPoint.X, interRes.XYZPoint.Y, 0);
|
|
|
|
PipeInfo info = new PipeInfo();
|
|
info.pipe = pipe;
|
|
info.InterPt = interPt;
|
|
PipeInfoLst.Add(info);
|
|
}
|
|
|
|
XYZ vec = (PipeInfoLst.First().InterPt - PipeInfoLst.Last().InterPt).Normalize();
|
|
XYZ virtualPt = Util.Polar(PipeInfoLst.First().InterPt, vec, Unit.MMToFeet(10000));
|
|
|
|
foreach (PipeInfo pipeInfo in PipeInfoLst)
|
|
{
|
|
if (maxDist < virtualPt.DistanceTo(pipeInfo.InterPt))
|
|
{
|
|
sideInfo1 = pipeInfo;
|
|
maxDist = virtualPt.DistanceTo(pipeInfo.InterPt);
|
|
}
|
|
|
|
if (minDist > virtualPt.DistanceTo(pipeInfo.InterPt))
|
|
{
|
|
sideInfo2 = pipeInfo;
|
|
minDist = virtualPt.DistanceTo(pipeInfo.InterPt);
|
|
}
|
|
}
|
|
//Util.Pyosi(doc, sideInfo1.InterPt, 1);
|
|
//MessageBox.Show("1");
|
|
//Util.Pyosi(doc, sideInfo2.InterPt, 1);
|
|
//MessageBox.Show("2");
|
|
return PipeInfoLst;
|
|
}
|
|
|
|
|
|
static Definition GetDefinition(Element elem, string parameter_name)
|
|
{
|
|
IList<Parameter> ps = elem.GetParameters(parameter_name);
|
|
|
|
int n = ps.Count;
|
|
|
|
Debug.Assert(1 >= n, "expected maximum one shared parameters" + "named " + parameter_name);
|
|
|
|
Definition d = (0 == n) ? null
|
|
: ps[0].Definition;
|
|
|
|
return d;
|
|
}
|
|
|
|
public class PipeSelectionFilter : ISelectionFilter
|
|
{
|
|
public bool AllowElement(Element element)
|
|
{
|
|
if (element.Category == null) return false;
|
|
if (element.Category.Id.IntegerValue == (int)BuiltInCategory.OST_PipeCurves)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
public bool AllowReference(Reference refer, XYZ point)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|