X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Placement.cpp;h=43b25be205b2270e3e0eec2bb0c5ce5d840f75c8;hb=530f5aff42069e844c4a4ef164088ea23ba0e2dd;hp=d9fe0ca5f35f7f7423a20973845475ecaf1fcde0;hpb=3874b57fe5aba25ff5aee2a07654fc23c1ee8eb0;p=modules%2Fshaper.git

diff --git a/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp b/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp
index d9fe0ca5f..43b25be20 100644
--- a/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp
+++ b/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp
@@ -8,11 +8,17 @@
 
 #include <ModelAPI_ResultConstruction.h>
 #include <ModelAPI_ResultBody.h>
+#include <ModelAPI_ResultPart.h>
 #include <ModelAPI_AttributeSelection.h>
+#include <ModelAPI_AttributeBoolean.h>
+#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_BodyBuilder.h>
 
+#include <GeomAPI_Edge.h>
 #include <GeomAPI_Face.h>
 #include <GeomAPI_Pln.h>
 #include <GeomAlgoAPI_Placement.h>
+#include <GeomAlgoAPI_Transform.h>
 
 #define _MODIFIEDF_TAG 1
 #define _MODIFIEDE_TAG 2
@@ -24,110 +30,175 @@ FeaturesPlugin_Placement::FeaturesPlugin_Placement()
 
 void FeaturesPlugin_Placement::initAttributes()
 {
-  data()->addAttribute(FeaturesPlugin_Placement::BASE_FACE_ID(), ModelAPI_AttributeSelection::type());
-  data()->addAttribute(FeaturesPlugin_Placement::ATTRACT_FACE_ID(), ModelAPI_AttributeSelection::type());
+
+  AttributeSelectionListPtr aSelection = 
+    std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(data()->addAttribute(
+    OBJECTS_LIST_ID(), ModelAPI_AttributeSelectionList::typeId()));
+  // extrusion works with faces always
+  aSelection->setSelectionType("SOLID");
+
+  data()->addAttribute(START_SHAPE_ID(), ModelAPI_AttributeSelection::typeId());
+  data()->addAttribute(END_SHAPE_ID(), ModelAPI_AttributeSelection::typeId());
+  data()->addAttribute(REVERSE_ID(), ModelAPI_AttributeBoolean::typeId());
+  data()->addAttribute(CENTERING_ID(), ModelAPI_AttributeBoolean::typeId());
 }
 
 void FeaturesPlugin_Placement::execute()
 {
-  // Verify the base face
-  std::shared_ptr<ModelAPI_AttributeSelection> aFaceRef = std::dynamic_pointer_cast<
-    ModelAPI_AttributeSelection>(data()->attribute(FeaturesPlugin_Placement::BASE_FACE_ID()));
-  if (!aFaceRef)
+  // Getting objects.
+  ListOfShape anObjects;
+  std::list<ResultPtr> aContextes;
+  AttributeSelectionListPtr anObjectsSelList = selectionList(OBJECTS_LIST_ID());
+  if(anObjectsSelList->size() == 0) {
     return;
+  }
+  for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) {
+    std::shared_ptr<ModelAPI_AttributeSelection> anObjectAttr = anObjectsSelList->value(anObjectsIndex);
+    std::shared_ptr<GeomAPI_Shape> anObject = anObjectAttr->value();
+    if(!anObject.get()) { // may be for not-activated parts
+      eraseResults();
+      return;
+    }
+    anObjects.push_back(anObject);
+    aContextes.push_back(anObjectAttr->context());
+  }
 
-  std::shared_ptr<GeomAPI_Shape> aBaseFace = 
-    std::dynamic_pointer_cast<GeomAPI_Shape>(aFaceRef->value());
-  if (!aBaseFace)
+  // Verify the start shape
+  AttributeSelectionPtr anObjRef = selection(START_SHAPE_ID());
+  if(!anObjRef) {
     return;
+  }
+  std::shared_ptr<GeomAPI_Shape> aStartShape = anObjRef->value();
+  if(!aStartShape) {
+    static const std::string aSelectionError = "Error: The start shape selection is bad.";
+    setError(aSelectionError);
+    return;
+  }
+
 
