# pyRevit 스크립트 예제
from pyrevit import revit, DB

# 현재 문서에서 모든 벽 수집
doc = revit.doc
walls = DB.FilteredElementCollector(doc)\
    .OfClass(DB.Wall)\
    .ToElements()

# 벽 정보 출력
for wall in walls:
    wall_type = wall.WallType.Name
    print("벽 ID: {} | 타입: {} | 길이: {:.2f}m".format(
        wall.Id.IntegerValue,
        wall_type,
        wall.get_Parameter(DB.BuiltInParameter.CURVE_ELEM_LENGTH).AsDouble() * 0.3048
    ))

# pyRevit: 선택한 요소들의 마크(Mark) 파라미터를 일괄 수정
from pyrevit import revit, DB, forms

doc = revit.doc

# 카테고리 선택 대화상자
selected_cat = forms.SelectFromList.show(
    ['Walls', 'Doors', 'Windows'],
    title='파라미터 수정 대상 카테고리'
)

# 카테고리별 BuiltInCategory 매핑
cat_map = {
    'Walls': DB.BuiltInCategory.OST_Walls,
    'Doors': DB.BuiltInCategory.OST_Doors,
    'Windows': DB.BuiltInCategory.OST_Windows
}

if selected_cat:
    elements = DB.FilteredElementCollector(doc)\
        .OfCategory(cat_map[selected_cat])\
        .WhereElementIsNotElementType()\
        .ToElements()

    # 접두사 입력
    prefix = forms.ask_for_string(
        prompt='마크 접두사를 입력하세요',
        title='일괄 마크 수정'
    )

    if prefix:
        with revit.Transaction("마크 일괄 수정"):
            count = 0
            for i, elem in enumerate(elements):
                mark_param = elem.get_Parameter(DB.BuiltInParameter.ALL_MODEL_MARK)
                if mark_param and not mark_param.IsReadOnly:
                    mark_param.Set("{}-{:04d}".format(prefix, i + 1))
                    count += 1

        print("{}개 요소의 마크를 수정했습니다.".format(count))

import rhinoscriptsyntax as rs
import Rhino.Geometry as rg

# rhinoscriptsyntax 방식 - 간결하고 직관적
line_id = rs.AddLine((0, 0, 0), (10, 0, 0))
circle_id = rs.AddCircle((5, 5, 0), 3)

# RhinoCommon 직접 사용 - 더 강력하고 세밀한 제어
pt1 = rg.Point3d(0, 0, 0)
pt2 = rg.Point3d(10, 0, 0)
pt3 = rg.Point3d(10, 10, 5)

# 3개 점을 지나는 NURBS 커브
curve = rg.NurbsCurve.Create(False, 3, [pt1, pt2, pt3])

# 커브를 회전하여 곡면 생성 (Revolution Surface)
axis = rg.Line(rg.Point3d(0, 0, 0), rg.Point3d(0, 0, 1))
rev_srf = rg.RevSurface.Create(curve, axis)
brep = rev_srf.ToBrep()

print("생성된 Brep 면 수: {}".format(brep.Faces.Count))

import Rhino.Geometry as rg
import csv
import os

# CSV 파일에서 좌표 데이터 읽기
csv_path = r"C:\data\building_footprints.csv"
buildings = []

with open(csv_path, 'r') as f:
    reader = csv.DictReader(f)
    for row in reader:
        # CSV 컬럼: x, y, width, depth, height
        x = float(row['x'])
        y = float(row['y'])
        w = float(row['width'])
        d = float(row['depth'])
        h = float(row['height'])

        # 바닥 사각형 생성
        corners = [
            rg.Point3d(x, y, 0),
            rg.Point3d(x + w, y, 0),
            rg.Point3d(x + w, y + d, 0),
            rg.Point3d(x, y + d, 0)
        ]

        # 폴리라인 -> 커브 -> 돌출(Extrusion)
        polyline = rg.Polyline(corners + [corners[0]])
        curve = polyline.ToNurbsCurve()
        extrusion = rg.Extrusion.Create(
            curve, h, True  # 높이, 캡 여부
        )

        if extrusion:
            buildings.append(extrusion.ToBrep())

