e6ec691ac1
* BIM: Use checkbox in model tree for Activation/Deactivation of WP * BIM: Set active object after deactivating current object if it exists Currently we can get into a scenario where user can activate two working planes, one after another. For example, Level, and then Level001. If they activate both, and then deactivate Level001, working plane switches back to Level. But, we didn't set the object as the active one, so user didn't have clear information that they can deactivate it, only the working plane was switching it. So this patch sets the object as the active one, if it exists. * BIM: Add support for deactivation active object to BIM Views Tree As the title says - it adds the checkbox that's similarly done in Part workbench, so user can select/deselect the item and if they had previous active object, it will also fall back to the previous object. Also, moved out part of the common logic from ArchBuildingPart and BimViews to utils. * BIM: Handle correct context on activating WP for NativeIFC/BIM * BIM: Remove redundant logic from BIM Views upon double click As all of the logic is being handled now in `activate` function in BimViews, this logic is redundant * BIM: Rename button for taskbar and BIM Views from Activate to Active
1009 lines
44 KiB
Python
1009 lines
44 KiB
Python
# SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
# ***************************************************************************
|
|
# * *
|
|
# * Copyright (c) 2018 Yorik van Havre <yorik@uncreated.net> *
|
|
# * *
|
|
# * This file is part of FreeCAD. *
|
|
# * *
|
|
# * FreeCAD is free software: you can redistribute it and/or modify it *
|
|
# * under the terms of the GNU Lesser General Public License as *
|
|
# * published by the Free Software Foundation, either version 2.1 of the *
|
|
# * License, or (at your option) any later version. *
|
|
# * *
|
|
# * FreeCAD is distributed in the hope that it will be useful, but *
|
|
# * WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
|
|
# * Lesser General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Lesser General Public *
|
|
# * License along with FreeCAD. If not, see *
|
|
# * <https://www.gnu.org/licenses/>. *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
__title__ = "FreeCAD Arch BuildingPart"
|
|
__author__ = "Yorik van Havre"
|
|
__url__ = "https://www.freecad.org"
|
|
|
|
## @package ArchBuildingPart
|
|
# \ingroup ARCH
|
|
# \brief The BuildingPart object and tools
|
|
#
|
|
# This module provides tools to build BuildingPart objects.
|
|
# BuildingParts are used to group different Arch objects
|
|
|
|
import os
|
|
import tempfile
|
|
|
|
import FreeCAD
|
|
import Arch
|
|
import ArchCommands
|
|
import ArchIFC
|
|
import Draft
|
|
import DraftVecUtils
|
|
|
|
from draftutils import params
|
|
|
|
if FreeCAD.GuiUp:
|
|
from PySide.QtCore import QT_TRANSLATE_NOOP
|
|
import FreeCADGui
|
|
from draftutils.translate import translate
|
|
import draftutils.units as units
|
|
else:
|
|
# \cond
|
|
def translate(ctxt,txt):
|
|
return txt
|
|
def QT_TRANSLATE_NOOP(ctxt,txt):
|
|
return txt
|
|
# \endcond
|
|
unicode = str
|
|
|
|
|
|
BuildingTypes = ['Undefined',
|
|
'Agricultural - Barn',
|
|
'Agricultural - Chicken coop or chickenhouse',
|
|
'Agricultural - Cow-shed',
|
|
'Agricultural - Farmhouse',
|
|
'Agricultural - Granary',
|
|
'Agricultural - Greenhouse',
|
|
'Agricultural - Hayloft',
|
|
'Agricultural - Pigpen or sty',
|
|
'Agricultural - Root cellar',
|
|
'Agricultural - Shed',
|
|
'Agricultural - Silo',
|
|
'Agricultural - Stable',
|
|
'Agricultural - Storm cellar',
|
|
'Agricultural - Well house',
|
|
'Agricultural - Underground pit',
|
|
|
|
'Commercial - Automobile repair shop',
|
|
'Commercial - Bank',
|
|
'Commercial - Car wash',
|
|
'Commercial - Convention center',
|
|
'Commercial - Forum',
|
|
'Commercial - Gas station',
|
|
'Commercial - Hotel',
|
|
'Commercial - Market',
|
|
'Commercial - Market house',
|
|
'Commercial - Skyscraper',
|
|
'Commercial - Shop',
|
|
'Commercial - Shopping mall',
|
|
'Commercial - Supermarket',
|
|
'Commercial - Warehouse',
|
|
'Commercial - Restaurant',
|
|
|
|
'Residential - Apartment block',
|
|
'Residential - Asylum',
|
|
'Residential - Condominium',
|
|
'Residential - Dormitory',
|
|
'Residential - Duplex',
|
|
'Residential - House',
|
|
'Residential - Nursing home',
|
|
'Residential - Townhouse',
|
|
'Residential - Villa',
|
|
'Residential - Bungalow',
|
|
|
|
'Educational - Archive',
|
|
'Educational - College classroom building',
|
|
'Educational - College gymnasium',
|
|
'Educational - College students union',
|
|
'Educational - School',
|
|
'Educational - Library',
|
|
'Educational - Museum',
|
|
'Educational - Art gallery',
|
|
'Educational - Theater',
|
|
'Educational - Amphitheater',
|
|
'Educational - Concert hall',
|
|
'Educational - Cinema',
|
|
'Educational - Opera house',
|
|
'Educational - Boarding school',
|
|
|
|
'Government - Capitol',
|
|
'Government - City hall',
|
|
'Government - Consulate',
|
|
'Government - Courthouse',
|
|
'Government - Embassy',
|
|
'Government - Fire station',
|
|
'Government - Meeting house',
|
|
'Government - Moot hall',
|
|
'Government - Palace',
|
|
'Government - Parliament',
|
|
'Government - Police station',
|
|
'Government - Post office',
|
|
'Government - Prison',
|
|
|
|
'Industrial - Brewery',
|
|
'Industrial - Factory',
|
|
'Industrial - Foundry',
|
|
'Industrial - Power plant',
|
|
'Industrial - Mill',
|
|
|
|
'Military - Arsenal',
|
|
'Military -Barracks',
|
|
|
|
'Parking - Boathouse',
|
|
'Parking - Garage',
|
|
'Parking - Hangar',
|
|
|
|
'Storage - Silo',
|
|
'Storage - Hangar',
|
|
|
|
'Religious - Church',
|
|
'Religious - Basilica',
|
|
'Religious - Cathedral',
|
|
'Religious - Chapel',
|
|
'Religious - Oratory',
|
|
'Religious - Martyrium',
|
|
'Religious - Mosque',
|
|
'Religious - Mihrab',
|
|
'Religious - Surau',
|
|
'Religious - Imambargah',
|
|
'Religious - Monastery',
|
|
'Religious - Mithraeum',
|
|
'Religious - Fire temple',
|
|
'Religious - Shrine',
|
|
'Religious - Synagogue',
|
|
'Religious - Temple',
|
|
'Religious - Pagoda',
|
|
'Religious - Gurdwara',
|
|
'Religious - Hindu temple',
|
|
|
|
'Transport - Airport terminal',
|
|
'Transport - Bus station',
|
|
'Transport - Metro station',
|
|
'Transport - Taxi station',
|
|
'Transport - Railway station',
|
|
'Transport - Signal box',
|
|
'Transport - Lighthouse',
|
|
|
|
'Infrastructure - Data centre',
|
|
|
|
'Power station - Fossil-fuel power station',
|
|
'Power station - Nuclear power plant',
|
|
'Power station - Geothermal power',
|
|
'Power station - Biomass-fuelled power plant',
|
|
'Power station - Waste heat power plant',
|
|
'Power station - Renewable energy power station',
|
|
'Power station - Atomic energy plant',
|
|
|
|
'Other - Apartment',
|
|
'Other - Clinic',
|
|
'Other - Community hall',
|
|
'Other - Eatery',
|
|
'Other - Folly',
|
|
'Other - Food court',
|
|
'Other - Hospice',
|
|
'Other - Hospital',
|
|
'Other - Hut',
|
|
'Other - Bathhouse',
|
|
'Other - Workshop',
|
|
'Other - World trade centre'
|
|
]
|
|
|
|
|
|
class BuildingPart(ArchIFC.IfcProduct):
|
|
|
|
|
|
"The BuildingPart object"
|
|
|
|
def __init__(self,obj):
|
|
|
|
obj.Proxy = self
|
|
obj.addExtension('App::GroupExtensionPython')
|
|
#obj.addExtension('App::OriginGroupExtensionPython')
|
|
self.setProperties(obj)
|
|
|
|
def setProperties(self,obj):
|
|
ArchIFC.IfcProduct.setProperties(self, obj)
|
|
|
|
pl = obj.PropertiesList
|
|
if not "Height" in pl:
|
|
obj.addProperty("App::PropertyLength","Height","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The height of this object"), locked=True)
|
|
if not "HeightPropagate" in pl:
|
|
obj.addProperty("App::PropertyBool","HeightPropagate","Children",QT_TRANSLATE_NOOP("App::Property","If true, the height value propagates to contained objects if the height of those objects is set to 0"), locked=True)
|
|
obj.HeightPropagate = True
|
|
if not "LevelOffset" in pl:
|
|
obj.addProperty("App::PropertyDistance","LevelOffset","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The level of the (0,0,0) point of this level"), locked=True)
|
|
if not "Area" in pl:
|
|
obj.addProperty("App::PropertyArea","Area", "BuildingPart",QT_TRANSLATE_NOOP("App::Property","The computed floor area of this floor"), locked=True)
|
|
if not "Description" in pl:
|
|
obj.addProperty("App::PropertyString","Description","Component",QT_TRANSLATE_NOOP("App::Property","An optional description for this component"), locked=True)
|
|
if not "Tag" in pl:
|
|
obj.addProperty("App::PropertyString","Tag","Component",QT_TRANSLATE_NOOP("App::Property","An optional tag for this component"), locked=True)
|
|
if not "Shape" in pl:
|
|
obj.addProperty("Part::PropertyPartShape","Shape","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The shape of this object"), locked=True)
|
|
if not "SavedInventor" in pl:
|
|
obj.addProperty("App::PropertyFileIncluded","SavedInventor","BuildingPart",QT_TRANSLATE_NOOP("App::Property","This property stores an OpenInventor representation for this object"), locked=True)
|
|
obj.setEditorMode("SavedInventor",2)
|
|
if not "OnlySolids" in pl:
|
|
obj.addProperty("App::PropertyBool","OnlySolids","BuildingPart",QT_TRANSLATE_NOOP("App::Property","If true, only solids will be collected by this object when referenced from other files"), locked=True)
|
|
obj.OnlySolids = True
|
|
if not "MaterialsTable" in pl:
|
|
obj.addProperty("App::PropertyMap","MaterialsTable","BuildingPart",QT_TRANSLATE_NOOP("App::Property","A MaterialName:SolidIndexesList map that relates material names with solid indexes to be used when referencing this object from other files"), locked=True)
|
|
|
|
self.Type = "BuildingPart"
|
|
|
|
def onDocumentRestored(self,obj):
|
|
|
|
self.setProperties(obj)
|
|
|
|
def dumps(self):
|
|
|
|
return None
|
|
|
|
def loads(self,state):
|
|
|
|
return None
|
|
|
|
def onBeforeChange(self,obj,prop):
|
|
|
|
if prop == "Placement":
|
|
self.oldPlacement = FreeCAD.Placement(obj.Placement)
|
|
|
|
def onChanged(self,obj,prop):
|
|
|
|
import math
|
|
|
|
ArchIFC.IfcProduct.onChanged(self, obj, prop)
|
|
|
|
# clean svg cache if needed
|
|
if prop in ["Placement","Group"]:
|
|
self.svgcache = None
|
|
self.shapecache = None
|
|
|
|
if (prop == "Height" or prop == "HeightPropagate") and obj.Height.Value:
|
|
self.touchChildren(obj)
|
|
|
|
elif prop == "Placement":
|
|
if hasattr(self,"oldPlacement") and self.oldPlacement != obj.Placement:
|
|
deltap = obj.Placement.Base.sub(self.oldPlacement.Base)
|
|
if deltap.Length == 0:
|
|
deltap = None
|
|
deltar = obj.Placement.Rotation * self.oldPlacement.Rotation.inverted()
|
|
if deltar.Angle < 0.0001:
|
|
deltar = None
|
|
for child in self.getMovableChildren(obj):
|
|
if deltar:
|
|
child.Placement.rotate(self.oldPlacement.Base,
|
|
deltar.Axis,
|
|
math.degrees(deltar.Angle),
|
|
comp=True)
|
|
if deltap:
|
|
child.Placement.move(deltap)
|
|
|
|
def execute(self,obj):
|
|
|
|
"gather all the child shapes into a compound"
|
|
|
|
pl = obj.Placement
|
|
shapes,materialstable = self.getShapes(obj)
|
|
if shapes:
|
|
import Part
|
|
if obj.OnlySolids:
|
|
f = []
|
|
for s in shapes:
|
|
f.extend(s.Solids)
|
|
#print("faces before compound:",len(f))
|
|
obj.Shape = Part.makeCompound(f)
|
|
#print("faces after compound:",len(obj.Shape.Faces))
|
|
#print("recomputing ",obj.Label)
|
|
else:
|
|
obj.Shape = Part.makeCompound(shapes)
|
|
obj.Placement = pl
|
|
obj.Area = self.getArea(obj)
|
|
obj.MaterialsTable = materialstable
|
|
if obj.ViewObject:
|
|
# update the autogroup box if needed
|
|
obj.ViewObject.Proxy.onChanged(obj.ViewObject,"AutoGroupBox")
|
|
|
|
def getMovableChildren(self, obj):
|
|
|
|
"recursively get movable children"
|
|
|
|
result = []
|
|
for child in obj.Group:
|
|
if child.isDerivedFrom("App::DocumentObjectGroup"):
|
|
result.extend(self.getMovableChildren(child))
|
|
if not hasattr(child,"MoveWithHost") or child.MoveWithHost:
|
|
if hasattr(child,"Placement"):
|
|
result.append(child)
|
|
return result
|
|
|
|
def getArea(self,obj):
|
|
|
|
"computes the area of this floor by adding its inner spaces"
|
|
|
|
area = 0
|
|
if hasattr(obj,"Group"):
|
|
for child in obj.Group:
|
|
if (Draft.get_type(child) in ["Space","BuildingPart"]) and hasattr(child,"IfcType"):
|
|
area += child.Area.Value
|
|
return area
|
|
|
|
def getShapes(self,obj):
|
|
|
|
"recursively get the shapes of objects inside this BuildingPart"
|
|
|
|
shapes = []
|
|
solidindex = 0
|
|
materialstable = {}
|
|
for child in Draft.get_group_contents(obj, walls=True):
|
|
if not Draft.get_type(child) in ["Space"]:
|
|
if hasattr(child,'Shape') and child.Shape:
|
|
shapes.append(child.Shape)
|
|
for solid in child.Shape.Solids:
|
|
matname = "Undefined"
|
|
if hasattr(child,"Material") and child.Material:
|
|
matname = child.Material.Name
|
|
if matname in materialstable:
|
|
materialstable[matname] = materialstable[matname]+","+str(solidindex)
|
|
else:
|
|
materialstable[matname] = str(solidindex)
|
|
solidindex += 1
|
|
return shapes,materialstable
|
|
|
|
def getSpaces(self,obj):
|
|
|
|
"gets the list of Spaces that have this object as their Zone property"
|
|
|
|
g = []
|
|
for o in obj.OutList:
|
|
if hasattr(o,"Zone"):
|
|
if o.Zone == obj:
|
|
g.append(o)
|
|
return g
|
|
|
|
def touchChildren(self,obj):
|
|
|
|
"Touches all descendents where applicable"
|
|
|
|
g = []
|
|
if hasattr(obj,"Group"):
|
|
g = obj.Group
|
|
elif (Draft.getType(obj) in ["Wall","Structure"]):
|
|
g = obj.Additions
|
|
for child in g:
|
|
if Draft.getType(child) in ["Wall","Structure"]:
|
|
if not child.Height.Value:
|
|
FreeCAD.Console.PrintLog("Auto-updating Height of "+child.Name+"\n")
|
|
self.touchChildren(child)
|
|
child.Proxy.execute(child)
|
|
elif Draft.getType(child) in ["App::DocumentObjectGroup","Group","BuildingPart"]:
|
|
self.touchChildren(child)
|
|
|
|
|
|
def addObject(self,obj,child):
|
|
|
|
"Adds an object to the group of this BuildingPart"
|
|
|
|
if not child in obj.Group:
|
|
g = obj.Group
|
|
g.append(child)
|
|
obj.Group = g
|
|
|
|
def autogroup(self,obj,child):
|
|
|
|
"Adds an object to the group of this BuildingPart automatically"
|
|
|
|
if obj.ViewObject:
|
|
if hasattr(obj.ViewObject.Proxy,"autobbox") and obj.ViewObject.Proxy.autobbox:
|
|
if hasattr(child,"Shape") and child.Shape:
|
|
abb = obj.ViewObject.Proxy.autobbox
|
|
cbb = child.Shape.BoundBox
|
|
if abb.isValid():
|
|
if not cbb.isValid():
|
|
FreeCAD.ActiveDocument.recompute()
|
|
if not cbb.isValid():
|
|
cbb = FreeCAD.BoundBox()
|
|
for v in child.Shape.Vertexes:
|
|
print(v.Point)
|
|
cbb.add(v.Point)
|
|
if cbb.isValid() and abb.isInside(cbb):
|
|
self.addObject(obj,child)
|
|
return True
|
|
return False
|
|
|
|
|
|
class ViewProviderBuildingPart:
|
|
|
|
|
|
"A View Provider for the BuildingPart object"
|
|
|
|
def __init__(self,vobj):
|
|
|
|
if vobj:
|
|
vobj.addExtension("Gui::ViewProviderGroupExtensionPython")
|
|
vobj.Proxy = self
|
|
self.setProperties(vobj)
|
|
vobj.ShapeColor = ArchCommands.getDefaultColor("Helpers")
|
|
self.Object = vobj.Object
|
|
|
|
def setProperties(self,vobj):
|
|
|
|
pl = vobj.PropertiesList
|
|
if not "LineWidth" in pl:
|
|
vobj.addProperty("App::PropertyFloat","LineWidth","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The line width of this object"), locked=True)
|
|
vobj.LineWidth = 1
|
|
if not "OverrideUnit" in pl:
|
|
vobj.addProperty("App::PropertyString","OverrideUnit","BuildingPart",QT_TRANSLATE_NOOP("App::Property","An optional unit to express levels"), locked=True)
|
|
if not "DisplayOffset" in pl:
|
|
vobj.addProperty("App::PropertyPlacement","DisplayOffset","BuildingPart",QT_TRANSLATE_NOOP("App::Property","A transformation to apply to the level mark"), locked=True)
|
|
vobj.DisplayOffset = FreeCAD.Placement(FreeCAD.Vector(0,0,0),FreeCAD.Rotation(FreeCAD.Vector(1,0,0),90))
|
|
if not "ShowLevel" in pl:
|
|
vobj.addProperty("App::PropertyBool","ShowLevel","BuildingPart",QT_TRANSLATE_NOOP("App::Property","If true, show the level"), locked=True)
|
|
vobj.ShowLevel = True
|
|
if not "ShowUnit" in pl:
|
|
vobj.addProperty("App::PropertyBool","ShowUnit","BuildingPart",QT_TRANSLATE_NOOP("App::Property","If true, show the unit on the level tag"), locked=True)
|
|
if not "OriginOffset" in pl:
|
|
vobj.addProperty("App::PropertyBool","OriginOffset","BuildingPart",QT_TRANSLATE_NOOP("App::Property","If true, display offset will affect the origin mark too"), locked=True)
|
|
if not "ShowLabel" in pl:
|
|
vobj.addProperty("App::PropertyBool","ShowLabel","BuildingPart",QT_TRANSLATE_NOOP("App::Property","If true, the object's label is displayed"), locked=True)
|
|
vobj.ShowLabel = True
|
|
if not "FontName" in pl:
|
|
vobj.addProperty("App::PropertyFont","FontName","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The font to be used for texts"), locked=True)
|
|
vobj.FontName = params.get_param("textfont")
|
|
if not "FontSize" in pl:
|
|
vobj.addProperty("App::PropertyLength","FontSize","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The font size of texts"), locked=True)
|
|
vobj.FontSize = params.get_param("textheight") * params.get_param("DefaultAnnoScaleMultiplier")
|
|
if not "DiffuseColor" in pl:
|
|
vobj.addProperty("App::PropertyColorList","DiffuseColor","BuildingPart",QT_TRANSLATE_NOOP("App::Property","The individual face colors"), locked=True)
|
|
|
|
# Interaction properties
|
|
if not "SetWorkingPlane" in pl:
|
|
vobj.addProperty("App::PropertyBool","SetWorkingPlane","Interaction",QT_TRANSLATE_NOOP("App::Property","If true, when activated, the working plane will automatically adapt to this level"), locked=True)
|
|
vobj.SetWorkingPlane = True
|
|
if not "AutoWorkingPlane" in pl:
|
|
vobj.addProperty("App::PropertyBool","AutoWorkingPlane","Interaction",QT_TRANSLATE_NOOP("App::Property","If set to True, the working plane will be kept on Auto mode"), locked=True)
|
|
if not "ViewData" in pl:
|
|
vobj.addProperty("App::PropertyFloatList","ViewData","Interaction",QT_TRANSLATE_NOOP("App::Property","Camera position data associated with this object"), locked=True)
|
|
vobj.setEditorMode("ViewData",2)
|
|
if not "RestoreView" in pl:
|
|
vobj.addProperty("App::PropertyBool","RestoreView","Interaction",QT_TRANSLATE_NOOP("App::Property","If set, the view stored in this object will be restored on double-click"), locked=True)
|
|
if not "DoubleClickActivates" in pl:
|
|
vobj.addProperty("App::PropertyBool","DoubleClickActivates","Interaction",QT_TRANSLATE_NOOP("App::Property","If True, double-clicking this object in the tree activates it"), locked=True)
|
|
vobj.DoubleClickActivates = True
|
|
|
|
# inventor saving
|
|
if not "SaveInventor" in pl:
|
|
vobj.addProperty("App::PropertyBool","SaveInventor","Interaction",QT_TRANSLATE_NOOP("App::Property","If this is enabled, the OpenInventor representation of this object will be saved in the FreeCAD file, allowing to reference it in other files in lightweight mode."), locked=True)
|
|
if not "SavedInventor" in pl:
|
|
vobj.addProperty("App::PropertyFileIncluded","SavedInventor","Interaction",QT_TRANSLATE_NOOP("App::Property","A slot to save the OpenInventor representation of this object, if enabled"), locked=True)
|
|
vobj.setEditorMode("SavedInventor",2)
|
|
|
|
# children properties
|
|
if not "ChildrenOverride" in pl:
|
|
vobj.addProperty("App::PropertyBool","ChildrenOverride","Children",QT_TRANSLATE_NOOP("App::Property","If true, show the objects contained in this Building Part will adopt these line, color and transparency settings"), locked=True)
|
|
if not "ChildrenLineWidth" in pl:
|
|
vobj.addProperty("App::PropertyFloat","ChildrenLineWidth","Children",QT_TRANSLATE_NOOP("App::Property","The line width of child objects"), locked=True)
|
|
vobj.ChildrenLineWidth = params.get_param_view("DefaultShapeLineWidth")
|
|
if not "ChildrenLineColor" in pl:
|
|
vobj.addProperty("App::PropertyColor","ChildrenLineColor","Children",QT_TRANSLATE_NOOP("App::Property","The line color of child objects"), locked=True)
|
|
vobj.ChildrenLineColor = params.get_param_view("DefaultShapeLineColor") & 0xFFFFFF00
|
|
if not "ChildrenShapeColor" in pl:
|
|
vobj.addProperty("App::PropertyMaterial","ChildrenShapeColor","Children",QT_TRANSLATE_NOOP("App::Property","The shape appearance of child objects"), locked=True)
|
|
vobj.ChildrenShapeColor = params.get_param_view("DefaultShapeColor") & 0xFFFFFF00
|
|
if not "ChildrenTransparency" in pl:
|
|
vobj.addProperty("App::PropertyPercent","ChildrenTransparency","Children",QT_TRANSLATE_NOOP("App::Property","The transparency of child objects"), locked=True)
|
|
vobj.ChildrenTransparency = params.get_param_view("DefaultShapeTransparency")
|
|
|
|
# clip properties
|
|
if not "CutView" in pl:
|
|
vobj.addProperty("App::PropertyBool","CutView","Clip",QT_TRANSLATE_NOOP("App::Property","Cut the view above this level"), locked=True)
|
|
if not "CutMargin" in pl:
|
|
vobj.addProperty("App::PropertyLength","CutMargin","Clip",QT_TRANSLATE_NOOP("App::Property","The distance between the level plane and the cut line"), locked=True)
|
|
vobj.CutMargin = 1600
|
|
if not "AutoCutView" in pl:
|
|
vobj.addProperty("App::PropertyBool","AutoCutView","Clip",QT_TRANSLATE_NOOP("App::Property","Turn cutting on when activating this level"), locked=True)
|
|
|
|
# autogroup properties
|
|
if not "AutogroupSize" in pl:
|
|
vobj.addProperty("App::PropertyIntegerList","AutogroupSize","AutoGroup",QT_TRANSLATE_NOOP("App::Property","The capture box for newly created objects expressed as [XMin,YMin,ZMin,XMax,YMax,ZMax]"), locked=True)
|
|
if not "AutogroupBox" in pl:
|
|
vobj.addProperty("App::PropertyBool","AutogroupBox","AutoGroup",QT_TRANSLATE_NOOP("App::Property","Turns auto group box on/off"), locked=True)
|
|
if not "AutogroupAutosize" in pl:
|
|
vobj.addProperty("App::PropertyBool","AutogroupAutosize","AutoGroup",QT_TRANSLATE_NOOP("App::Property","Automatically set size from contents"), locked=True)
|
|
if not "AutogroupMargin" in pl:
|
|
vobj.addProperty("App::PropertyLength","AutogroupMargin","AutoGroup",QT_TRANSLATE_NOOP("App::Property","A margin to use when autosize is turned on"), locked=True)
|
|
|
|
def onDocumentRestored(self,vobj):
|
|
|
|
self.setProperties(vobj)
|
|
|
|
def getIcon(self):
|
|
|
|
import Arch_rc
|
|
if hasattr(self,"Object"):
|
|
if self.Object.IfcType == "Building Storey":
|
|
return ":/icons/Arch_Floor_Tree.svg"
|
|
elif self.Object.IfcType == "Building":
|
|
return ":/icons/Arch_Building_Tree.svg"
|
|
elif self.Object.IfcType == "Annotation":
|
|
return ":/icons/BIM_ArchView.svg"
|
|
elif hasattr(self.Object,"IfcClass"):
|
|
from nativeifc import ifc_viewproviders
|
|
return ifc_viewproviders.get_icon(self)
|
|
return ":/icons/Arch_BuildingPart_Tree.svg"
|
|
|
|
def attach(self,vobj):
|
|
|
|
self.Object = vobj.Object
|
|
self.clip = None
|
|
from pivy import coin
|
|
self.sep = coin.SoGroup()
|
|
self.mat = coin.SoMaterial()
|
|
self.sep.addChild(self.mat)
|
|
self.dst = coin.SoDrawStyle()
|
|
self.sep.addChild(self.dst)
|
|
self.lco = coin.SoCoordinate3()
|
|
self.sep.addChild(self.lco)
|
|
import PartGui # Required for "SoBrepEdgeSet" (because a BuildingPart is not a Part::FeaturePython object).
|
|
lin = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
|
|
if lin:
|
|
lin.coordIndex.setValues([0,1,-1,2,3,-1,4,5,-1])
|
|
self.sep.addChild(lin)
|
|
self.bbox = coin.SoSwitch()
|
|
self.bbox.whichChild = -1
|
|
bboxsep = coin.SoSeparator()
|
|
self.bbox.addChild(bboxsep)
|
|
drawstyle = coin.SoDrawStyle()
|
|
drawstyle.style = coin.SoDrawStyle.LINES
|
|
drawstyle.lineWidth = 3
|
|
drawstyle.linePattern = 0x0f0f # 0xaa
|
|
bboxsep.addChild(drawstyle)
|
|
self.bbco = coin.SoCoordinate3()
|
|
bboxsep.addChild(self.bbco)
|
|
lin = coin.SoIndexedLineSet()
|
|
lin.coordIndex.setValues([0,1,2,3,0,-1,4,5,6,7,4,-1,0,4,-1,1,5,-1,2,6,-1,3,7,-1])
|
|
bboxsep.addChild(lin)
|
|
self.sep.addChild(self.bbox)
|
|
self.tra = coin.SoTransform()
|
|
self.tra.rotation.setValue(FreeCAD.Rotation(0,0,90).Q)
|
|
self.sep.addChild(self.tra)
|
|
self.fon = coin.SoFont()
|
|
self.sep.addChild(self.fon)
|
|
self.txt = coin.SoAsciiText()
|
|
self.txt.justification = coin.SoText2.LEFT
|
|
self.txt.string.setValue("level")
|
|
self.sep.addChild(self.txt)
|
|
vobj.addDisplayMode(self.sep,"Default")
|
|
self.onChanged(vobj,"ShapeColor")
|
|
self.onChanged(vobj,"FontName")
|
|
self.onChanged(vobj,"ShowLevel")
|
|
self.onChanged(vobj,"FontSize")
|
|
self.onChanged(vobj,"AutogroupBox")
|
|
self.setProperties(vobj)
|
|
return
|
|
|
|
def getDisplayModes(self,vobj):
|
|
|
|
return ["Default"]
|
|
|
|
def getDefaultDisplayMode(self):
|
|
|
|
return "Default"
|
|
|
|
def setDisplayMode(self,mode):
|
|
|
|
return mode
|
|
|
|
def updateData(self,obj,prop):
|
|
|
|
if prop in ["Placement","LevelOffset"]:
|
|
self.onChanged(obj.ViewObject,"OverrideUnit")
|
|
elif prop == "Shape":
|
|
# gather all the child shapes
|
|
colors = self.getColors(obj)
|
|
if colors and hasattr(obj.ViewObject,"DiffuseColor"):
|
|
if len(colors) == len(obj.Shape.Faces):
|
|
if colors != obj.ViewObject.DiffuseColor:
|
|
obj.ViewObject.DiffuseColor = colors
|
|
self.writeInventor(obj)
|
|
#else:
|
|
#print("color mismatch:",len(colors),"colors,",len(obj.Shape.Faces),"faces")
|
|
elif prop == "Group":
|
|
self.onChanged(obj.ViewObject,"ChildrenOverride")
|
|
elif prop == "Label":
|
|
self.onChanged(obj.ViewObject,"ShowLabel")
|
|
|
|
def getColors(self,obj):
|
|
|
|
"recursively get the colors of objects inside this BuildingPart"
|
|
|
|
colors = []
|
|
for child in Draft.get_group_contents(obj, walls=True):
|
|
if not Draft.get_type(child) in ["Space"]:
|
|
if hasattr(child,'Shape') and (hasattr(child.ViewObject,"DiffuseColor") or hasattr(child.ViewObject,"ShapeColor")):
|
|
if hasattr(child.ViewObject,"DiffuseColor") and len(child.ViewObject.DiffuseColor) == len(child.Shape.Faces):
|
|
colors.extend(child.ViewObject.DiffuseColor)
|
|
else:
|
|
c = child.ViewObject.ShapeColor[:3]+(1.0 - child.ViewObject.Transparency/100.0,)
|
|
for i in range(len(child.Shape.Faces)):
|
|
colors.append(c)
|
|
return colors
|
|
|
|
def onChanged(self,vobj,prop):
|
|
|
|
#print(vobj.Object.Label," - ",prop)
|
|
|
|
if prop == "ShapeColor":
|
|
if hasattr(vobj,"ShapeColor"):
|
|
l = vobj.ShapeColor
|
|
self.mat.diffuseColor.setValue([l[0],l[1],l[2]])
|
|
elif prop == "LineWidth":
|
|
if hasattr(vobj,"LineWidth"):
|
|
self.dst.lineWidth = vobj.LineWidth
|
|
elif prop == "FontName":
|
|
if hasattr(vobj,"FontName") and hasattr(self,"fon"):
|
|
if vobj.FontName:
|
|
self.fon.name = vobj.FontName
|
|
elif prop in ["FontSize","DisplayOffset","OriginOffset"]:
|
|
if hasattr(vobj,"FontSize") and hasattr(vobj,"DisplayOffset") and hasattr(vobj,"OriginOffset") and hasattr(self,"fon"):
|
|
fs = vobj.FontSize.Value
|
|
if fs:
|
|
self.fon.size = fs
|
|
b = vobj.DisplayOffset.Base
|
|
self.tra.translation.setValue([b.x+fs/8,b.y,b.z+fs/8])
|
|
r = vobj.DisplayOffset.Rotation
|
|
self.tra.rotation.setValue(r.Q)
|
|
if vobj.OriginOffset:
|
|
self.lco.point.setValues([[b.x-fs,b.y,b.z],[b.x+fs,b.y,b.z],[b.x,b.y-fs,b.z],[b.x,b.y+fs,b.z],[b.x,b.y,b.z-fs],[b.x,b.y,b.z+fs]])
|
|
else:
|
|
self.lco.point.setValues([[-fs,0,0],[fs,0,0],[0,-fs,0],[0,fs,0],[0,0,-fs],[0,0,fs]])
|
|
elif prop in ["OverrideUnit","ShowUnit","ShowLevel","ShowLabel"]:
|
|
if hasattr(vobj,"OverrideUnit") and hasattr(vobj,"ShowUnit") and hasattr(vobj,"ShowLevel") and hasattr(vobj,"ShowLabel") and hasattr(self,"txt"):
|
|
offset = getattr(vobj.Object, "LevelOffset", 0)
|
|
if hasattr(offset, "Value"):
|
|
offset = offset.Value
|
|
z = vobj.Object.Placement.Base.z + offset
|
|
q = FreeCAD.Units.Quantity(z,FreeCAD.Units.Length)
|
|
txt = ""
|
|
if vobj.ShowLabel:
|
|
txt += vobj.Object.Label
|
|
if vobj.ShowLevel:
|
|
if txt:
|
|
txt += " "
|
|
if z >= 0:
|
|
txt += "+"
|
|
if vobj.OverrideUnit:
|
|
u = vobj.OverrideUnit
|
|
else:
|
|
u = q.getUserPreferred()[2]
|
|
try:
|
|
txt += units.display_external(float(q),None,'Length',vobj.ShowUnit,u)
|
|
except Exception:
|
|
q = q.getValueAs(q.getUserPreferred()[2])
|
|
d = params.get_param("Decimals",path="Units")
|
|
fmt = "{0:."+ str(d) + "f}"
|
|
if not vobj.ShowUnit:
|
|
u = ""
|
|
txt += fmt.format(float(q)) + str(u)
|
|
if not txt:
|
|
txt = " " # empty texts make coin crash...
|
|
if isinstance(txt,unicode):
|
|
txt = txt.encode("utf8")
|
|
self.txt.string.setValue(txt)
|
|
elif prop in ["ChildrenOverride","ChildenLineWidth","ChildrenLineColor","ChildrenShapeColor","ChildrenTransparency"]:
|
|
if hasattr(vobj,"ChildrenOverride") and vobj.ChildrenOverride:
|
|
props = ["ChildenLineWidth","ChildrenLineColor","ChildrenShapeColor","ChildrenTransparency"]
|
|
for child in vobj.Object.Group:
|
|
for prop in props:
|
|
if hasattr(vobj,prop) and hasattr(child.ViewObject,prop[8:]) and not hasattr(child,"ChildrenOverride"):
|
|
setattr(child.ViewObject,prop[8:],getattr(vobj,prop))
|
|
elif prop in ["CutView","CutMargin"]:
|
|
if hasattr(vobj, "CutView") \
|
|
and FreeCADGui.ActiveDocument.ActiveView \
|
|
and hasattr(FreeCADGui.ActiveDocument.ActiveView, "getSceneGraph"):
|
|
sg = FreeCADGui.ActiveDocument.ActiveView.getSceneGraph()
|
|
if vobj.CutView:
|
|
from pivy import coin
|
|
if self.clip:
|
|
sg.removeChild(self.clip)
|
|
self.clip = None
|
|
for o in Draft.get_group_contents(vobj.Object.Group,
|
|
walls=True):
|
|
if hasattr(o.ViewObject,"Lighting"):
|
|
o.ViewObject.Lighting = "One side"
|
|
self.clip = coin.SoClipPlane()
|
|
self.clip.on.setValue(True)
|
|
norm = vobj.Object.Placement.multVec(FreeCAD.Vector(0,0,1))
|
|
mp = vobj.Object.Placement.Base
|
|
mp = DraftVecUtils.project(mp,norm)
|
|
dist = mp.Length #- 0.1 # to not clip exactly on the section object
|
|
norm = norm.negative()
|
|
marg = 1
|
|
if hasattr(vobj,"CutMargin"):
|
|
marg = vobj.CutMargin.Value
|
|
if mp.getAngle(norm) > 1:
|
|
dist += marg
|
|
dist = -dist
|
|
else:
|
|
dist -= marg
|
|
plane = coin.SbPlane(coin.SbVec3f(norm.x,norm.y,norm.z),dist)
|
|
self.clip.plane.setValue(plane)
|
|
sg.insertChild(self.clip,0)
|
|
else:
|
|
if getattr(self,"clip",None):
|
|
sg.removeChild(self.clip)
|
|
self.clip = None
|
|
for o in Draft.get_group_contents(vobj.Object.Group,
|
|
walls=True):
|
|
if hasattr(o.ViewObject,"Lighting"):
|
|
o.ViewObject.Lighting = "Two side"
|
|
elif prop == "Visibility":
|
|
# turn clipping off when turning the object off
|
|
if hasattr(vobj,"Visibility") and not(vobj.Visibility) and hasattr(vobj,"CutView"):
|
|
vobj.CutView = False
|
|
elif prop == "SaveInventor":
|
|
self.writeInventor(vobj.Object)
|
|
elif prop in ["AutogroupBox","AutogroupSize"]:
|
|
if hasattr(vobj,"AutogroupBox") and hasattr(vobj,"AutogroupSize"):
|
|
if vobj.AutogroupBox:
|
|
if len(vobj.AutogroupSize) >= 6:
|
|
self.autobbox = FreeCAD.BoundBox(*vobj.AutogroupSize[0:6])
|
|
self.autobbox.move(vobj.Object.Placement.Base)
|
|
pts = [list(self.autobbox.getPoint(i)) for i in range(8)]
|
|
self.bbco.point.setValues(pts)
|
|
self.bbox.whichChild = 0
|
|
else:
|
|
self.autobbox = None
|
|
self.bbox.whichChild = -1
|
|
elif prop in ["AutogroupAutosize","AutogroupMargin"]:
|
|
if hasattr(vobj,"AutogroupAutosize") and vobj.AutogroupAutosize:
|
|
bbox = vobj.Object.Shape.BoundBox
|
|
bbox.enlarge(vobj.AutogroupMargin.Value)
|
|
vobj.AutogroupSize = [int(i) for i in [bbox.XMin,bbox.YMin,bbox.ZMin,bbox.XMax,bbox.YMax,bbox.ZMax]]
|
|
|
|
def onDelete(self,vobj,subelements):
|
|
|
|
if self.clip:
|
|
sg.removeChild(self.clip)
|
|
self.clip = None
|
|
for o in Draft.get_group_contents(vobj.Object.Group, walls=True):
|
|
if hasattr(o.ViewObject,"Lighting"):
|
|
o.ViewObject.Lighting = "Two side"
|
|
return True
|
|
|
|
def setEdit(self, vobj, mode):
|
|
# mode == 1 if Transform is selected in the Tree view context menu.
|
|
# mode == 2 has been added for consistency.
|
|
if mode == 1 or mode == 2:
|
|
return None
|
|
# For some reason mode is always 0 if the object is double-clicked in
|
|
# the Tree view. Using FreeCADGui.getUserEditMode() as a workaround.
|
|
if FreeCADGui.getUserEditMode() in ("Transform", "Cutting"):
|
|
return None
|
|
|
|
self.activate()
|
|
return False # Return `False` as we don't want to enter edit mode.
|
|
|
|
def unsetEdit(self, vobj, mode):
|
|
if mode == 1 or mode == 2:
|
|
return None
|
|
if FreeCADGui.getUserEditMode() in ("Transform", "Cutting"):
|
|
return None
|
|
|
|
return True
|
|
|
|
def setupContextMenu(self, vobj, menu):
|
|
from PySide import QtCore, QtGui
|
|
import Draft_rc
|
|
if FreeCADGui.activeWorkbench().name() != 'BIMWorkbench':
|
|
return
|
|
if (not hasattr(vobj,"DoubleClickActivates")) or vobj.DoubleClickActivates:
|
|
menuTxt = translate("Arch", "Active")
|
|
actionActivate = QtGui.QAction(menuTxt, menu)
|
|
actionActivate.setCheckable(True)
|
|
if FreeCADGui.ActiveDocument.ActiveView.getActiveObject("Arch") == self.Object:
|
|
actionActivate.setChecked(True)
|
|
else:
|
|
actionActivate.setChecked(False)
|
|
actionActivate.triggered.connect(lambda _: self.activate(actionActivate))
|
|
menu.addAction(actionActivate)
|
|
|
|
actionSetWorkingPlane = QtGui.QAction(QtGui.QIcon(":/icons/Draft_SelectPlane.svg"),
|
|
translate("Arch", "Set working plane"),
|
|
menu)
|
|
QtCore.QObject.connect(actionSetWorkingPlane,
|
|
QtCore.SIGNAL("triggered()"),
|
|
self.setWorkingPlane)
|
|
menu.addAction(actionSetWorkingPlane)
|
|
|
|
actionWriteCamera = QtGui.QAction(QtGui.QIcon(":/icons/Draft_SelectPlane.svg"),
|
|
translate("Arch", "Write camera position"),
|
|
menu)
|
|
QtCore.QObject.connect(actionWriteCamera,
|
|
QtCore.SIGNAL("triggered()"),
|
|
self.writeCamera)
|
|
menu.addAction(actionWriteCamera)
|
|
|
|
actionCreateGroup = QtGui.QAction(translate("Arch", "Create group..."),
|
|
menu)
|
|
QtCore.QObject.connect(actionCreateGroup,
|
|
QtCore.SIGNAL("triggered()"),
|
|
self.createGroup)
|
|
menu.addAction(actionCreateGroup)
|
|
|
|
actionReorder = QtGui.QAction(translate("Arch", "Reorder children alphabetically"),
|
|
menu)
|
|
QtCore.QObject.connect(actionReorder,
|
|
QtCore.SIGNAL("triggered()"),
|
|
self.reorder)
|
|
menu.addAction(actionReorder)
|
|
|
|
actionCloneUp = QtGui.QAction(translate("Arch", "Clone level up"),
|
|
menu)
|
|
QtCore.QObject.connect(actionCloneUp,
|
|
QtCore.SIGNAL("triggered()"),
|
|
self.cloneUp)
|
|
menu.addAction(actionCloneUp)
|
|
|
|
def activate(self, action=None):
|
|
from draftutils.utils import toggle_working_plane
|
|
vobj = self.Object.ViewObject
|
|
|
|
if (not hasattr(vobj,"DoubleClickActivates")) or vobj.DoubleClickActivates:
|
|
if toggle_working_plane(self.Object, action, restore=True):
|
|
print("Setting active working plane to: ", self.Object.Label)
|
|
else:
|
|
print("Deactivating working plane from: ", self.Object.Label)
|
|
|
|
FreeCADGui.Selection.clearSelection()
|
|
|
|
def setWorkingPlane(self,restore=False):
|
|
vobj = self.Object.ViewObject
|
|
|
|
import WorkingPlane
|
|
wp = WorkingPlane.get_working_plane(update=False)
|
|
autoclip = False
|
|
if hasattr(vobj,"AutoCutView"):
|
|
autoclip = vobj.AutoCutView
|
|
if restore:
|
|
if wp.label.rstrip("*") == self.Object.Label:
|
|
prev_data = wp._previous()
|
|
if prev_data:
|
|
prev_label = prev_data.get("label", "").rstrip("*")
|
|
prev_obj = None
|
|
for obj in FreeCAD.ActiveDocument.Objects:
|
|
if hasattr(obj, "Label") and obj.Label == prev_label:
|
|
prev_obj = obj
|
|
break
|
|
|
|
if prev_obj:
|
|
# check in which context we need to set the active object
|
|
context = "Arch"
|
|
obj_type = Draft.getType(prev_obj)
|
|
if obj_type == "IfcBuildingStorey":
|
|
context = "NativeIFC"
|
|
FreeCADGui.ActiveDocument.ActiveView.setActiveObject(context, prev_obj)
|
|
print(f"Set active object to: {prev_obj.Label} (context: {context})")
|
|
|
|
if autoclip:
|
|
vobj.CutView = False
|
|
else:
|
|
wp.align_to_selection()
|
|
if autoclip:
|
|
vobj.CutView = True
|
|
|
|
def writeCamera(self):
|
|
|
|
if hasattr(self,"Object"):
|
|
from pivy import coin
|
|
n = FreeCADGui.ActiveDocument.ActiveView.getCameraNode()
|
|
FreeCAD.Console.PrintMessage(QT_TRANSLATE_NOOP("Draft","Writing camera position")+"\n")
|
|
cdata = list(n.position.getValue().getValue())
|
|
cdata.extend(list(n.orientation.getValue().getValue()))
|
|
cdata.append(n.nearDistance.getValue())
|
|
cdata.append(n.farDistance.getValue())
|
|
cdata.append(n.aspectRatio.getValue())
|
|
cdata.append(n.focalDistance.getValue())
|
|
if isinstance(n,coin.SoOrthographicCamera):
|
|
cdata.append(n.height.getValue())
|
|
cdata.append(0.0) # orthograhic camera
|
|
elif isinstance(n,coin.SoPerspectiveCamera):
|
|
cdata.append(n.heightAngle.getValue())
|
|
cdata.append(1.0) # perspective camera
|
|
self.Object.ViewObject.ViewData = cdata
|
|
|
|
def createGroup(self):
|
|
|
|
if hasattr(self,"Object"):
|
|
s = "FreeCAD.ActiveDocument.getObject(\"%s\").newObject(\"App::DocumentObjectGroup\",\"Group\")" % self.Object.Name
|
|
FreeCADGui.doCommand(s)
|
|
|
|
def reorder(self):
|
|
|
|
if hasattr(self,"Object"):
|
|
if hasattr(self.Object,"Group") and self.Object.Group:
|
|
g = self.Object.Group
|
|
g.sort(key=lambda obj: obj.Label)
|
|
self.Object.Group = g
|
|
FreeCAD.ActiveDocument.recompute()
|
|
|
|
def cloneUp(self):
|
|
|
|
if hasattr(self,"Object"):
|
|
if not self.Object.Height.Value:
|
|
FreeCAD.Console.PrintError("This level has no height value. Please define a height before using this function.\n")
|
|
return
|
|
height = self.Object.Height.Value
|
|
ng = []
|
|
if hasattr(self.Object,"Group") and self.Object.Group:
|
|
for o in self.Object.Group:
|
|
no = Draft.clone(o)
|
|
Draft.move(no,FreeCAD.Vector(0,0,height))
|
|
ng.append(no)
|
|
nobj = Arch.makeBuildingPart()
|
|
Draft.formatObject(nobj,self.Object)
|
|
nobj.Placement = self.Object.Placement
|
|
nobj.Placement.move(FreeCAD.Vector(0,0,height))
|
|
nobj.IfcType = self.Object.IfcType
|
|
nobj.Height = height
|
|
nobj.Label = self.Object.Label
|
|
nobj.Group = ng
|
|
for parent in self.Object.InList:
|
|
if hasattr(parent,"Group") and hasattr(parent,"addObject") and (self.Object in parent.Group):
|
|
parent.addObject(nobj)
|
|
FreeCAD.ActiveDocument.recompute()
|
|
# fix for missing IFC attributes
|
|
for no in ng:
|
|
if hasattr(no,"LongName") and hasattr(no,"CloneOf") and no.CloneOf and hasattr(no.CloneOf,"LongName"):
|
|
no.LongName = no.CloneOf.LongName
|
|
FreeCAD.ActiveDocument.recompute()
|
|
|
|
def dumps(self):
|
|
return None
|
|
|
|
def loads(self,state):
|
|
return None
|
|
|
|
def writeInventor(self,obj):
|
|
|
|
def callback(match):
|
|
return next(callback.v)
|
|
|
|
if hasattr(obj.ViewObject,"SaveInventor") and obj.ViewObject.SaveInventor:
|
|
if obj.Shape and obj.Shape.Faces and hasattr(obj,"SavedInventor"):
|
|
colors = obj.ViewObject.DiffuseColor
|
|
if len(colors) != len(obj.Shape.Faces):
|
|
print("Debug: Colors mismatch in",obj.Label)
|
|
colors = None
|
|
iv = self.Object.Shape.writeInventor()
|
|
import re
|
|
if colors:
|
|
if len(re.findall(r"IndexedFaceSet",iv)) == len(obj.Shape.Faces):
|
|
# convert colors to iv representations
|
|
colors = ["Material { diffuseColor "+str(color[0])+" "+str(color[1])+" "+str(color[2])+"}\n IndexedFaceSet" for color in colors]
|
|
# replace
|
|
callback.v=iter(colors)
|
|
iv = re.sub(r"IndexedFaceSet",callback,iv)
|
|
else:
|
|
print("Debug: IndexedFaceSet mismatch in",obj.Label)
|
|
# save embedded file
|
|
tf = tempfile.mkstemp(prefix=obj.Name,suffix=".iv")[1]
|
|
f = open(tf,"w")
|
|
f.write(iv)
|
|
f.close()
|
|
obj.SavedInventor = tf
|
|
os.remove(tf)
|