-  std::shared_ptr<GeomAPI_Shape> aBaseFaceContext;
-  ResultPtr aContextRes = aFaceRef->context();
-  if (aContextRes) {
-    if (aContextRes->groupName() == ModelAPI_ResultBody::group())
-      aBaseFaceContext = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aContextRes)->shape();
-    else if (aContextRes->groupName() == ModelAPI_ResultConstruction::group())
-      aBaseFaceContext = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContextRes)->shape();
+  std::shared_ptr<GeomAPI_Shape> aStartShapeContext;
+  ResultPtr aContextRes = anObjRef->context();
+  if (aContextRes.get()) {
+    aStartShapeContext = aContextRes->shape();
   }
-  if (!aBaseFaceContext) {
-    static const std::string aContextError = "The selection context is bad";
+  if(!aStartShapeContext.get()) {
+    static const std::string aContextError = "Error: The start shape selection context is bad.";
     setError(aContextError);
     return;
   }
 
-  // Verify the attractive face
-  aFaceRef = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(
-      data()->attribute(FeaturesPlugin_Placement::ATTRACT_FACE_ID()));
-
-  std::shared_ptr<GeomAPI_Shape> aSlaveObjectFace = 
-    std::dynamic_pointer_cast<GeomAPI_Shape>(aFaceRef->value());
-  if (!aSlaveObjectFace)
+  // Verify the end shape
+  anObjRef = selection(END_SHAPE_ID());
+  std::shared_ptr<GeomAPI_Shape> anEndShape = anObjRef->value();
+  if(!anEndShape) {
+    static const std::string aSelectionError = "Error: The end shape selection is bad.";
+    setError(aSelectionError);
     return;
+  }
 
-  std::shared_ptr<GeomAPI_Shape> aSlaveObject;
-  aContextRes = aFaceRef->context();
-  if (aContextRes) {
-    if (aContextRes->groupName() == ModelAPI_ResultBody::group())
-      aSlaveObject = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aContextRes)->shape();
-    else if (aContextRes->groupName() == ModelAPI_ResultConstruction::group())
-      aSlaveObject = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContextRes)->shape();
+  std::shared_ptr<GeomAPI_Shape> anEndShapeContext;
+  aContextRes = anObjRef->context();
+  if(aContextRes.get()) {
+    anEndShapeContext = aContextRes->shape();
   }
-  if (!aSlaveObject) {
-    static const std::string aContextError = "The selection context is bad";
+  if(!anEndShapeContext.get()) {
+    static const std::string aContextError = "Error: The end shape selection context is bad.";
     setError(aContextError);
     return;
   }
 
-  // Verify faces planarity
-  std::shared_ptr<GeomAPI_Face> aBaseFace1(new GeomAPI_Face(aBaseFace));
-  std::shared_ptr<GeomAPI_Face> aSlaveFace1(new GeomAPI_Face(aSlaveObjectFace));
-  if (!aBaseFace1->isPlanar() || !aSlaveFace1->isPlanar()) {
-    static const std::string aPlanarityError = "One of selected face is not planar";
-    setError(aPlanarityError);
-    return;
+  // Verify planarity of faces and linearity of edges
+  std::shared_ptr<GeomAPI_Shape> aShapes[2] = {aStartShape, anEndShape};
+  for (int i = 0; i < 2; i++) {
+    if (aShapes[i]->isFace()) {
+      std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(aShapes[i]));
+      if (!aFace->isPlanar()) {
+        static const std::string aPlanarityError = "Error: One of selected faces is not planar.";
+        setError(aPlanarityError);
+        return;
+      }
+    }
+    else if (aShapes[i]->isEdge()) {
+      std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(aShapes[i]));
+      if (!anEdge->isLine()) {
+        static const std::string aLinearityError = "Error: One of selected endges is not linear.";
+        setError(aLinearityError);
+        return;
+      }
+    }
   }
 
-  std::shared_ptr<GeomAPI_Pln> aBasePlane = aBaseFace1->getPlane();
-  std::shared_ptr<GeomAPI_Pln> aSlavePlane = aSlaveFace1->getPlane();
+  // Flags of the Placement
+  bool isReverse = boolean(REVERSE_ID())->value();
+  bool isCentering = boolean(CENTERING_ID())->value();
 
