Результаты поиска для 'list'

[Андрей]

Всем добрый день. Пытаюсь написать алгоритм по группировке трубных трасс .Всего 4 списка.Есть список труб(list_c), есть список отводов(list_w).Есть список труб к которым присоединены отводы(list_c_c) (два или один) и есть список отводов  которым присоединены трубы((list_w_c) .Необходимо создать список с вложенными списками в которые входят все элементы которые создают одну непрерывную сеть

Алгоритмы был написан и протестирован в Microsoft Visual code.Всё работает(если списки состоят из текстовых значений). Пытаюсь перенести его в Dynamo. Пока без успешно. Программа бесконечно зацикливается. Может быть подскажете в чё может быть дело.

[Илья]

Хотел найти перемещение с прикрепленными элементами. Наткнулся вот на эту тему. Почему то в пакетах не нашел. Но зато в пакете Clockwork нашел НОД … Element.CopyByVector , который можно посмотреть. Дальше по наитию внутри заменил Copy на Move и вуаля. Теперь нужные элементы таскаются скопом без откреплений.

Суть в целом в методе … ElementTransformUtils.MoveElements(doc,itemlist,xyz)

…..

https://disk.yandex.ru/d/qhhP-McxKqvvSQ

 

[ZHUN]

Добрый день, столкнулся с такой проблемой , при копировании армирования колонн, Основа остается та колонна, с которой копировала. Решил добавить функцию принадлежности элемента, к которому копируется, но походу пошло что-то не так. Он присваивает элементы по разному к колоннам

Вот,  код. Мысль есть, что не правильно работаю со списком. Так как пишу первый раз пишу код,  не могу четкого представлении о работе

import clr
from System.Collections.Generic import *
clr.AddReference(‘RevitAPI’)
from Autodesk.Revit.DB import *
import Autodesk

clr.AddReference(“RevitNodes”)
import Revit
clr.ImportExtensions(Revit.Elements)
clr.ImportExtensions(Revit.GeometryConversion)

clr.AddReference(‘System’)
from System.Collections.Generic import List

clr.AddReference(“RevitServices”)
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

doc = DocumentManager.Instance.CurrentDBDocument

items = UnwrapElement(IN[0])

xyz = UnwrapElement(IN[1])
newHost = UnwrapElement(IN[2])

#hostId = UnwrapElement(IN[2]).Id
axis = UnwrapElement(IN[4])
angle = IN[3]

idx = []
for item in newHost:
idx.append(item.Id)
itexlist = List[ElementId](idx)

ids = list()
for item in items:
ids.append(item.Id)
itemlist = List[ElementId](ids)

TransactionManager.Instance.EnsureInTransaction(doc)
for x,y,z in zip(xyz,angle,itexlist):
newitems = ElementTransformUtils.CopyElements(doc,itemlist,x.ToXyz())
for rebarElement in z:
rebarElement.SetHostId(doc,z.Id)

elementlist = list()
for item in newitems:
elementlist.append(doc.GetElement(item).ToDSType(False))

OUT = itexlist

[Максим]

Доброго времени суток, я новичок в python и dynamo.  Столкнулся с необходимостью автоматизировать создание отверстий для конструкции типа балка (каркас несущий). Нашел формирование отверстий для коммуникаций из ролика https://www.youtube.com/watch?v=wPbfz6YxNJw.  Проблемы с которыми я столкнулся: оригинал работал с шириной и высотой коммуникаций через BuiltInParameter,  но у балки эти параметры спрятаны в свойствах типа, по умолчанию там доступна длина. Я пытался добраться до параметров высоты и ширины балки и отправить в BuiltInParameter, но он принимает только Guid, а как я понял, возможно плохо понял, но у этих параметров нет Guid, я попытался создать их через ExternalDefinitionCreationOptions. не помогло. тогда решил работать от длины, и вычислять отверстия в зависимости от длины. В итоге вылезла ошибка, File “<string>”, line 218, in getCommunicationDirection UnboundLocalError: Local variable ‘direction’ referenced before assignment.

Помогите, пожалуйста, с адаптацией или подскажите как еще это можно сделать если через подобную адаптацию это сделать невозможно.

оригинал из ролика

<p>

#————————————————————————————————————————-
# ЗАГРУЗКА СИСТЕМНЫХ БИБЛИОТЕК И ОПЦИЙ
#————————————————————————————————————————-
import clr
import math
from System.Collections.Generic import *

clr.AddReference(‘RevitAPI’)
import Autodesk
from Autodesk.Revit.DB import *

# Определение опций Revit API
options = Options()
intersectionOptions = SolidCurveIntersectionOptions() # для нахождения пересечения
nonStructural = Autodesk.Revit.DB.Structure.StructuralType.NonStructural # для вставки семейства в основу

# Категории коммуникаций
pipeCategory = BuiltInCategory.OST_PipeCurves
ductCategory = BuiltInCategory.OST_DuctCurves
conduitCategory = BuiltInCategory.OST_Conduit
cableTrayCategory = BuiltInCategory.OST_CableTray
frameCat = BuiltInCategory.OST_StructuralFraming

clr.AddReference(‘RevitServices’)
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

#————————————————————————————————————————-
# ВХОДНЫЕ ДАННЫЕ
#————————————————————————————————————————-

# Типоразмеры семейств проёмов
rectangularFamilyForWall = UnwrapElement(IN[0]) # прямоугольной для стен
roundFamilyForWall = UnwrapElement(IN[1]) # круглой для стен
rectangularFamilyForFloor = UnwrapElement(IN[2]) # прямоугольной для плит
roundFamilyForFloor = UnwrapElement(IN[3]) # круглой для плит

# Экземпляры выбранных конструкций (если выбраны)
selectElements = UnwrapElement(IN[4])
try:
selectElements.Count
except:
if selectElements is not None:
selectElements = [UnwrapElement(IN[4])]

# Запас сторон для проёмов
isReservByCoefficient = IN[5] # запас задаётся коэффициентом?
if isReservByCoefficient:
reserv = IN[6] # запас для проёма как отношение сторон
else:
reserv = IN[6] / 304.8 # запас для проёма в мм

# Условия формирования круглого, а не прямоугольного, проёма
maxAspectRatio = IN[7] # максимальное отношение сторон коммуникации для круглого отверстия
maxDiameter = IN[8] / 304.8 # максимальный диаметр для круглого отверстия

# Работа со связанными файлами
isLinkDocument = IN[9] # конструкции в связанном файле?
nameLinkDocument = IN[10] # часть имени связанного файла с конструкциями

# Типы обрабатываемых конструкций
includeWalls = IN[11] # обрабатывть стены?
includeFloors = IN[12] # обрабатывать перекрытия?

# Значения параметров проёмов
comment = IN[13] # дата или другой комментарий (для версионирования)
disciplineName = IN[14] # дисциплина проёма

# Имена параметров проёмов
disciplineParameter = IN[15] # параметр дисциплины
diameterParameter = IN[16] # параметр диаметра
widthParameter = IN[17] # параметр ширины
heightParameter = IN[18] # параметр высоты
commentParameter = IN[19] # параметр комментария

#————————————————————————————————————————-
# ПОЛУЧЕНИЕ ДАННЫХ ИЗ ПРОЕКТА
#————————————————————————————————————————-

# Получение текущего проекта
currentDoc = DocumentManager.Instance.CurrentDBDocument

# Получение списка связанных файлов
linkInstances = FilteredElementCollector(currentDoc).OfClass(RevitLinkInstance)

# Определение файла, в котором содержатся конструкции
if isLinkDocument:
a = 0
for linkInstance in linkInstances:
if nameLinkDocument in linkInstance.Name:
docWithCommunications = linkInstance.GetLinkDocument()
a = 1
# Если связанный файл с подходящим именем не найден, то берём текущий файл
if a == 0:
docWithCommunications = currentDoc
else:
docWithCommunications = currentDoc

#————————————————————————————————————————-
# СОЗДАНИЕ КЛАССОВ И ФУНКЦИЙ
#————————————————————————————————————————-

# Класс стены с нужными свойствами
class WallObject:
# Инициализация свойств класса
def __init__(self, instance, width, A, B, solid, level):
self.instance = instance # экзмепляр стены в модели
self.width = width # толщина стены
self.A = A # коэффициент A уравнения прямой стены
self.B = B # коэффициент B уравнения прямой стены
self.solid = solid # объёмная геометрия стены
self.level = level # уровень, на котором размещена стена

# Класс плиты с нужными свойствами
class FloorObject:
def __init__(self, instance, solid, level):
self.instance = instance # экземпляр плиты в модели
self.solid = solid # объёмная геометрия плиты
self.level = level # уровень, на котором размещена плита

# Класс коммуникации с нужными свойствами
class CommunicationObject:
def __init__(self, width, height, A, B, C, direction, centerPoint):
self.width = width # ширина сечения коммуникации
self.height = height # высота сечения коммуникации
self.A = A # коэффициент A уравнения прямой коммуникации
self.B = B # коэффициент B уравнения прямой коммуникации
self.C = C # коэффициент C уравнения прямой коммуникации
self.direction = direction # направление для расположения проёма плиты
self.centerPoint = centerPoint # центр пересечения коммуникации и конструкции

# Функция получения координат начальной и конечной точки линии
def getLineCoordinates(line):
endPoint0 = line.GetEndPoint(0) # получение начальной точки кривой
endPoint1 = line.GetEndPoint(1) # получение конечной точки кривой
x0 = endPoint0.X; y0 = endPoint0.Y; z0 = endPoint0.Z # получение координат начальной точки
x1 = endPoint1.X; y1 = endPoint1.Y; z1 = endPoint1.Z # получение координат начальной точки
coordinates = x0, y0, z0, x1, y1, z1
return coordinates

# Функция получения объёмной геометрии конструкции
def getSolid(construction):
geometry = construction.get_Geometry(options)
for object in geometry:
solid = object
return solid

# Функция создания экземпляра класса Wall
def createWallObject(wall):
width = wall.Width # получение толщины экземпляра стены
x0, y0, z0, x1, y1, z1 = getLineCoordinates(wall.Location.Curve) # получение координат прямой эскиза стены
A = y0 – y1 # получение коэффициента A уравнения прямой
B = x1 – x0 # получение коэффициента B уравнения прямой
solid = getSolid(wall) # получение объёмной геометрии стены
level = currentDoc.GetElement(wall.LevelId) # получение уровня, на котором размещена стена
wallObject = WallObject(wall, width, A, B, solid, level) # создание экземпляра класса WallObject
return wallObject

# Функция создания экземпляра класса Floor
def createFloorObject(floor):
solid = getSolid(floor) # получение объёмной геометрии плиты
level = currentDoc.GetElement(floor.LevelId) # получение уровня, на котором размещена плиты
floorObject = FloorObject(floor, solid, level) # создание экземпляра класса FloorObject
return floorObject

# Функция получения всех, либо только выбранных экземпляров класса в модели
def getInstances(revitClass):
selectIds = List[ElementId]()
if selectElements is not None:
for select in selectElements:
selectIds.Add(select.Id)
instances = FilteredElementCollector(currentDoc, selectIds).OfClass(revitClass).WhereElementIsNotElementType().ToElements()
else:
instances = FilteredElementCollector(currentDoc).OfClass(revitClass).WhereElementIsNotElementType().ToElements()
return instances

# Функция создания проёмов в экземпляре конструкции для коммуникаций конкретного типа
def createOpenings(category, constructionObject):

# Функция создания экземпляра класса Communication
def createCommunication(communication):

# Функция получения размеров сечений коммуникации
def getCommunicationSize():
# Для труб
if category == pipeCategory:
diameter = communication.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER).AsDouble()
width = diameter
height = diameter
# Для воздухововдов
elif category == ductCategory:
try:
diameter = communication.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM).AsDouble()
width = diameter
height = diameter
except:
width = communication.get_Parameter(BuiltInParameter.RBS_CURVE_WIDTH_PARAM).AsDouble()
height = communication.get_Parameter(BuiltInParameter.RBS_CURVE_HEIGHT_PARAM).AsDouble()
# Для коробов
elif category == conduitCategory:
diameter = communication.get_Parameter(BuiltInParameter.RBS_CONDUIT_DIAMETER_PARAM).AsDouble()
width = diameter
height = diameter
# Для кабельных лотков
elif category == cableTrayCategory:
width = communication.get_Parameter(BuiltInParameter.RBS_CABLETRAY_WIDTH_PARAM).AsDouble()
height = communication.get_Parameter(BuiltInParameter.RBS_CABLETRAY_HEIGHT_PARAM).AsDouble()
return width, height
# Функция получения координат начальной и конечной точки линий коммуникации
def getCommunicationLineCoordinates():
curve = communication.Location.Curve # определение кривой эскиза коммуникации
lines = constructionObject.solid.IntersectWithCurve(curve, intersectionOptions) # определение линий пересечения коммуникации и конструкции
try:
line = lines.GetCurveSegment(0) # взятие первой и единственной линии
except:
line = curve # в некоторых случаях берём саму кривую
coordinates = getLineCoordinates(line)
return coordinates

