#include <GeomAPI_Pnt.h>
#include <GeomAPI_Dir.h>
#include <GeomAPI_ShapeExplorer.h>
+#include <GeomAPI_ShapeIterator.h>
+#include <GeomAlgoAPI_NExplode.h>
#include <GeomDataAPI_Dir.h>
#include <GeomDataAPI_Point.h>
if (aNbFeatures.first == anId && aNbFeatures.second < anId) {
// name is not user-defined
isDefaultName = true;
+
+ // check there are postponed features of this kind,
+ // dump their names, because the sequence of features may be changed
+ for (std::list<EntityPtr>::const_iterator aPpIt = myPostponed.begin();
+ aPpIt != myPostponed.end(); ++aPpIt) {
+ FeaturePtr aCurFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*aPpIt);
+ if (aCurFeature && aCurFeature->getKind() == aKind) {
+ myNames[*aPpIt].myIsDefault = false;
+ isDefaultName = false;
+ }
+ }
}
if (anId > aNbFeatures.second)
return true;
}
+static bool isSketchSub(const FeaturePtr& theFeature)
+{
+ static const std::string SKETCH("Sketch");
+ CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theFeature);
+ return anOwner && anOwner->getKind() == SKETCH;
+}
+
bool ModelHighAPI_Dumper::isDefaultColor(const ResultPtr& theResult) const
{
AttributeIntArrayPtr aColor = theResult->data()->intArray(ModelAPI_Result::COLOR_ID());
if (!aColor || !aColor->isInitialized())
return true;
+ // check the result belongs to sketch entity, do not dump color in this way
+ ResultConstructionPtr aResConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theResult);
+ if (aResConstr) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theResult->data()->owner());
+ if (isSketchSub(aFeature))
+ return true;
+ }
+
std::string aSection, aName, aDefault;
theResult->colorConfigInfo(aSection, aName, aDefault);
}
static int possibleSelectionsByPoint(const GeomPointPtr& thePoint,
- const GeomAPI_Shape::ShapeType& theType,
+ const ResultPtr& theResult,
+ const GeomShapePtr& theShape,
const FeaturePtr& theStartFeature,
const FeaturePtr& theEndFeature)
{
// collect the list of composite features, containing the last feature;
// these features should be excluded from searching,
// because the feature cannot select sub-shapes from its parent
- std::set<CompositeFeaturePtr> aEndFeatureParents;
- for (FeaturePtr aCurFeat = theEndFeature; aCurFeat;) {
- CompositeFeaturePtr aFoundComposite;
- const std::set<AttributePtr>& aRefs = aCurFeat->data()->refsToMe();
- for (std::set<AttributePtr>::const_iterator anIt = aRefs.begin();
- anIt != aRefs.end(); ++anIt) {
- FeaturePtr aF = ModelAPI_Feature::feature((*anIt)->owner());
- aFoundComposite = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aF);
- if (aFoundComposite && aFoundComposite->isSub(aCurFeat))
- break;
- else
- aFoundComposite = CompositeFeaturePtr();
- }
-
- if (aFoundComposite) {
- aEndFeatureParents.insert(aFoundComposite);
- aCurFeat = aFoundComposite;
- }
- else {
- // add the part containing high-level feature
- SessionPtr aSession = ModelAPI_Session::get();
- DocumentPtr aPartSetDoc = aSession->moduleDocument();
- std::list<FeaturePtr> aPartSetFeatures = aPartSetDoc->allFeatures();
- for (std::list<FeaturePtr>::const_iterator anIt = aPartSetFeatures.begin();
- anIt != aPartSetFeatures.end(); ++anIt) {
- aFoundComposite = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*anIt);
- if (aFoundComposite && aFoundComposite->isSub(aCurFeat)) {
- aEndFeatureParents.insert(aFoundComposite);
- break;
- }
- }
-
- aCurFeat = FeaturePtr();
- }
- }
+ std::set<FeaturePtr> aEndFeatureParents = ModelAPI_Tools::getParents(theEndFeature);
int aNbPossibleSelections = 0;
for (; aFIt != aFeatures.end() && *aFIt != theEndFeature; ++aFIt) {
isSkipFeature = true;
CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aFIt);
if (aCompFeat) {
- aLastCompositeFeature = aCompFeat;
- if (aEndFeatureParents.find(aLastCompositeFeature) != aEndFeatureParents.end()) {
+ ResultPartPtr aPartRes =
+ std::dynamic_pointer_cast<ModelAPI_ResultPart>(aCompFeat->firstResult());
+ if (!aPartRes)
+ aLastCompositeFeature = aCompFeat;
+ if (aEndFeatureParents.find(aCompFeat) != aEndFeatureParents.end()) {
// do not process the parent for the last feature,
// because it cannot select objects from its parent
isSkipFeature = true;
if (isSkipFeature)
continue;
- ResultPtr aResult;
- GeomShapePtr aSubshape;
- int theCenterType;
- if (ModelGeomAlgo_Shape::findSubshapeByPoint(*aFIt, thePoint, theType,
- aResult, aSubshape, theCenterType))
- ++aNbPossibleSelections;
+ std::list<ModelGeomAlgo_Shape::SubshapeOfResult> anApproproate;
+ if (ModelGeomAlgo_Shape::findSubshapeByPoint(*aFIt, thePoint, theShape->shapeType(),
+ anApproproate)) {
+ std::list<ModelGeomAlgo_Shape::SubshapeOfResult>::iterator anApIt = anApproproate.begin();
+ for (; anApIt != anApproproate.end(); ++anApIt) {
+ ++aNbPossibleSelections;
+
+ // stop if the target shape and result are found
+ GeomShapePtr aCurShape = anApIt->mySubshape;
+ if (!aCurShape)
+ aCurShape = anApIt->myResult->shape();
+
+ if (anApIt->myResult->isSame(theResult) && aCurShape->isSame(theShape))
+ break;
+ }
+ }
}
return aNbPossibleSelections;
}
FeaturePtr aSelectedFeature;
if (isDumpByGeom) {
ResultPtr aRes = theAttrSelect->context();
- if (aRes) {
+ FeaturePtr aFeature = theAttrSelect->contextFeature();
+ if (aRes && !aFeature)
aSelectedFeature = ModelAPI_Feature::feature(aRes->data()->owner());
- if (aSelectedFeature)
- isDumpByGeom = aSelectedFeature->isInHistory();
- }
+ isDumpByGeom = aSelectedFeature && aSelectedFeature->isInHistory();
+ }
+
+ if (theAttrSelect->isGeometricalSelection() && aShape->shapeType() == GeomAPI_Shape::COMPOUND) {
+ GeomAPI_ShapeIterator anIt(aShape);
+ aShape = anIt.current();
}
myDumpBuffer << "\"" << aShape->shapeTypeStr();
+ bool aStandardDump = true;
if (isDumpByGeom) {
// check the selected item is a ResultPart;
// in this case it is necessary to get shape with full transformation
// for correct calculation of the middle point
ResultPartPtr aResPart =
std::dynamic_pointer_cast<ModelAPI_ResultPart>(theAttrSelect->context());
- if (aResPart)
+ if (aResPart && aShape->shapeType() == GeomAPI_Shape::COMPOUND)
aShape = aResPart->shape();
GeomPointPtr aMiddlePoint = aShape->middlePoint();
// calculate number of features, which could be selected by the same point
FeaturePtr anOwner = ModelAPI_Feature::feature(theAttrSelect->owner());
- int aNbPossibleSelections =
- possibleSelectionsByPoint(aMiddlePoint, aShape->shapeType(), aSelectedFeature, anOwner);
+ int aNbPossibleSelections = possibleSelectionsByPoint(aMiddlePoint,
+ theAttrSelect->context(), aShape, aSelectedFeature, anOwner);
// produce the index if the number of applicable features is greater than 1
std::string anIndex;
anIndex = anOutput.str();
}
- myDumpBuffer << anIndex << "\", ";
- *this << aMiddlePoint;
+ myDumpBuffer << anIndex << "\", ("
+ << aMiddlePoint->x() << ", "
+ << aMiddlePoint->y() << ", "
+ << aMiddlePoint->z() << ")";
+ aStandardDump = false;
+ } else if (myWeakNamingSelection && aShape.get() && theAttrSelect->context().get() &&
+ aShape != theAttrSelect->context()->shape()) { // weak naming for local selection only
+ GeomAlgoAPI_NExplode aNExplode(theAttrSelect->context()->shape(), aShape->shapeType());
+ int anIndex = aNExplode.index(aShape);
+ if (anIndex != 0) { // found a week-naming index, so, export it
+ myDumpBuffer<<"\", \""<<
+ theAttrSelect->contextName(theAttrSelect->context())<<"\", "<<anIndex;
+ aStandardDump = false;
+ }
}
- else
+ if (aStandardDump)
myDumpBuffer << "\", \"" << theAttrSelect->namingName() << "\"";
myDumpBuffer << ")";
return *this;