-  std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data());
-  GeomAlgoAPI_Placement aFeature(aSlaveObject, aSlavePlane, aBasePlane);
-  if(!aFeature.isDone()) {
-    static const std::string aFeatureError = "Placement algorithm failed";
+  // Getting transformation.
+  GeomAlgoAPI_Placement aPlacementAlgo(
+    aStartShapeContext, anEndShapeContext, aStartShape, anEndShape, isReverse, isCentering, true);
+  if(!aPlacementAlgo.isDone()) {
+    static const std::string aFeatureError = "Error: Placement algorithm failed.";
     setError(aFeatureError);
     return;
   }
-
-  // Check if shape is valid
-  if (aFeature.shape()->isNull()) {
-    static const std::string aShapeError = "Resulting shape is Null";
-    setError(aShapeError);
-    return;
+  std::shared_ptr<GeomAPI_Trsf> aTrsf = aPlacementAlgo.transformation();
+
+  // Applying transformation to each object.
+  int aResultIndex = 0;
+  std::list<ResultPtr>::iterator aContext = aContextes.begin();
+  for(ListOfShape::iterator anObjectsIt = anObjects.begin(); anObjectsIt != anObjects.end();
+      anObjectsIt++, aContext++) {
+
+    if ((*aContext)->groupName() == ModelAPI_ResultPart::group()) { // for part results just set transformation
+      ResultPartPtr anOrigin = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aContext);
+      ResultPartPtr aResultPart = document()->copyPart(anOrigin, data(), aResultIndex);
+      aResultPart->setTrsf(aContextRes, aTrsf);
+      setResult(aResultPart, aResultIndex);
+    } else {
+      std::shared_ptr<GeomAPI_Shape> aBaseShape = *anObjectsIt;
+      GeomAlgoAPI_Transform aTransformAlgo(aBaseShape, aTrsf);
+
+      // Checking that the algorithm worked properly.
+      if(!aTransformAlgo.isDone()) {
+        static const std::string aFeatureError = "Error: Transform algorithm failed.";
+        setError(aFeatureError);
+        break;
+      }
+      if(aTransformAlgo.shape()->isNull()) {
+        static const std::string aShapeError = "Error: Resulting shape is Null.";
+        setError(aShapeError);
+        break;
+      }
+      if(!aTransformAlgo.isValid()) {
+        std::string aFeatureError = "Error: Resulting shape is not valid.";
+        setError(aFeatureError);
+        break;
+      }
+
+      //LoadNamingDS
+      std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
+      LoadNamingDS(aTransformAlgo, aResultBody, aBaseShape);
+      setResult(aResultBody, aResultIndex);
+    }
+    aResultIndex++;
   }
-  if(!aFeature.isValid()) {
-    std::string aFeatureError = "Warning: resulting shape is not valid";
-    setError(aFeatureError);
-    return;
-  }  
-  //LoadNamingDS
-  LoadNamingDS(aFeature, aResultBody, aSlaveObject);
 
-  setResult(aResultBody);
+  // Remove the rest results if there were produced in the previous pass.
+  removeResults(aResultIndex);
 }
 
 //============================================================================
-void FeaturesPlugin_Placement::LoadNamingDS(
-    GeomAlgoAPI_Placement& theFeature,
-    std::shared_ptr<ModelAPI_ResultBody> theResultBody,
-    std::shared_ptr<GeomAPI_Shape> theSlaveObject)
+void FeaturesPlugin_Placement::LoadNamingDS(GeomAlgoAPI_Transform& theTransformAlgo,
+                                            std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+                                            std::shared_ptr<GeomAPI_Shape> theSlaveObject)
 {
   //load result
-  theResultBody->storeModified(theSlaveObject, theFeature.shape()); // the initial Slave, the resulting Slave
+  theResultBody->storeModified(theSlaveObject, theTransformAlgo.shape()); // the initial Slave, the resulting Slave
 
-  GeomAPI_DataMapOfShapeShape* aSubShapes = new GeomAPI_DataMapOfShapeShape();
-  theFeature.mapOfShapes(*aSubShapes);
+  std::shared_ptr<GeomAPI_DataMapOfShapeShape> aSubShapes = theTransformAlgo.mapOfSubShapes();
 
     // put modifed faces in DF
-  theResultBody->loadAndOrientModifiedShapes(theFeature.makeShape(), theSlaveObject, _FACE, _MODIFIEDF_TAG, *aSubShapes); 
-
+  std::string aModName = "Modified";
+  theResultBody->loadAndOrientModifiedShapes(&theTransformAlgo,
+                                             theSlaveObject, _FACE,
+                                             _MODIFIEDF_TAG, aModName, *aSubShapes.get());
 }