print("{}개 건물 형상 생성 완료".format(len(buildings)))

# Grasshopper 출력
a = buildings

# Dynamo Python 노드 (PythonNet3)
import clr

# Revit API 라이브러리 로드
clr.AddReference('RevitAPI')
clr.AddReference('RevitServices')

from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager

# 현재 Revit 문서 가져오기
doc = DocumentManager.Instance.CurrentDBDocument

# 모든 레벨 수집
collector = FilteredElementCollector(doc)
levels = collector.OfClass(Level).ToElements()

# 레벨 이름과 높이 출력
output = []
for level in levels:
    name = level.Name
    elevation = level.Elevation * 304.8  # feet -> mm
    output.append("{}: {:.0f}mm".format(name, elevation))

# Dynamo 출력 (OUT 변수에 할당)
OUT = output

# Dynamo Python 노드: 방(Room) 데이터를 CSV로 내보내기
import clr
import csv

clr.AddReference('RevitAPI')
clr.AddReference('RevitServices')

from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Architecture import Room
from RevitServices.Persistence import DocumentManager

doc = DocumentManager.Instance.CurrentDBDocument

# 모든 Room 수집
rooms = FilteredElementCollector(doc)\
    .OfCategory(BuiltInCategory.OST_Rooms)\
    .WhereElementIsNotElementType()\
    .ToElements()

# 데이터 수집
room_data = []
for room in rooms:
    if room.Area > 0:  # 배치된 방만
        data = {
            'Number': room.Number,
            'Name': room.get_Parameter(BuiltInParameter.ROOM_NAME).AsString(),
            'Area_sqm': round(room.Area * 0.092903, 2),  # sqft -> sqm
            'Level': room.Level.Name,
            'Department': room.get_Parameter(
                BuiltInParameter.ROOM_DEPARTMENT
            ).AsString() or 'N/A'
        }
        room_data.append(data)

# CSV 내보내기
output_path = r"C:\temp\room_schedule.csv"
with open(output_path, 'w', newline='', encoding='utf-8-sig') as f:
    writer = csv.DictWriter(f, fieldnames=room_data[0].keys())
    writer.writeheader()
    writer.writerows(room_data)

OUT = "{}개 방 데이터를 {}에 저장했습니다.".format(len(room_data), output_path)

# ArchiCAD Python API: 벽 목록 조회
from archicad import ACConnection

# ArchiCAD에 연결 (ArchiCAD가 실행 중이어야 함)
conn = ACConnection.connect()
assert conn, "ArchiCAD 연결 실패"

acc = conn.commands   # 명령 인터페이스
act = conn.types      # 타입 정의
acu = conn.utilities  # 유틸리티 함수

# 모든 벽 요소 가져오기
walls = acc.GetElementsByType('Wall')
print("벽 개수: {}".format(len(walls)))

# 벽의 속성값 조회
property_ids = [
    acu.GetBuiltInPropertyId('General_ElementID'),
    acu.GetBuiltInPropertyId('General_Height'),
    acu.GetBuiltInPropertyId('General_Thickness')
]

# 각 벽의 속성 출력
element_ids = [wall.elementId for wall in walls]
property_values = acc.GetPropertyValuesOfElements(element_ids, property_ids)

for i, wall_props in enumerate(property_values):
    print("벽 {}: ID={}, 높이={}, 두께={}".format(
        i + 1,
        wall_props[0].propertyValue.value if wall_props[0].propertyValue else 'N/A',
        wall_props[1].propertyValue.value if wall_props[1].propertyValue else 'N/A',
        wall_props[2].propertyValue.value if wall_props[2].propertyValue else 'N/A'
    ))

# ArchiCAD Python API: 프로젝트 데이터를 JSON으로 내보내기
import json
from archicad import ACConnection

conn = ACConnection.connect()
assert conn