# Функция определения направления коммуникации
def getCommunicationDirection():

# Функция определения нормали к грани воздуховода или лотка для проёмов в плитах
def getFaceNormal():
# Для определения направления берём боковую сторону воздуховода или лотка и находим нормаль к ней
geometry = communication.get_Geometry(options)
for object in geometry:
solid = object
faces = solid.Faces
for face in faces:
_faceNormal = face.FaceNormal
# Проверка того, что берётся именно боковая грань
if _faceNormal.Z == 0:
faceNormal = _faceNormal
return faceNormal

# Для плит направление проёма определяется из геометрии коммуникации
if constructionObject.__class__.__name__ == ‘FloorObject’:
# Для воздуховодов (могут быть как круглые, так и прямоугольные)
if category == ductCategory:
try:
diameter = communication.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM).AsDouble()
direction = XYZ(0, 0, 0)
except:
# В случае прямоугольных или овальных воздухововдов берём нормаль к грани
direction = getFaceNormal()
# Для кабельных лотков (всегда прямоугольные)
elif category == cableTrayCategory:
# В отличие от воздуховода, у кабельного лотка берём не нормаль, а касательную
faceNormal = getFaceNormal()
direction = XYZ(faceNormal.Y, -faceNormal.X, faceNormal.Z)
# Для труб и коробов (всегда круглые)
else:
direction = XYZ(0, 0, 0)
return direction

