from System.Runtime.InteropServices import Marshal
import sys
import Autodesk
e_a = str("\xe9")
a_a = str("\xe0")
# INSERT LINK
# User select a revit file in folders
filepath = select_file('Revit Model (*.rvt)|*.rvt')
#start transaction
with db.Transaction('insert link'):
for path in filepath:
linkpath = DB.ModelPathUtils.ConvertUserVisiblePathToModelPath(
filepath)
linkoptions = DB.RevitLinkOptions(relative=True)
linkloadresult = DB.RevitLinkType.Create(revit.doc, linkpath, linkoptions)
linkinstance = DB.RevitLinkInstance.Create(revit.doc,
linkloadresult.ElementId)
# # Insert from Base Point to Base Point
# DB.RevitLinkInstance.MoveBasePointToHostBasePoint(linkinstance, resetToOriginalRotation = True)
# # Insert from Origin To Origin
# DB.RevitLinkInstance.MoveOriginToHostOrigin(linkinstance, resetToOriginalRotation = True)
# ACQUIRE COORDINATES FROM REVIT LINK
collector_maq = DB.FilteredElementCollector(revit.doc)
linkInstances = collector_maq.OfClass(DB.RevitLinkInstance)
linkDoc = [links.GetLinkDocument() for links in linkInstances]
collector_link = DB.FilteredElementCollector(linkDoc[0])
linkInstancesId = linkInstances.ToElementIds()
# SET COORDINATE TO MAQUETTE
import rpw
from rpw import revit, db, ui, DB, UI
from rpw.ui.forms import *
from System import Array
from System.Runtime.InteropServices import Marshal
import sys
import Autodesk
e_a = str("\xe9")
a_a = str("\xe0")
options = __revit__.Application.Create.NewGeometryOptions()
floor_collector = DB.FilteredElementCollector(revit.doc, revit.doc.ActiveView.Id)\
.OfCategory(DB.BuiltInCategory.OST_Floors)\
.WhereElementIsNotElementType()\
.ToElements()
beam_collector = DB.FilteredElementCollector(revit.doc, revit.doc.ActiveView.Id)\
.OfCategory(DB.BuiltInCategory.OST_StructuralFraming)\
.WhereElementIsNotElementType()\
.ToElements()
level_collector = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_Levels)\
.WhereElementIsNotElementType()\
.ToElements()
levels = {}
for level in level_collector:
def y(self, value):
self._revit_object = DB.XYZ(self.x, value, self.z)
#log(__file__)
from viewport_wrapper import Point, ViewPortWrapper
from viewport_wrapper import Point, ViewPortWrapper, move_to_match_vp_placment
tempfile = os.path.join(gettempdir(), 'ViewPlacement')
selection = rpw.ui.Selection()
try:
with open(tempfile, 'rb') as fp:
pt = pickle.load(fp)
except IOError:
UI.TaskDialog.Show(
'pyRevitPlus',
'Could not find saved viewport placement.\nCopy a Viewport Placement first.'
)
sys.exit()
else:
saved_pt = DB.XYZ(pt.X, pt.Y, pt.Z)
for viewsheet in [
e for e in selection.elements if isinstance(e, DB.ViewSheet)
]:
viewports = rpw.db.Collector(view=viewsheet, of_class='Viewport').elements
for viewport in viewports:
view = doc.GetElement(viewport.ViewId)
if isinstance(view, DB.ViewPlan):
move_to_match_vp_placment(viewport, saved_pt)
break
__window__.Close()
def test_corce_element_ref_id(self):
wall_id = DB.ElementId(self.wall.Id.IntegerValue)
elements = rpw.utils.coerce.to_elements([wall_id])
self.assertTrue(all([isinstance(e, DB.Element) for e in elements]))
def setUpClass(cls):
logger.title('TESTING COLLECTOR...')
collector = DB.FilteredElementCollector(doc)
cls.family_loaded = collector.OfCategory(
DB.BuiltInCategory.OST_Furniture).ToElements()
from System.Collections.Generic import List
from rpw import revit, db, ui, DB, UI
# from rpw.ui.forms import *
# from System import Array
# from System.Runtime.InteropServices import Marshal
import sys
import Autodesk
from Autodesk.Revit.DB import *
from Autodesk.Revit.UI import *
clr.AddReference('System.Drawing')
clr.AddReference('System.Windows.Forms')
from System.Drawing import *
from System.Windows.Forms import *
# COLLECT SHEET MAQUETTE
sheet_category = DB.FilteredElementCollector(revit.doc).OfCategory(
BuiltInCategory.OST_Sheets)
sheet_element = sheet_category.WhereElementIsNotElementType()
sheet_name = [sheets.Name for sheets in sheet_element]
sheet_id = [sheets.Id for sheets in sheet_element]
sheet_elementId = [
DB.Document.GetElement(revit.doc, sheets) for sheets in sheet_id
]
# Dictionnary for sheet : keys are names and values are elementId
dico_sheet_nameToElementId = {}
for k in range(len(sheet_name)):
dico_sheet_nameToElementId[str(sheet_name[k])] = sheet_elementId[k]
# COLLECT REVISION MAQUETTE
revisions_category = DB.FilteredElementCollector(revit.doc).OfCategory(
BuiltInCategory.OST_Revisions)
revision_element = revisions_category.WhereElementIsNotElementType()
def from_int(id_int):
element = doc.GetElement(DB.ElementId(id_int))
return Element(element)
def __init__(self, name=None, doc=revit.doc):
if name is None:
name = 'RPW Transaction'
super(Transaction, self).__init__(DB.Transaction(doc, name))
self.transaction = self._revit_object
def __init__(self, name=None):
if name is None:
name = 'RPW Transaction'
self.transaction = DB.Transaction(doc, name)
# coding: utf8
import rpw
from rpw import DB
__doc__ = "Designed for annotation families. It moves selected annotation to center (set 0,0,0 coordinates)"
__title__ = "Label/Text"
__author__ = "Cyril Waechter"
__context__ = 'Selection'
with rpw.db.Transaction():
for text_element in rpw.ui.Selection():
text_element.Coord = DB.XYZ()
def uv_to_pt(uv):
return DB.XYZ(uv.U, uv.V, 0)
def from_int(id_int):
""" Instantiate Element from an Integer representing and Id """
element = revit.doc.GetElement(DB.ElementId(id_int))
return Element(element)
doc_active = revit.uidoc.ActiveView
# Collect CAD links
# Note: Because we import DB, we can call on ImportInstance
dwg_collector = db.Collector(of_class = 'ImportInstance', is_type=False)
dwg_elements = dwg_collector.get_elements()
# Collect views
view_collector = db.ViewPlan.collect()
# Set Color
color_gray = DB.Color(80,80,80)
# Create Class for Override
ogs = DB.OverrideGraphicSettings().SetProjectionLineColor(color_gray)
# Start transaction
t = db.Transaction('Set Linked CADs to Gray')
t.Start()
# The SetElementOverrides method requires element ID and override instance
for view in view_collector:
for dwg in dwg_elements:
dwg_id = dwg.Id
def test_category2(self):
rv = DB.FilteredElementCollector(doc).OfCategory(
DB.BuiltInCategory.OST_Levels).WhereElementIsNotElementType(
).ToElements()
rv2 = rpw.db.Collector(of_category="Levels", is_type=False)
self.assertEqual(len(rv), len(rv2))
stopwatch = Stopwatch()
stopwatch.Start()
dtype_methods = {
DB.StorageType.String: DB.Parameter.AsString,
DB.StorageType.Integer: DB.Parameter.AsDouble,
DB.StorageType.Double: DB.Parameter.AsDouble,
DB.StorageType.ElementId: DB.Parameter.AsElementId,
}
dtype_empty = {
DB.StorageType.String: "",
DB.StorageType.Integer: 0.0,
DB.StorageType.Double: 0.0,
DB.StorageType.ElementId: DB.ElementId(-1),
}
ignored_durchbruch_ids = [
# "S037U01", # UG1
]
ft_mm = 304.8
up = XYZ(0, 0, 1)
non_struct = Structure.StructuralType.NonStructural
geo_opt = Options()
rvt_link_opt = RevitLinkOptions(False)
project_lvl_code = None
project_number = doc.ProjectInformation.LookupParameter(
"Project Number").AsString()
if project_number.isdigit() and len(project_number) == 3:
def test_class(self):
rv = DB.FilteredElementCollector(doc).OfClass(DB.View).ToElements()
rv2 = rpw.db.Collector(of_class="View")
self.assertEqual(len(rv), len(rv2))
__title__ = "Open in\nExcel"
import os
import sys
import subprocess
import time
import rpw
from rpw import doc, uidoc, DB, UI
EXCELPATHS_FILENAME = 'OpenInExcel_UserPaths.txt'
EXCELPATHS_FILEPATH = os.path.join(os.path.dirname(__file__), EXCELPATHS_FILENAME)
# Export Settings
temp_folder = os.path.expandvars('%temp%\\')
export_options = DB.ViewScheduleExportOptions()
# Get Saved Excelp Paths
if not os.path.exists(EXCELPATHS_FILEPATH):
UI.TaskDialog.Show('OpenInExcel', 'Could not find the File: \n'
'{} in:\n {}'.format(
EXCELPATHS_FILENAME, os.path.dirname(__file__)))
sys.exit()
with open(EXCELPATHS_FILEPATH) as fp:
excel_paths = fp.read().split('\n')
for excel_path in excel_paths:
if os.path.exists(excel_path):
recipient = excel_path
break
"4102-Small AV",
"4103-Conversation",
"4108-Micro AV",
"4104-Brainstorm",
"4105-Large AV",
"4106-Boardroom",
"4107-Classroom",
]
all_sheet_numbers = []
all_sheet_names = []
for sheet_name in sheet_names:
for i in range(1, 5):
all_sheet_names.append(sheet_name + "-Type {}".format(i))
all_sheet_numbers.append(sheet_name.split("-")[0] + "." + str(i))
viewTypeId = DB.ElementId(10522069)
view_data = {
"WW-ViewCategory": "Working",
"WW-ViewSubCategory": "0000 Architecture"
}
params = ["WW-ViewCategory", "WW-ViewSeries", "WW-ViewSubCategory"]
with db.Transaction("Add Elevation Marker"):
for sheet_name in all_sheet_names:
print("pick point for {}".format(sheet_name))
pt = ui.Pick.pick_pt().unwrap()
col = db.Collector(of_class="ViewSection",
is_type=False,
where=lambda x: sheet_name in x.Name)
col = col.unwrap()
# UI.TaskDialog.Show('pyRevitPlus', 'Grid element \'{}\''.format(cAxis.Name))
#UI.TaskDialog.Show('pyRevitPlus', 'Found saved grid element \'{}\''.format(cAxis.Name))
curves = cAxis.GetCurvesInView(DB.DatumExtentType.ViewSpecific, cView)
if len(curves) <> 1:
UI.TaskDialog.Show(
'pyRevitPlus',
'The grid line is defind by {} curves, unable to proceed',
len(curves))
else:
cCurve = curves[0]
cGridData = GridLines[GridLines.keys()[0]]
tmp = cCurve.GetEndPoint(0)
if cView.ViewType == DB.ViewType.Section or cView == DB.ViewType.Elevation:
pt0 = DB.XYZ(tmp.X, tmp.Y, cGridData['Start'].Z)
else:
pt0 = DB.XYZ(cGridData['Start'].X, cGridData['Start'].Y, tmp.Z)
tmp1 = cCurve.GetEndPoint(1)
if cView.ViewType == DB.ViewType.Section or cView == DB.ViewType.Elevation:
pt1 = DB.XYZ(tmp.X, tmp.Y, cGridData['End'].Z)
else:
pt1 = DB.XYZ(cGridData['End'].X, cGridData['End'].Y, tmp1.Z)
if isinstance(cCurve, DB.Arc):
#ptc = DB.XYZ(cGridData['Center'].X, cGridData['Center'].Y, tmp1.Z)
# take mid-point of the exixting curve as reference. Will cause trouble.
# should't, if the grid is not extremelly modified, eg, reversed
ptRef = cCurve.Evaluate(0.5, True)
gridline = DB.Arc.Create(pt0, pt1, ptRef)
"4108-Micro AV",
"4104-Brainstorm",
"4105-Large AV",
"4106-Boardroom",
"4107-Classroom",
]
# create seet names & numbers
all_sheet_numbers = []
all_sheet_names = []
for sheet_name in sheet_names:
for i in range(1, 5):
all_sheet_names.append(sheet_name + "-Type {}".format(i))
all_sheet_numbers.append(sheet_name.split("-")[0] + "." + str(i))
plan_view = doc.GetElement(DB.ElementId(11335718))
rcp_view = doc.GetElement(DB.ElementId(11632340))
def duplicate_view(view, cropbox, name_suffix):
duplicate_plan = doc.GetElement(
view.Duplicate(DB.ViewDuplicateOption.AsDependent))
duplicate_plan.Name = sheet_name + name_suffix
duplicate_plan.CropBoxActive = True
duplicate_plan.CropBox = cropbox
duplicate_plan.CropBoxVisible = False
return duplicate_plan
with db.Transaction("Duplicate View"):
for sheet_name in all_sheet_names:
def setUp(self):
self.wall = DB.FilteredElementCollector(revit.doc).OfClass(
DB.Wall).ToElements()[0]
self.wrapped_wall = rpw.db.Element(self.wall)
def test_xyz_from_DB_XYZ(self):
pt = XYZ(DB.XYZ(2,4,6))
self.assertEqual(pt.X, 2)
self.assertEqual(pt.Y, 4)
self.assertEqual(pt.Z, 6)
def test_detail_line(self):
self.assertIsInstance(self.detail_line, DB.DetailLine)
curve = self.detail_line.GeometryCurve
self.assertTrue(
curve.GetEndPoint(1).IsAlmostEqualTo(DB.XYZ(10, 10, 0)))
@rpw.db.Transaction.ensure('Make Floor')
def make_floor(new_floor):
floor_curves = DB.CurveArray()
for boundary_segment in new_floor.boundary:
try:
floor_curves.Append(boundary_segment.Curve) # 2015, dep 2016
except AttributeError:
floor_curves.Append(boundary_segment.GetCurve()) # 2017
floorType = doc.GetElement(new_floor.floor_type_id)
level = doc.GetElement(new_floor.level_id)
normal_plane = DB.XYZ.BasisZ
doc.Create.NewFloor(floor_curves, floorType, level, False, normal_plane)
NewFloor = namedtuple('NewFloor', ['floor_type_id', 'boundary', 'level_id'])
new_floors = []
room_boundary_options = DB.SpatialElementBoundaryOptions()
for room in selected_rooms:
room_level_id = room.Level.Id
# List of Boundary Segment comes in an array by itself.
room_boundary = room.GetBoundarySegments(room_boundary_options)[0]
new_floor = NewFloor(floor_type_id=floor_type_id,
boundary=room_boundary,
level_id=room_level_id)
new_floors.append(new_floor)
for new_floor in new_floors:
make_floor(new_floor)
def setUpClass(cls):
logger.title('TESTING Line...')
pt1 = DB.XYZ(0, 0, 0)
pt2 = DB.XYZ(10, 10, 0)
cls.Line = DB.Line.CreateBound(pt1, pt2)
cls.line = db.Line.new(pt1, pt2)
def x(self, value):
self._revit_object = DB.XYZ(value, self.y, self.z)
def test_collector_elements_view_element_another(self):
# Id of view where everything is hidden
view_hidden = doc.GetElement(DB.ElementId(12531))
x = self.collector_helper({'of_class': DB.Wall, 'view': view_hidden})
self.assertEqual(len(x), 0)
def z(self, value):
self._revit_object = DB.XYZ(self.x, self.y, value)
uidoc = rpw.uidoc
class_dict = {
'family': {
'class': DB.FamilyInstance
},
'system': {
'class': DB.MEPSystem
},
'space': {
'class': DB.SpatialElement
}
}
for k, v in class_dict.items():
element = DB.FilteredElementCollector(doc).OfClass(
class_dict[k]['class']).FirstElement()
class_dict[k]['parameter_name_list'] = sorted(
[parameter.Definition.Name for parameter in element.Parameters])
class_dict[k]['regex'] = re.compile(
r"({})\(([\w\s]+)\)".format(k)) # class_key(parameter_name)
def set_parameter_value(pattern):
with rpw.db.Transaction("Apply pattern to parameters"):
for element in rpw.ui.Selection():
applied_pattern = apply_pattern(element, pattern)
rpw.db.Element(element).parameters['name'].value = applied_pattern
def apply_pattern(element, pattern):
for k, v in class_dict.items():