acc = conn.commands
acu = conn.utilities

# 여러 요소 타입 조회
element_types = ['Wall', 'Column', 'Slab', 'Door', 'Window']
project_data = {}

for elem_type in element_types:
    elements = acc.GetElementsByType(elem_type)

    if not elements:
        continue

    # 속성 ID 준비
    prop_ids = [
        acu.GetBuiltInPropertyId('General_ElementID'),
        acu.GetBuiltInPropertyId('General_Area'),
        acu.GetBuiltInPropertyId('General_Volume')
    ]

    elem_ids = [e.elementId for e in elements]
    props = acc.GetPropertyValuesOfElements(elem_ids, prop_ids)

    type_data = []
    for i, elem_props in enumerate(props):
        entry = {
            'guid': str(elem_ids[i].guid),
            'element_id': str(elem_props[0].propertyValue.value) if elem_props[0].propertyValue else None,
            'area': elem_props[1].propertyValue.value if elem_props[1].propertyValue else None,
            'volume': elem_props[2].propertyValue.value if elem_props[2].propertyValue else None
        }
        type_data.append(entry)

    project_data[elem_type] = {
        'count': len(type_data),
        'elements': type_data
    }

# JSON 파일로 내보내기
output_path = r"C:\temp\archicad_export.json"
with open(output_path, 'w', encoding='utf-8') as f:
    json.dump(project_data, f, indent=2, ensure_ascii=False)

print("내보내기 완료: {}".format(output_path))
for et, data in project_data.items():
    print("  {}: {}개".format(et, data['count']))

import ifcopenshell
import ifcopenshell.util.element
import ifcopenshell.geom

# IFC 파일 열기
model = ifcopenshell.open("building.ifc")

# 프로젝트 정보
project = model.by_type("IfcProject")[0]
print("프로젝트: {}".format(project.Name))

# 모든 벽 조회
walls = model.by_type("IfcWall")
print("벽 개수: {}".format(len(walls)))

# 벽 상세 정보 추출
for wall in walls[:5]:  # 처음 5개만
    # 기본 속성
    info = wall.get_info()
    print("\n벽: {} (GlobalId: {})".format(wall.Name, wall.GlobalId))

    # 프로퍼티 셋 조회
    psets = ifcopenshell.util.element.get_psets(wall)
    for pset_name, props in psets.items():
        print("  [{}]".format(pset_name))
        for key, value in props.items():
            if key != 'id':
                print("    {}: {}".format(key, value))

# 지오메트리 추출
settings = ifcopenshell.geom.settings()
wall = walls[0]
shape = ifcopenshell.geom.create_shape(settings, wall)

# 삼각형 메시 데이터
verts = shape.geometry.verts     # [x1,y1,z1, x2,y2,z2, ...]
faces = shape.geometry.faces     # [v1,v2,v3, v1,v2,v3, ...]
print("\n지오메트리 - 정점: {}, 면: {}".format(
    len(verts) // 3, len(faces) // 3
))

import ifcopenshell

# 새 IFC4 파일 생성
ifc = ifcopenshell.file(schema="IFC4")

# 프로젝트 구조 생성
project = ifc.create_entity("IfcProject", Name="테스트 프로젝트")
context = ifc.create_entity("IfcGeometricRepresentationContext",
    ContextType="Model", CoordinateSpaceDimension=3)

site = ifc.create_entity("IfcSite", Name="현장")
building = ifc.create_entity("IfcBuilding", Name="건물")
storey = ifc.create_entity("IfcBuildingStorey", Name="1층")

# 관계 설정
ifc.create_entity("IfcRelAggregates",
    RelatingObject=project, RelatedObjects=[site])
ifc.create_entity("IfcRelAggregates",
    RelatingObject=site, RelatedObjects=[building])
ifc.create_entity("IfcRelAggregates",
    RelatingObject=building, RelatedObjects=[storey])

# 파일 저장
ifc.write("output.ifc")
print("IFC 파일 생성 완료")