width, height = getCommunicationSize() # получение ширины и высоты сечения коммуникации
x0, y0, z0, x1, y1, z1 = getCommunicationLineCoordinates() # получение координат линии эскиза коммуникации
A = y0 – y1 # получение коэффициента A уравнения прямой
B = x1 – x0 # получение коэффициента B уравнения прямой
C = z1 – z0 # получение коэффициента C уравнения прямой
direction = getCommunicationDirection() # получения направления коммуникаций (для проёмов в плите)
centerPoint = XYZ((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2) # получение центра пересечения коммуникации и конструкции
# Cоздание экземпляра класса Communication
communicationObject = CommunicationObject(width, height, A, B, C, direction, centerPoint)
return communicationObject

# Функция создания экземпляра проёма
def createOpening(rectangularFamily, roundFamily, minWidth, minHeight, centerPoint, direction):

# Функция создания экземпляра проёма и назначения геометрических параметров
def _createOpening(maxSide, minSide, openingWidth, openingHeight):
# Если значения допустимы для создания круглого проёма, то создание и назначение диаметра
if maxSide / minSide <= maxAspectRatio and maxSide <= maxDiameter:
if constructionObject.__class__.__name__ == ‘WallObject’:
_opening = currentDoc.Create.NewFamilyInstance(centerPoint, roundFamily, constructionObject.instance, constructionObject.level, nonStructural)
else:
_opening = currentDoc.Create.NewFamilyInstance(centerPoint, roundFamily, direction, constructionObject.instance, nonStructural)
_opening.get_Parameter(BuiltInParameter.FAMILY_LEVEL_PARAM).Set(constructionObject.level.Id)
_opening.LookupParameter(diameterParameter).Set(maxSide)
# Если нет, то создание прямоугольного проёма и задание её ширины и высоты
else:
if constructionObject.__class__.__name__ == ‘WallObject’:
_opening = currentDoc.Create.NewFamilyInstance(centerPoint, rectangularFamily, constructionObject.instance, constructionObject.level, nonStructural)
else:
_opening = currentDoc.Create.NewFamilyInstance(centerPoint, rectangularFamily, direction, constructionObject.instance, nonStructural)
_opening.get_Parameter(BuiltInParameter.FAMILY_LEVEL_PARAM).Set(constructionObject.level.Id)
_opening.LookupParameter(widthParameter).Set(openingWidth)
_opening.LookupParameter(heightParameter).Set(openingHeight)
return _opening

# Проверка того, возможно ли создать проём, и создание
if minWidth is not None and minHeight is not None:
# Определение ширины проёма с учётом допуска
if isReservByCoefficient: # если допуск задан коэффициентом
openingWidth = minWidth * reserv
openingHeight = minHeight * reserv
else: # если допуск задан в миллиметрах
openingWidth = minWidth + reserv
openingHeight = minHeight + reserv
# Округление сторон до сантиметров
openingWidth = round(openingWidth * 304.8, -1) / 304.8
openingHeight = round(openingHeight * 304.8, -1) / 304.8
# Создание проёма
if openingHeight > openingWidth:
opening = _createOpening(openingHeight, openingWidth, openingWidth, openingHeight) # случай, если высота больше ширины
else:
opening = _createOpening(openingWidth, openingHeight, openingWidth, openingHeight) # случай, если ширина больше высоты
# Установка других параметров проёма
opening.LookupParameter(disciplineParameter).Set(disciplineName)
opening.LookupParameter(commentParameter).Set(comment)
return opening
# Если проём нельзя создать
else:
message = ‘Коммуникация внутри конструкции’
return message

# Функция создания проёма в стене
def createWallOpening(communicationObject):

# Функция вычисления минимальной стороны проёма в стене
def getMinSide(cosin, communicationSide):
angle = round(math.degrees(math.acos(cosin))) # вычисление угла между коммуникацией и консутркцией из косинуса
if angle > 90:
angle = 180 – angle # определение острого угла при пересечении
angleRad = math.radians(angle) # перевод острого угла в радианы
if angle != 180 and angle != 0:
# Определение минимальной стороны проёма, если коммуникация не проходит вдоль конструкции
minSide = constructionObject.width / math.tan(angleRad) + communicationSide / math.sin(angleRad)
return minSide

# Получение косинуса угла пересечения коммуникации и конструкции в плане для определения минимальной ширины проёма
try:
cosin = (constructionObject.A * communicationObject.A + constructionObject.B * communicationObject.B) / ((constructionObject.A**2 + constructionObject.B**2)**0.5 * (communicationObject.A**2 + communicationObject.B**2)**0.5)
except:
cosin = 1
minWidth = getMinSide(cosin, communicationObject.width)
# Получение угла пересечения коммуникации и конструкции по вертикали (то есть между трубой и горизонтальной плоскостью) для определения минимальной высоты проёма
cosin = communicationObject.C / ((communicationObject.A**2 + communicationObject.B**2 + communicationObject.C**2)**0.5)
minHeight = getMinSide(cosin, communicationObject.height) # определение минимальной высота проёма
rectangularFamily = rectangularFamilyForWall # семейство прямоугольного проёма в стене
roundFamily = roundFamilyForWall # семейство круглого проёма в стене
# Создание проёма
wallOpening = createOpening(rectangularFamily, roundFamily, minWidth, minHeight, communicationObject.centerPoint, None)
return wallOpening

# Функция создания проёма в плите
def createFloorOpening(communicationObject):
minWidth = communicationObject.width # минимальная ширина проёма равна ширине коммуникации
minHeight = communicationObject.height # минимальная высота проёма равна высоте коммуникации
direction = communicationObject.direction # для проёмов в плите направление определяется из направления коммуникации
rectangularFamily = rectangularFamilyForFloor # семейство прямоугольного проёма в плите
roundFamily = roundFamilyForFloor # семейство круглого проёма в плите
# Создание проёма
floorOpening = createOpening(rectangularFamily, roundFamily, minWidth, minHeight, communicationObject.centerPoint, direction)
return floorOpening

# Получение всех, либо только выбранных экземпляров коммуникаций в модели (для каждого экземпляра конструкции берём заново)
communications = FilteredElementCollector(docWithCommunications).OfCategory(category).WhereElementIsNotElementType()
# Извлечение только тех экземпляров коммуникаций, которые пересекаются с геометрией конструкции
intersectingCommunications = communications.WherePasses(ElementIntersectsSolidFilter(constructionObject.solid)).ToElements()
# Формирование списка для созданных проёмов
openings = []
# Обработка полученных экземпляров коммуникаций
for communication in intersectingCommunications:
# Создание экземляра класса Communication
communicationObject = createCommunication(communication)
# Если конструкция является стеной
if constructionObject.__class__.__name__ == ‘WallObject’:
opening = createWallOpening(communicationObject)
# Если конструкция является плитой
else:
opening = createFloorOpening(communicationObject)
openings.append([communication, opening])
return openings

#————————————————————————————————————————-
# ОБРАБОТКА МОДЕЛИ
#————————————————————————————————————————-

# Получение всех экзмепляров стен и плит
walls = getInstances(Wall)
floors = getInstances(Floor)

# Открытие транзакции
TransactionManager.Instance.EnsureInTransaction(currentDoc)

# Обработка стен, если включена
if includeWalls:
# Активация загруженных семейств проёмов (если ещё не были использованы)
rectangularFamilyForWall.Activate()
roundFamilyForWall.Activate()
# Формирование выходного списка и создание проёмов для каждой стены с коммуникациями каждой категории
wallOpenings = []
for wall in walls:
wallObject = createWallObject(wall)
for category in [pipeCategory, ductCategory, conduitCategory, cableTrayCategory]:
openings = createOpenings(category, wallObject)
if openings.Count > 0:
wallOpenings.append(openings)
else:
wallOpenings = ‘Обработка стен отключена’

# Обработка плит, если включена (аналогично)
if includeFloors:
rectangularFamilyForFloor.Activate()
roundFamilyForFloor.Activate()
floorOpenings = []
for floor in floors:
floorObject = createFloorObject(floor)
for category in [pipeCategory, ductCategory, conduitCategory, cableTrayCategory]:
openings = createOpenings(category, floorObject)
if openings.Count > 0:
wallOpenings.append(openings)
else:
floorOpenings = ‘Обработка плит отключена’

# Закрытие транзакции
TransactionManager.Instance.TransactionTaskDone()

#————————————————————————————————————————-
# ВЫХОДНЫЕ ДАННЫЕ
#————————————————————————————————————————-

OUT = wallOpenings, floorOpenings

</p>

моя попытка его адаптировать

<p>
<div>
<div>import clr</div>
<div>import math</div>
<div>from System.Collections.Generic import *</div>
<div>clr.AddReference(‘RevitAPI’)</div>
<div>import Autodesk</div>
<div>from Autodesk.Revit.DB import *</div>
<div># Определение опций Revit API</div>
<div>options = Options()</div>
<div>intersectionOptions = SolidCurveIntersectionOptions()                       # для нахождения пересечения</div>
<div>nonStructural = Autodesk.Revit.DB.Structure.StructuralType.NonStructural    # для вставки семейства в основу</div>
<div># Категории балки</div>
<div>frameCat = BuiltInCategory.OST_StructuralFraming</div>
<div>clr.AddReference(‘RevitServices’)</div>
<div>import RevitServices</div>
<div>from RevitServices.Persistence import DocumentManager</div>
<div>from RevitServices.Transactions import TransactionManager</div>
<div>#————————————————————————————————————————-</div>
<div># ВХОДНЫЕ ДАННЫЕ</div>
<div>#————————————————————————————————————————-</div>
<div># Типоразмеры семейств проёмов</div>
<div>rectangularFamilyForWall = UnwrapElement(IN[0])     # прямоугольной для стен</div>
<div>rectangularFamilyForFloor = UnwrapElement(IN[2])    # прямоугольной для плит</div>
<div># Экземпляры выбранных конструкций (если выбраны)</div>
<div>selectElements = UnwrapElement(IN[4])</div>
<div>try:</div>
<div>    selectElements.Count</div>
<div>except:</div>
<div>    if selectElements is not None:</div>
<div>        selectElements = [UnwrapElement(IN[4])]</div>
<div># Запас сторон для проёмов</div>
<div>isReservByCoefficient = IN[5]   # запас задаётся коэффициентом?</div>
<div>if isReservByCoefficient:</div>
<div>    reserv = IN[6]              # запас для проёма как отношение сторон</div>
<div>else:</div>
<div>    reserv = IN[6] / 304.8      # запас для проёма в мм</div>
<div># Условия формирования круглого, а не прямоугольного, проёма</div>
<div># Работа со связанными файлами</div>
<div>isLinkDocument = IN[9]          # конструкции в связанном файле?</div>
<div>nameLinkDocument = IN[10]       # часть имени связанного файла с конструкциями</div>
<div># Типы обрабатываемых конструкций</div>
<div>includeWalls = IN[11]           # обрабатывть стены?</div>
<div>includeFloors = IN[12]          # обрабатывать перекрытия?</div>
<div># Значения параметров проёмов</div>
<div>comment = IN[13]                # дата или другой комментарий (для версионирования)</div>
<div>disciplineName = IN[14]         # дисциплина проёма</div>
<div># Имена параметров проёмов</div>
<div>disciplineParameter = IN[15]    # параметр дисциплины</div>
<div>diameterParameter = IN[16]      # параметр диаметра</div>
<div>widthParameter = IN[17]         # параметр ширины</div>
<div>heightParameter = IN[18]        # параметр высоты</div>
<div>commentParameter = IN[19]       # параметр комментария</div>
<div>#————————————————————————————————————————-</div>
<div># ПОЛУЧЕНИЕ ДАННЫХ ИЗ ПРОЕКТА</div>
<div>#————————————————————————————————————————-</div>
<div># Получение текущего проекта</div>
<div>currentDoc = DocumentManager.Instance.CurrentDBDocument</div>
<div># Получение списка связанных файлов</div>
<div>linkInstances = FilteredElementCollector(currentDoc).OfClass(RevitLinkInstance)</div>
<div># Определение файла, в котором содержатся конструкции</div>
<div>if isLinkDocument:</div>
<div>    a = 0</div>
<div>    for linkInstance in linkInstances:</div>
<div>        if nameLinkDocument in linkInstance.Name:</div>
<div>            docWithCommunications = linkInstance.GetLinkDocument()</div>
<div>            a = 1</div>
<div>    # Если связанный файл с подходящим именем не найден, то берём текущий файл</div>
<div>    if a == 0:</div>
<div>        docWithCommunications = currentDoc</div>
<div>else:</div>
<div>    docWithCommunications = currentDoc</div>
<div>#————————————————————————————————————————-</div>
<div># СОЗДАНИЕ КЛАССОВ И ФУНКЦИЙ</div>
<div>#————————————————————————————————————————-</div>
<div># Класс стены с нужными свойствами</div>
<div>class WallObject:</div>
<div>    # Инициализация свойств класса</div>
<div>    def __init__(self, instance, width, A, B, solid, level):</div>
<div>        self.instance = instance        # экзмепляр стены в модели</div>
<div>        self.width = width              # толщина стены</div>
<div>        self.A = A                      # коэффициент A уравнения прямой стены</div>
<div>        self.B = B                      # коэффициент B уравнения прямой стены</div>
<div>        self.solid = solid              # объёмная геометрия стены</div>
<div>        self.level = level              # уровень, на котором размещена стена</div>
<div># Класс плиты с нужными свойствами</div>
<div>class FloorObject:</div>
<div>    def __init__(self, instance, solid, level):</div>
<div>        self.instance = instance        # экземпляр плиты в модели</div>
<div>        self.solid = solid              # объёмная геометрия плиты</div>
<div>        self.level = level              # уровень, на котором размещена плита</div>
<div># Класс балки с нужными свойствами</div>
<div>class BalkaObject:</div>
<div>    def __init__(self, length, A, B, C, direction, centerPoint):</div>
<div>        self.length = length            # длина балки</div>
<div>        self.A = A                      # коэффициент A уравнения прямой</div>
<div>        self.B = B                      # коэффициент B уравнения прямой</div>
<div>        self.C = C                      # коэффициент C уравнения прямой</div>
<div>        self.direction = direction      # направление для расположения проёма плиты</div>
<div>        self.centerPoint = centerPoint  # центр пересечения  и конструкции</div>
<div># Функция получения координат начальной и конечной точки линии</div>
<div>def getLineCoordinates(line):</div>
<div>    endPoint0 = line.GetEndPoint(0)                         # получение начальной точки кривой</div>
<div>    endPoint1 = line.GetEndPoint(1)                         # получение конечной точки кривой</div>
<div>    x0 = endPoint0.X; y0 = endPoint0.Y; z0 = endPoint0.Z    # получение координат начальной точки</div>
<div>    x1 = endPoint1.X; y1 = endPoint1.Y; z1 = endPoint1.Z    # получение координат начальной точки</div>
<div>    coordinates = x0, y0, z0, x1, y1, z1</div>
<div>    return coordinates</div>
<div># Функция получения объёмной геометрии конструкции</div>
<div>def getSolid(construction):</div>
<div>    geometry = construction.get_Geometry(options)</div>
<div>    for object in geometry:</div>
<div>        solid = object</div>
<div>    return solid</div>
<div># Функция создания экземпляра класса Wall</div>
<div>def createWallObject(wall):</div>
<div>    width = wall.Width                                                  # получение толщины экземпляра стены</div>
<div>    x0, y0, z0, x1, y1, z1 = getLineCoordinates(wall.Location.Curve)    # получение координат прямой эскиза стены</div>
<div>    A = y0 – y1                                                         # получение коэффициента A уравнения прямой</div>
<div>    B = x1 – x0                                                         # получение коэффициента B уравнения прямой</div>
<div>    solid = getSolid(wall)                                              # получение объёмной геометрии стены</div>
<div>    level = currentDoc.GetElement(wall.LevelId)                 # получение уровня, на котором размещена стена</div>
<div>    wallObject = WallObject(wall, width, A, B, solid, level)            # создание экземпляра класса WallObject</div>
<div>    return wallObject</div>
<div># Функция создания экземпляра класса Floor</div>
<div>def createFloorObject(floor):</div>
<div>    solid = getSolid(floor)                                             # получение объёмной геометрии плиты</div>
<div>    level = currentDoc.GetElement(floor.LevelId)                    # получение уровня, на котором размещена плиты</div>
<div>    floorObject = FloorObject(floor, solid, level)                      # создание экземпляра класса FloorObject</div>
<div>    return floorObject</div>
<div># Функция получения всех, либо только выбранных экземпляров класса в модели</div>
<div>def getInstances(revitClass):</div>
<div>    selectIds = List[ElementId]()</div>
<div>    if selectElements is not None:</div>
<div>        for select in selectElements:</div>
<div>            selectIds.Add(select.Id)</div>
<div>        instances = FilteredElementCollector(currentDoc, selectIds).OfClass(revitClass).WhereElementIsNotElementType().ToElements()</div>
<div>    else:</div>
<div>        instances = FilteredElementCollector(currentDoc).OfClass(revitClass).WhereElementIsNotElementType().ToElements()</div>
<div>    return instances</div>
<div># Функция создания проёмов в экземпляре конструкции для коммуникаций конкретного типа</div>
<div>def createOpenings(category, constructionObject):</div>
<div>    # Функция создания экземпляра класса Communication</div>
<div>    def createCommunication(communication):</div>
<div></div>
<div>        # Функция получения размеров сечений</div>
<div>        def getCommunicationSize():</div>
<div>            # Для балки</div>
<div>            if category == frameCat:</div>
<div>                length = communication.get_Parameter(BuiltInParameter.STRUCTURAL_FRAME_CUT_LENGTH).AsDouble()</div>
<div></div>
<div>            return length</div>
<div></div>
<div># Функция получения координат начальной и конечной точки линий</div>
<div>        def getCommunicationLineCoordinates():</div>
<div>            curve = communication.Location.Curve                                            # определение кривой эскиза</div>
<div>            lines = constructionObject.solid.IntersectWithCurve(curve, intersectionOptions) # определение линий пересечения   и конструкции</div>
<div>            try:</div>
<div>                line = lines.GetCurveSegment(0)                                             # взятие первой и единственной линии</div>
<div>            except:</div>
<div>                line = curve                                                                # в некоторых случаях берём саму кривую</div>
<div>            coordinates = getLineCoordinates(line)</div>
<div>            return coordinates</div>
<div>    # Функция определения направления</div>
<div>        def getCommunicationDirection():</div>
<div></div>
<div>            # Функция определения нормали к грани воздуховода или лотка для проёмов в плитах</div>
<div>            def getFaceNormal():</div>
<div>                # Для определения направления берём боковую сторону воздуховода или лотка и находим нормаль к ней</div>
<div>                geometry = communication.get_Geometry(options)</div>
<div>                for object in geometry:</div>
<div>                    solid = object</div>
<div>                faces = solid.Faces</div>
<div>                for face in faces:</div>
<div>                    _faceNormal = face.FaceNormal</div>
<div>                    # Проверка того, что берётся именно боковая грань</div>
<div>                    if _faceNormal.Z == 0:</div>
<div>                        faceNormal = _faceNormal</div>
<div>                return faceNormal</div>
<div>    # Для плит направление проёма определяется из геометрии</div>
<div>            if constructionObject.__class__.__name__ == ‘FloorObject’:</div>
<div>                # Для балки (только прямоугольные)</div>
<div>                if category == frameCat:</div>
<div>                    try:</div>
<div>                        direction = XYZ(0, 0, 0)</div>
<div>                    except:</div>
<div>                        # В случае прямоугольных или овальных воздухововдов берём нормаль к грани</div>
<div>                        direction = getFaceNormal()</div>
<div>            return direction</div>
<div>        length = getCommunicationSize()                                 # получение длины сечения</div>
<div>        x0 = IN[20][0].X # координата стартовой точки</div>
<div>        y0 = IN[20][0].Y # координата стартовой точки</div>
<div>        z0 = IN[20][0].Z # координата стартовой точки</div>
<div>        x1 = IN[21][0].X # координата конечной точки</div>
<div>        y1 = IN[21][0].Y # координата конечной точки</div>
<div>        z1 = IN[21][0].Z # координата конечной точки                    # получение координат линии эскиза</div>
<div>        A = y0 – y1                                                     # получение коэффициента A уравнения прямой</div>
<div>        B = x1 – x0                                                     # получение коэффициента B уравнения прямой</div>
<div>        C = z1 – z0                                                     # получение коэффициента C уравнения прямой</div>
<div>        direction = getCommunicationDirection()                         # получения направления коммуникаций (для проёмов в плите)</div>
<div>        centerPoint = XYZ((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2)  # получение центра пересечения   и конструкции</div>
<div>        # Cоздание экземпляра класса Communication</div>
<div>        communicationObject = CommunicationObject(width, height, A, B, C, direction, centerPoint)</div>
<div>        return communicationObject</div>
<div>    # Функция создания экземпляра проёма</div>
<div>    def createOpening(rectangularFamily, roundFamily, minWidth, minHeight, centerPoint, direction):</div>
<div></div>
<div>        # Функция создания экземпляра проёма и назначения геометрических параметров</div>
<div>        def _createOpening(maxSide, minSide, openingWidth, openingHeight):</div>
<div></div>
<div>            #создание прямоугольного проёма и задание её ширины и высоты</div>
<div>            if constructionObject.__class__.__name__ == ‘WallObject’:</div>
<div>                _opening = currentDoc.Create.NewFamilyInstance(centerPoint, rectangularFamily, constructionObject.instance, constructionObject.level, nonStructural)</div>
<div>            else:</div>
<div>                _opening = currentDoc.Create.NewFamilyInstance(centerPoint, rectangularFamily, direction, constructionObject.instance, nonStructural)</div>
<div>                _opening.get_Parameter(BuiltInParameter.FAMILY_LEVEL_PARAM).Set(constructionObject.level.Id)</div>
<div>            _opening.LookupParameter(widthParameter).Set(openingWidth)</div>
<div>            _opening.LookupParameter(heightParameter).Set(openingHeight)</div>
<div>            return _opening</div>
<div>        # Проверка того, возможно ли создать проём, и создание</div>
<div>        if minWidth is not None and minHeight is not None:</div>
<div>            # Определение ширины проёма с учётом допуска</div>
<div>            if isReservByCoefficient:                                   # если допуск задан коэффициентом</div>
<div>                openingWidth = minWidth * reserv</div>
<div>                openingHeight = minHeight * reserv</div>
<div>            else:                                                       # если допуск задан в миллиметрах</div>
<div>                openingWidth = minWidth + reserv</div>
<div>                openingHeight = minHeight + reserv</div>
<div>            # Округление сторон до сантиметров</div>
<div>            openingWidth = round(openingWidth * 304.8, -1) / 304.8</div>
<div>            openingHeight = round(openingHeight * 304.8, -1) / 304.8</div>
<div>            # Создание проёма</div>
<div>            if openingHeight > openingWidth:</div>
<div>                opening = _createOpening(openingHeight, openingWidth, openingWidth, openingHeight)  # случай, если высота больше ширины</div>
<div>            else:</div>
<div>                opening = _createOpening(openingWidth, openingHeight, openingWidth, openingHeight)  # случай, если ширина больше высоты</div>
<div>            # Установка других параметров проёма</div>
<div>            opening.LookupParameter(disciplineParameter).Set(disciplineName)</div>
<div>            opening.LookupParameter(commentParameter).Set(comment)</div>
<div>            return opening</div>
<div>        # Если проём нельзя создать</div>
<div>        else:</div>
<div>            message = ‘Балка внутри конструкции'</div>
<div>            return message</div>
<div># Функция создания проёма в стене</div>
<div>    def createWallOpening(communicationObject):</div>
<div></div>
<div>        # Функция вычисления минимальной стороны проёма в стене</div>
<div>        def getMinSide(cosin, communicationSide):</div>
<div>            angle = round(math.degrees(math.acos(cosin)))   # вычисление угла между коммуникацией и консутркцией из косинуса</div>
<div>            if angle > 90:</div>
<div>                angle = 180 – angle                         # определение острого угла при пересечении</div>
<div>            angleRad = math.radians(angle)                  # перевод острого угла в радианы</div>
<div>            if angle != 180 and angle != 0:</div>
<div>                # Определение минимальной стороны проёма, если коммуникация не проходит вдоль конструкции</div>
<div>                minSide = constructionObject.width / math.tan(angleRad) + communicationSide / math.sin(angleRad)</div>
<div>                return minSide</div>
<div>        # Получение косинуса угла пересечения   и конструкции в плане для определения минимальной ширины проёма</div>
<div>        try:</div>
<div>            cosin = (constructionObject.A * communicationObject.A + constructionObject.B * communicationObject.B) / ((constructionObject.A**2 + constructionObject.B**2)**0.5 * (communicationObject.A**2 + communicationObject.B**2)**0.5)</div>
<div>        except:</div>
<div>            cosin = 1</div>
<div>        minWidth = getMinSide(cosin, communicationObject.width)</div>
<div>        # Получение угла пересечения   и конструкции по вертикали (то есть между трубой и горизонтальной плоскостью) для определения минимальной высоты проёма</div>
<div>        cosin = communicationObject.C / ((communicationObject.A**2 + communicationObject.B**2 + communicationObject.C**2)**0.5)</div>
<div>        minHeight = getMinSide(cosin, communicationObject.height)   # определение минимальной высота проёма</div>
<div>        rectangularFamily = rectangularFamilyForWall                # семейство прямоугольного проёма в стене</div>
<div></div>
<div>        # Создание проёма</div>
<div>        wallOpening = createOpening(rectangularFamily, roundFamily, minWidth, minHeight, communicationObject.centerPoint, None)</div>
<div>        return wallOpening</div>
<div># Функция создания проёма в плите</div>
<div>    def createFloorOpening(communicationObject):</div>
<div>        minWidth = communicationObject.length / (communicationObject.length / 4)            # минимальная ширина проёма равна ширине</div>
<div>        minHeight = communicationObject.length / (communicationObject.length / 3)           # минимальная высота проёма равна высоте</div>
<div>        direction = communicationObject.direction       # для проёмов в плите направление определяется из направления</div>
<div>        rectangularFamily = rectangularFamilyForFloor   # семейство прямоугольного проёма в плите</div>
<div></div>
<div>        # Создание проёма</div>
<div>        floorOpening = createOpening(rectangularFamily, roundFamily, minWidth, minHeight, communicationObject.centerPoint, direction)</div>
<div>        return floorOpening</div>
<div># Получение всех, либо только выбранных экземпляров коммуникаций в модели (для каждого экземпляра конструкции берём заново)</div>
<div>    communications = FilteredElementCollector(docWithCommunications).OfCategory(category).WhereElementIsNotElementType()</div>
<div>    # Извлечение только тех экземпляров коммуникаций, которые пересекаются с геометрией конструкции</div>
<div>    intersectingCommunications = communications.WherePasses(ElementIntersectsSolidFilter(constructionObject.solid)).ToElements()</div>
<div>    # Формирование списка для созданных проёмов</div>
<div>    openings = []</div>
<div>    # Обработка полученных экземпляров коммуникаций</div>
<div>    for communication in intersectingCommunications:</div>
<div>        # Создание экземляра класса Communication</div>
<div>        communicationObject = createCommunication(communication)</div>
<div>        # Если конструкция является стеной</div>
<div>        if constructionObject.__class__.__name__ == ‘WallObject’:</div>
<div>            opening = createWallOpening(communicationObject)</div>
<div>        # Если конструкция является плитой</div>
<div>        else:</div>
<div>            opening = createFloorOpening(communicationObject)</div>
<div>        openings.append([communication, opening])</div>
<div>    return openings</div>
<div>#————————————————————————————————————————-</div>
<div># ОБРАБОТКА МОДЕЛИ</div>
<div>#————————————————————————————————————————-</div>
<div># Получение всех экзмепляров стен и плит</div>
<div>walls = getInstances(Wall)</div>
<div>floors = getInstances(Floor)</div>
<div># Открытие транзакции</div>
<div>TransactionManager.Instance.EnsureInTransaction(currentDoc)</div>
<div># Обработка стен, если включена</div>
<div>if includeWalls:</div>
<div>    # Активация загруженных семейств проёмов (если ещё не были использованы)</div>
<div>    rectangularFamilyForWall.Activate()</div>
<div>    # Формирование выходного списка и создание проёмов для каждой стены с коммуникациями каждой категории</div>
<div>    wallOpenings = []</div>
<div>    for wall in walls:</div>
<div>        wallObject = createWallObject(wall)</div>
<div>        for category in [frameCat]:</div>
<div>            openings = createOpenings(category, wallObject)</div>
<div>            if openings.Count > 0:</div>
<div>                wallOpenings.append(openings)</div>
<div>else:</div>
<div>    wallOpenings = ‘Обработка стен отключена'</div>
<div># Обработка плит, если включена (аналогично)</div>
<div>if includeFloors:</div>
<div>    rectangularFamilyForFloor.Activate()</div>
<div></div>
<div>    floorOpenings = []</div>
<div>    for floor in floors:</div>
<div>        floorObject = createFloorObject(floor)</div>
<div>        for category in [frameCat]:</div>
<div>            openings = createOpenings(category, floorObject)</div>
<div>            if openings.Count > 0:</div>
<div>                wallOpenings.append(openings)</div>
<div>else:</div>
<div>    floorOpenings = ‘Обработка плит отключена'</div>
<div># Закрытие транзакции</div>
<div>TransactionManager.Instance.TransactionTaskDone()</div>
<div># Назначьте вывод переменной OUT.</div>
<div>OUT = wallOpenings, floorOpenings</div>
</div>
</p>

[ILYAKOREPANOFF]

потому что требует на вход для создания новой группы NewGroup типизированный список. Чтобы импортировать класс типизированного списка, необходимо добавить следующую строчку кода: “from System.Collections.Generic import List”. Для создания типизированного списка указываем имя типа List, в квадратных скобках обозначается тип объектов данного списка (в вашем случае ElementId), далее в круглых скобках указывается аргумент, например, список или кортеж, который будет превращен в типизированный список. “List[ElementId](ваш список с id элементов)”

[Nurik]

Добрый день

Нашел в просторах интернета скрипт python.

import clr

# Import RevitAPI
clr.AddReference(“RevitAPI”)
import Autodesk
from Autodesk.Revit.DB import *

# Import DocumentManager and TransactionManager
clr.AddReference(“RevitServices”)
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

#The inputs to this node will be stored as a list in the IN variable.
doc =  DocumentManager.Instance.CurrentDBDocument
app =  DocumentManager.Instance.CurrentUIApplication.Application

dataEnteringNode = IN
elementId = IN[0].Id

TransactionManager.Instance.EnsureInTransaction(doc)
ElementTransformUtils.MoveElement(doc,ElementId(elementId),XYZ(IN[1],IN[2],IN[3]))
TransactionManager.Instance.TransactionTaskDone()

# Assign your output to the OUT variable.
OUT = 0

Данный скрипт чудесно работает если в IN[0] подавать один элемент.

Как сделать так, чтобы работало при подаче во вход нескольких элементов?

 

 

[Аноним]

[Аноним]

У меня в результате получается всего 40 списков, а я хотел, чтобы было списка 21,  какую функцию добавить или Python , чтобы выполнили векторное переплетение по каждым листам, а не все?

[ИваСерж]

Похоже на говно-код.
Почему бы не использовать словарь вместо целой обоймы elif?
Тот же код, но в несколько строк.

test_list = [15, 250 , 20, 100]
# create dictionary, pipe_diameter: pipe_index
index_dict = {15: 1, 20: 2, 25:3, 50:6, 250: 13,}
# index_list generator. For stable run i converts to inteter with int()
index_list = [index_dict.get(int(i)) for i in test_list]

OUT = index_list

Проблема с типизацией может возникать. Возможно, это баг. Сложно сказать.
Для уверенности я перевожу в цикле диаметр в инт.
Итак: для улучшени кода вместо if я использовал словарь, а вместо цикла – генератор.
Из-за этого улучшилась расширяемость – в словарь можно удобно добавлять новые индексы.
Значительно улучшилась читаемость.

[Yrij]

Приветствую всех начинающих и гуру!

У меня возник “затык” (не могу найти решение). Вот и обращаюсь за помощью.

Есть скрипт который отрисовывает curve на чертежном виде (это у меня получилось с помощью честно подсмотреного)))

