X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FConnectorPlugin%2FConnectorPlugin_PublishToStudyFeature.py;h=15efb9750ecc4a3b206c338a1bae40f104588ba4;hb=a13f87935d2a6f52f942790b6abc874f1016c9fc;hp=a21dca2c6c317288a7f89acb3f9db173052bb1e4;hpb=689cf0cf4c12d33f4b2850975e9b466a28903da1;p=modules%2Fshaper.git diff --git a/src/ConnectorPlugin/ConnectorPlugin_PublishToStudyFeature.py b/src/ConnectorPlugin/ConnectorPlugin_PublishToStudyFeature.py index a21dca2c6..15efb9750 100644 --- a/src/ConnectorPlugin/ConnectorPlugin_PublishToStudyFeature.py +++ b/src/ConnectorPlugin/ConnectorPlugin_PublishToStudyFeature.py @@ -23,13 +23,14 @@ import ModelAPI import ExchangeAPI import EventsAPI +from GeomAPI import * +import GeomAlgoAPI import salome from salome.shaper import model -import os -import salome - +import SHAPERSTUDY_ORB +import SHAPERSTUDY_utils ## @ingroup Plugins # Feature to export all shapes and groups into the GEOM module @@ -59,17 +60,24 @@ class PublishToStudyFeature(ModelAPI.ModelAPI_Feature): ## Exports all shapes and groups into the GEOM module. def execute(self): - print("### Execution of PublishToStudy") - + aSession = ModelAPI.ModelAPI_Session.get() + aPartSet = aSession.moduleDocument() + # check that the PartSet document current feature is the last to avoid problems with all + # features update + if aPartSet.size(model.ModelAPI_Feature_group()) > 0: + aLastFeature = ModelAPI.objectToFeature(aPartSet.object(model.ModelAPI_Feature_group(), aPartSet.size(model.ModelAPI_Feature_group()) - 1)) + aCurrentFeature = aPartSet.currentFeature(True) + if aLastFeature.data().featureId() != aCurrentFeature.data().featureId(): + EventsAPI.Events_InfoMessage("PublishToStudy", "Not all PartSet parts are up-to-date, nothing is published. Please, make the last PartSet feature as current.", self).send() + return # find a shaper-study component salome.salome_init(1) - import SHAPERSTUDY_utils - SHAPERSTUDY_utils.findOrCreateComponent() + aComponent = SHAPERSTUDY_utils.findOrCreateComponent() anEngine = SHAPERSTUDY_utils.getEngine() + # collect all processed internal entries to break the link of unprocessed later + allProcessed = [] # iterate all parts and all results to publish them in SHAPER_STUDY - aSession = ModelAPI.ModelAPI_Session.get() - aPartSet = aSession.moduleDocument() for aPartId in range(aPartSet.size(model.ModelAPI_ResultPart_group())): aPartObject = aPartSet.object(model.ModelAPI_ResultPart_group(), aPartId) aPartRes = ModelAPI.modelAPI_ResultPart(ModelAPI.modelAPI_Result(aPartObject)) @@ -78,13 +86,187 @@ class PublishToStudyFeature(ModelAPI.ModelAPI_Feature): EventsAPI.Events_InfoMessage("PublishToStudy", "For publish to SHAPER-STUDY some Part is not activated", self).send() break aPartFeatureId = aPartSet.feature(aPartRes).data().featureId() + # Collects all features of exported results to find results of the same features and extend id. + # Map from feature index to index of result. If index is zero (initial), no surrfix to entry is added. + aFeaturesIndices = {} for aResId in range(aPartDoc.size(model.ModelAPI_ResultBody_group())): aResObject = aPartDoc.object(model.ModelAPI_ResultBody_group(), aResId) aRes = model.objectToResult(aResObject) - print("Found a result to publish ", aRes.data().name()) - aResFeatureId = aPartDoc.feature(aRes).data().featureId() - aSSEntry = str(aPartFeatureId) + ":" + str(aResFeatureId) + aResFeatureId = str(aPartDoc.feature(aRes).data().featureId()) + if aResFeatureId in aFeaturesIndices: + aFeaturesIndices[aResFeatureId] += 1 + aResFeatureId += ":" + str(aFeaturesIndices[aResFeatureId]) + else: + aFeaturesIndices[aResFeatureId] = 0 + aSSEntry = str(aPartFeatureId) + ":" + aResFeatureId aSShape = anEngine.FindOrCreateShape(aSSEntry) aSShape.SetShapeByStream(aRes.shape().getShapeStream(False)) if not aSShape.GetSO(): # publish in case it is a new shape anEngine.AddInStudy(aSShape, aRes.data().name(), None) + else: # restore a red reference if it was deleted + aDone, aSO2 = aSShape.GetSO().FindSubObject(1) + if aDone: + aDone, aRef = aSO2.ReferencedObject() + if not aDone: + aBuilder = SHAPERSTUDY_utils.getStudy().NewBuilder() + aBuilder.Addreference(aSO2, aSShape.GetSO()) + allProcessed.append(aSSEntry) + # Groups + self.processGroups(aRes, anEngine, aPartFeatureId, aSShape, False) + # Fields + self.processGroups(aRes, anEngine, aPartFeatureId, aSShape, True) + + # process all SHAPER-STUDY shapes to find dead + aSOIter = SHAPERSTUDY_utils.getStudy().NewChildIterator(aComponent) + while aSOIter.More(): + aSO = aSOIter.Value() + aSOIter.Next() # here because there is continue inside the loop + anIOR = aSO.GetIOR() + if len(anIOR): + anObj = salome.orb.string_to_object(anIOR) + if isinstance(anObj, SHAPERSTUDY_ORB._objref_SHAPER_Object): + anEntry = anObj.GetEntry() + if len(anEntry) == 0: + continue; + elif anEntry not in allProcessed: # found a removed shape: make it dead for the moment + # remove the reference - red node + aRes, aSO2 = aSO.FindSubObject(1) + if aRes: + aRes, aRef = aSO2.ReferencedObject() + if aRes: + aBuilder = SHAPERSTUDY_utils.getStudy().NewBuilder() + aBuilder.RemoveReference(aSO2) + # if the object is not marked as dead, mark it (#3201) to make all entries unique + aDeadEntry = anObj.GetEntry() + if not aDeadEntry.startswith("dead"): + anIndex = aSO.Tag() + anObj.SetEntry("dead0" + str(anIndex) + "_" + aDeadEntry) + + # also for groups + aGrSOIter = SHAPERSTUDY_utils.getStudy().NewChildIterator(aSO) + while aGrSOIter.More(): + aGroupSO = aGrSOIter.Value() + aGrSOIter.Next() + anIOR = aGroupSO.GetIOR() + if len(anIOR): + aGroup = salome.orb.string_to_object(anIOR) + if isinstance(aGroup, SHAPERSTUDY_ORB._objref_SHAPER_Group) or \ + isinstance(aGroup, SHAPERSTUDY_ORB._objref_SHAPER_Field): + if not aGroup.GetEntry().startswith("dead"): + aDeadGroupEntry = "dead0" + str(anIndex) + "_" + aGroup.GetEntry() + aGroup.SetEntry(aDeadGroupEntry) + + # Part of the "execute" method: processes the Groups of theRes result publication. + # If theFields is true, the same is performed for Fields. + def processGroups(self, theRes, theEngine, thePartFeatureId, theStudyShape, theFields): + allGroupsProcessed = [] + if theFields: + aRefGroups = ModelAPI.referencedFeatures(theRes, "Field", True) + else: + aRefGroups = ModelAPI.referencedFeatures(theRes, "Group", True) + for aRef in aRefGroups: + aGroupIndices = [] + aGroupHasIndex = {} + aResShape = theRes.shape() + if theFields: + aSelList = aRef.selectionList("selected") + else: + aSelList = aRef.selectionList("group_list") + aSelType = GeomAPI_Shape.shapeTypeByStr(aSelList.selectionType()) + for aSelIndex in range(aSelList.size()): + aSelection = aSelList.value(aSelIndex) + if aSelection.contextObject(): + aShape = aSelection.value() + if aShape: + allShapesList = [] # collect all sub-shapes selected in the group + if aShape.shapeType() == 0 or aShape.shapeType() != aSelType: # compound or whole res + anExplorer = GeomAPI_ShapeExplorer(aShape, aSelType) + while anExplorer.more(): + allShapesList.append(anExplorer.current()) + anExplorer.next() + else: + allShapesList.append(aShape) + # get index of each selected shape: if 0, this sub-shape is not in our result + for aSelected in allShapesList: + anId = GeomAlgoAPI.GeomAlgoAPI_CompoundBuilder.id(aResShape, aSelected) + if anId > 0 and not anId in aGroupHasIndex: + aGroupIndices.append(anId) + aGroupHasIndex[anId] = 0 + if len(aGroupIndices): # create group + aGroupFeatureId = aRef.data().featureId() + if theFields: + aFieldOp = theEngine.GetIFieldOperations() + aGroupEntry = "field" + str(thePartFeatureId) + ":" + str(aGroupFeatureId) + aGroup = aFieldOp.FindField(theStudyShape, aGroupEntry) + else: + aGroupOp = theEngine.GetIGroupOperations() + aGroupEntry = "group" + str(thePartFeatureId) + ":" + str(aGroupFeatureId) + aGroup = aGroupOp.FindGroup(theStudyShape, aGroupEntry) + if not aGroup: # create a new + if theFields: + aGroup = aFieldOp.CreateFieldByType(theStudyShape, aSelType) + else: + aGroup = aGroupOp.CreateGroup(theStudyShape, aSelType) + aGroup.SetEntry(aGroupEntry) + theEngine.AddInStudy(aGroup, aRef.firstResult().data().name(), theStudyShape) + aGroup.SetSelection(aGroupIndices) + if theFields: + self.fillField(aGroup, aRef, theEngine, aGroupIndices) + # a group takes shape from the main result + #aGroup.SetShapeByStream(aRef.firstResult().shape().getShapeStream(False)) # group shape + allGroupsProcessed.append(aGroupEntry) + # check all existing groups: if some does not processed, remove it from the tree + aSOIter = SHAPERSTUDY_utils.getStudy().NewChildIterator(theStudyShape.GetSO()) + while aSOIter.More(): + aSO = aSOIter.Value() + anIOR = aSO.GetIOR() + if len(anIOR): + anObj = salome.orb.string_to_object(anIOR) + if (theFields and isinstance(anObj, SHAPERSTUDY_ORB._objref_SHAPER_Field)) or \ + (not theFields and type(anObj) == SHAPERSTUDY_ORB._objref_SHAPER_Group): + anEntry = anObj.GetEntry() + if anEntry not in allGroupsProcessed: # found a removed group => remove + aBuilder = SHAPERSTUDY_utils.getStudy().NewBuilder() + aBuilder.RemoveObject(anObj.GetSO()) + aSOIter.Next() + + # Part of the "execute" method: theFiled fields filling. + def fillField(self, theField, theFeature, theEngine, theSelectionIndices): + aTables = theFeature.tables("values") + aValType = aTables.type() # type of the values + theField.SetValuesType(aValType) + aNumSteps = aTables.tables() # number of steps is number of tables + aSteps = [] + for aVal in range(aNumSteps): + aSteps.append(aVal + 1) + theField.SetSteps(aSteps) + aCompNames = [] + aCompNamesAttr = theFeature.stringArray("components_names") + for anIndex in range(aCompNamesAttr.size()): + aCompNames.append(aCompNamesAttr.value(anIndex)) + theField.SetComponents(aCompNames) + # prepare the sub-shapes indices: all values for all sub-shapes must be defined + aShapeOp = theEngine.GetIShapesOperations() + allIndices = aShapeOp.GetAllSubShapesIDs(theField.GetShape(), theField.GetSelectionType(), False) + # define steps + theField.ClearFieldSteps() + for aVal in range(aNumSteps): + aVals = [] + for aCol in range(aTables.columns()): + #for aRow in range(aTables.rows()): + for anIndex in allIndices: + if anIndex in theSelectionIndices: + aRow = theSelectionIndices.index(anIndex) + 1 # starting from the first line + else: + aRow = 0 # default value + aStrVal = aTables.valueStr(aRow, aCol, aVal) + if aValType == 0: # boolean + if aStrVal == "True": + aVals.append(1) + else: + aVals.append(0) + elif aValType == 1: # int + aVals.append(int(aStrVal)) + elif aValType == 2: # double + aVals.append(float(aStrVal)) + theField.AddFieldStep(theFeature.intArray("stamps").value(aVal), aVal + 1, aVals)