TransactionManager.Instance.EnsureInTransaction(doc)

for curve in curves:
detcurve = doc.Create.NewDetailCurve(view, curve.ToRevitType())
elementlist.append(detcurve)
TransactionManager.Instance.TransactionTaskDone()

OUT = elementlist

И собственно сам вопрос:

Как назначить тип линии до того как она будет отрисована на виде?

Если можно использовать   newLineStyleCat.SetLineWeight( weight, GraphicsStyleType.Projection ), то у меня не получается(

Заранее благодарен всем откликнувшимся.

[Виталий]

import clr
clr.AddReference(‘ProtoGeometry’)
from Autodesk.DesignScript.Geometry import *

# Import DocumentManager and TransactionManager
clr.AddReference(“RevitServices”)
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

# Import RevitAPI
clr.AddReference(“RevitAPI”)
import Autodesk
from Autodesk.Revit.DB import *

doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application

from System.Collections.Generic import *

# Import ToDSType(bool) extension method
clr.AddReference(“RevitNodes”)
import Revit
clr.ImportExtensions(Revit.Elements)

#The inputs to this node will be stored as a list in the IN variable.
def dsColorToRvtColor(dsColor):
R = dsColor.Red
G = dsColor.Green
B = dsColor.Blue
return Autodesk.Revit.DB.Color(R,G,B)
keySchedule = UnwrapElement(IN[0])

#”Start” the transaction
TransactionManager.Instance.EnsureInTransaction(doc)
a=[]
b=[]
c=[]
tableData = keySchedule.GetTableData()

tsd = tableData.GetSectionData(SectionType.Body)

options=TableCellStyleOverrideOptions()
options.BackgroundColor=True
tcs=TableCellStyle()
b.append(dir(tcs))
c.append(dir(options))
tcs.SetCellStyleOverrideOptions(options)
tcs.BackgroundColor=dsColorToRvtColor( IN[2])
tsd.SetCellStyle(0,0, tcs)
TransactionManager.Instance.TransactionTaskDone()
OUT = a,b,c

 

Используя SetCellStyleOverrideOptions, у меня получилось поменять цвет шапки и название столбцов

SetCellStyle не позволяет поменять цвет ячейки тела таблицы ругается “Only allow to override cell style for header section or column header in body section.”

Как разрешить переопределение стиля ячейки?

Как делать с помощью SetStyle, тоже не особо понял

[Aminka13]

Есть семейство – типовая модель, размещение – по рабочей плоскости. Хотела приложить к теме, но что-то не разобралась, как.

Хочу написать скрипт, который бы позволял прикреплять экземпляры этого семейства на опорную плоскость. Поскольку нельзя поменять плоскость у уже имеющегося семейства, иду путем копирования параметров экземпляра, создания нового семейства и удаления исходного. Написала некий скрипт, который хорошо работает с семействами, изначально созданными по грани. Но для семейства на основе типовой модели с размещением по рабочей плоскости скрипт чудит – новые семейства оказываются с host по опорной плоскости, но location point выдает упорно (0,0,0). Если после того, как скрипт завершен, использовать “нарисованные” скриптом семейства в качестве основы для новых – location нормально ловится. Почему так происходит? где ошибка?

Текст скрипта:

import clr, System
clr.AddReference(“RevitNodes”)
import Revit
clr.ImportExtensions(Revit.Elements)
clr.ImportExtensions(Revit.GeometryConversion)

clr.AddReference(‘RevitAPI’)
from Autodesk.Revit.DB import *

clr.AddReference(“RevitServices”)
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument

clr.AddReference(‘ProtoGeometry’)
from Autodesk.DesignScript.Geometry import *

#Введенные в этом узле данные сохраняется в виде списка в переменных IN.
dataEnteringNode = IN

Rplane = IN[0]
ElList = IN[1]

newFamList = []
ParList = []
ParList2D = []

doc = DocumentManager.Instance.CurrentDBDocument
view = doc.ActiveView

TransactionManager.Instance.EnsureInTransaction(doc)

Z = UnwrapElement(Rplane).GetPlane().Origin[2]#Получили плоскость и ее исходную точку-список, и из нее Z координату
for el in ElList :
if UnwrapElement(el).CanFlipWorkPlane :

#сначала рисуем новый экземпляр семейства
FamTyp = UnwrapElement(el).Symbol#Получаем семейство
dir = Vector.ByCoordinates(1,0,0)#Получаем вектор
famPt = UnwrapElement(el).Location.Point#Получаем точку вставки исходного семейства как .DB.locationpoint и берем ее свойство point
pt = Point.ByCoordinates(304.8*famPt[0],304.8*famPt[1],304.8*Z)#Получаем новую точку вставки на высоте опорной плоскости в мм
sttyp = UnwrapElement(el).StructuralType
newFam = doc.Create.NewFamilyInstance(UnwrapElement(Rplane).GetReference(), pt.ToXyz(), dir.ToRevitType(), FamTyp)#Нарисовали новое семейство

<span style=”text-decoration: underline;”> #ПРОВЕРЯЕМ, ЧТО У СЕМЕЙСТВА В ЛОКЕЙШЕНЕ – И ВИДИМ, ЧТО ТАМ НУЛИ-это видно на узле element.getlocation, zzz-просто проверочная переменная      </span>
<span style=”text-decoration: underline;”> #       zzz=UnwrapElement(newFam).Location.Point</span>

#потом копируем все параметры в новый список с параметрами
ParSet = UnwrapElement(el).Parameters #Получили список параметров как объектов db-objects
for ps in ParSet:
pn = ps.Definition.Name #Получаем имя параметра
if isinstance(ps.AsValueString(), str) :  #выясняем, есть ли значиение AsValueString в виде стринг (не нон-тайп)
pval = ps.AsValueString()
else:
pval = “”
ParList.append(pn +” : ” + pval)#Получаем список имен и значений параметров аналогичный ноду element.parameters
ParList2D.append([pn,pval])#Получаем список имен и значений параметров в виде списка с вложенным списком

#теперь передаем параметры из исходного экземпляра в новое
NewParSet = UnwrapElement(newFam).Parameters #Получили список параметров как объектов db-objects
for ps in NewParSet :
pn = ps.Definition.Name #Получаем имя параметра нового семейства
if not ps.IsReadOnly : #проверяем, не является ли он параметром только для чтения
for par in ParList2D:
if par[0] == pn :
pval = par[1]
newFam.LookupParameter(pn).Set(pval);

newFamList.append(newFam)

#удалим старое семейство
for el in ElList :
if UnwrapElement(el).CanFlipWorkPlane :
doc.Delete(UnwrapElement(el).Id)

TransactionManager.Instance.TransactionTaskDone()

OUT=newFamList

 

 

 

 

 

[durasov_artyom]

Добрый день!

Вероятнее всего, вам необходимо назначение пикетов в 3D-солиды Civil 3D

Рекомендую познакомиться со статьей
<h5 class=””>Frederic Classon, Technical Sales Specialist AEC at Autodesk AEC BAR</h5>
<h1 id=”caas-title” class=”caas__title caas-content-result-mt”>Dynamo 4 Civil 3D: Segmentation of Corridor Solids from a Station List</h1>

[Андрей]

l

Здесь список “list_Centerline” является вложенным в список “list”. Если я правильно понял вопрос – про вложенные списки. Просто один список, добавляем в другой список. В приведенном мной примере обратите внимание на отступы

[ИваСерж]

Dynamo KhM #12. Доступ к примитивам Autocad

Для начала можно посмотреть видео Хасана.
Не помню, было ли этого мне достаточно, но у меня получилось получать доступ и к примитивам, и к блокам и т.п.