X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGeomAlgoAPI%2FGeomAlgoAPI_Placement.cpp;h=4e29cdb305d6df989964137f3b9a8ecbba547c9d;hb=f5c7bb3100ed321392da42f61c2ab505833ec61a;hp=b8718f938e7e6b2b83a6230a6b4f72ce89fbed8a;hpb=c852965b2300f81aea972fe2a8013f495c61cba3;p=modules%2Fshaper.git diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_Placement.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_Placement.cpp index b8718f938..4e29cdb30 100644 --- a/src/GeomAlgoAPI/GeomAlgoAPI_Placement.cpp +++ b/src/GeomAlgoAPI/GeomAlgoAPI_Placement.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + // File: GeomAlgoAPI_Placement.cpp // Created: 2 Dec 2014 // Author: Artem ZHIDKOV @@ -5,68 +7,214 @@ #include #include +#include +#include #include +#include +#include +#include #include #include #include #include #include +#include #include #include #include - GeomAlgoAPI_Placement::GeomAlgoAPI_Placement( - std::shared_ptr theAttractiveFace, - std::shared_ptr theSourcePlane, - std::shared_ptr theDestPlane) + std::shared_ptr theSourceSolid, + std::shared_ptr theDestSolid, + std::shared_ptr theSourceShape, + std::shared_ptr theDestShape, + bool theIsReverse, + bool theIsCentering, + bool theSimpleTransform) : myDone(false), - myShape(new GeomAPI_Shape()) + myShape(new GeomAPI_Shape()) { - build(theAttractiveFace, theSourcePlane, theDestPlane); + build(theSourceSolid, theDestSolid, theSourceShape, theDestShape, + theIsReverse, theIsCentering, theSimpleTransform); } void GeomAlgoAPI_Placement::build( - const std::shared_ptr& theAttractiveShape, - const std::shared_ptr& theSourcePlane, - const std::shared_ptr& theDestPlane) + const std::shared_ptr& theSourceSolid, + const std::shared_ptr& theDestSolid, + const std::shared_ptr& theSourceShape, + const std::shared_ptr& theDestShape, + bool theIsReverse, + bool theIsCentering, + bool theSimpleTransform) { - std::shared_ptr aSourceDir = theSourcePlane->direction(); - std::shared_ptr aSourceLoc = theSourcePlane->location(); - std::shared_ptr aDestDir = theDestPlane->direction(); - std::shared_ptr aDestLoc = theDestPlane->location(); + // Filling the parameters of the objects + static const int aNbObjects = 2; + gp_Pnt aSrcDstPoints[aNbObjects]; // points on the selected objects (0 - source, 1 - destination) + gp_Vec aSrcDstNormals[aNbObjects]; // normal vectors, if planar faces are selected + gp_Vec aSrcDstDirections[aNbObjects]; // directions of linear edges + bool hasNormal[aNbObjects]; + bool hasDirection[aNbObjects]; + std::shared_ptr aShapes[aNbObjects] = {theSourceShape, theDestShape}; + + for (int i = 0; i < aNbObjects; i++) { + if (aShapes[i]->isFace()) { + std::shared_ptr aFace(new GeomAPI_Face(aShapes[i])); + std::shared_ptr aPlane = aFace->getPlane(); + std::shared_ptr aDir = aPlane->direction(); + std::shared_ptr aLoc = aPlane->location(); + aSrcDstPoints[i].SetCoord(aLoc->x(), aLoc->y(), aLoc->z()); + aSrcDstNormals[i].SetCoord(aDir->x(), aDir->y(), aDir->z()); + } else if (aShapes[i]->isEdge()) { + std::shared_ptr anEdge(new GeomAPI_Edge(aShapes[i])); + std::shared_ptr aLine = anEdge->line(); + std::shared_ptr aDir = aLine->direction(); + std::shared_ptr aFirstPnt = anEdge->firstPoint(); + std::shared_ptr aLastPnt = anEdge->lastPoint(); + std::shared_ptr aLoc = aFirstPnt->xyz()->added(aLastPnt->xyz())->multiplied(0.5); + aSrcDstPoints[i].SetCoord(aLoc->x(), aLoc->y(), aLoc->z()); + aSrcDstDirections[i].SetCoord(aDir->x(), aDir->y(), aDir->z()); + } else if (aShapes[i]->isVertex()) { + std::shared_ptr aVertex(new GeomAPI_Vertex(aShapes[i])); + std::shared_ptr aPnt = aVertex->point(); + aSrcDstPoints[i].SetCoord(aPnt->x(), aPnt->y(), aPnt->z()); + } else // something goes wrong + return; + hasNormal[i] = aSrcDstNormals[i].SquareMagnitude() >= Precision::SquareConfusion(); + hasDirection[i] = aSrcDstDirections[i].SquareMagnitude() >= Precision::SquareConfusion(); + } + + // Initial shapes + const TopoDS_Shape& aSourceShape = theSourceSolid->impl(); + const TopoDS_Shape& aDestShape = theDestSolid->impl(); + // Check the material of the solids to be on the correct side + BRepClass3d_SolidClassifier aClassifier; + static const double aTransStep = 10. * Precision::Confusion(); + if (hasNormal[0]) { + aClassifier.Load(aSourceShape); + gp_Pnt aPoint = aSrcDstPoints[0]; + aPoint.Translate(aSrcDstNormals[0] * aTransStep); + aClassifier.Perform(aPoint, Precision::Confusion()); + if ((aClassifier.State() == TopAbs_OUT && !theIsReverse) || + (aClassifier.State() == TopAbs_IN && theIsReverse)) + aSrcDstNormals[0].Reverse(); + } + if (hasNormal[1]) { + aClassifier.Load(aDestShape); + gp_Pnt aPoint = aSrcDstPoints[1]; + aPoint.Translate(aSrcDstNormals[1] * aTransStep); + aClassifier.Perform(aPoint, Precision::Confusion()); + if (aClassifier.State() == TopAbs_IN) + aSrcDstNormals[1].Reverse(); + } + + // Calculate directions, which comply the normal, for vertices and edges + if (!hasNormal[0] || !hasNormal[1]) { + if (hasNormal[0] || hasNormal[1]) { // plane with line or vertex + if (hasDirection[0] || hasDirection[1]) { // plane - line + int anInd = hasDirection[0] ? 0 : 1; + gp_Vec aVec = aSrcDstNormals[1 - anInd].Crossed(aSrcDstDirections[anInd]); + if (aVec.SquareMagnitude() < Precision::SquareConfusion()) { // normal and direction are collinear + aVec = aSrcDstNormals[1 - anInd].Crossed( + gp_Vec(aSrcDstPoints[1 - anInd], aSrcDstPoints[anInd])); + if (aVec.SquareMagnitude() < Precision::SquareConfusion()) { // normal and points direction are collinear + if (Abs(aSrcDstNormals[1 - anInd].Y()) >= Precision::Confusion() || + Abs(aSrcDstNormals[1 - anInd].Z()) >= Precision::Confusion()) + aVec = gp::DX(); + else + aVec = gp::DY(); + } + } + aSrcDstNormals[anInd] = aSrcDstDirections[anInd].Crossed(aVec).Normalized(); + } else { // plane - point + int anInd = hasNormal[0] ? 1 : 0; + aSrcDstNormals[anInd] = aSrcDstNormals[1 - anInd]; + } + } else { + if (hasDirection[0] && hasDirection[1]) { // line - line + gp_Vec aVec = aSrcDstDirections[0].Crossed(aSrcDstDirections[1]); + if (aVec.SquareMagnitude() < Precision::SquareConfusion()) { // lines are parallel + aVec = aSrcDstDirections[0].Crossed(gp_Vec(aSrcDstPoints[0], aSrcDstPoints[1])); + if (aVec.SquareMagnitude() < Precision::SquareConfusion()) { // lines are equal + if (Abs(aSrcDstDirections[0].Y()) >= Precision::Confusion() || + Abs(aSrcDstDirections[0].Z()) >= Precision::Confusion()) + aVec = gp::DX(); + else + aVec = gp::DY(); + } + } + aSrcDstNormals[0] = aSrcDstDirections[0].Crossed(aVec); + aSrcDstNormals[0].Normalize(); + aSrcDstNormals[1] = aSrcDstDirections[1].Crossed(aVec); + aSrcDstNormals[1].Normalize(); + if (aSrcDstDirections[0].Dot(aSrcDstDirections[1]) < -Precision::Confusion()) + aSrcDstNormals[1].Reverse(); + } else if (!hasDirection[0] && !hasDirection[1]) { // point - point + aSrcDstNormals[0] = gp_Vec(aSrcDstPoints[0], aSrcDstPoints[1]); + aSrcDstNormals[0].Normalize(); + aSrcDstNormals[1] = -aSrcDstNormals[0]; + } else { // line - point + int anInd = hasDirection[0] ? 0 : 1; + gp_Vec aVec(aSrcDstPoints[anInd], aSrcDstPoints[1 - anInd]); + aVec.Cross(aSrcDstDirections[anInd]); + if (aVec.SquareMagnitude() < Precision::SquareConfusion()) { // point is on line + if (Abs(aSrcDstDirections[1 - anInd].Y()) >= Precision::Confusion() || + Abs(aSrcDstDirections[1 - anInd].Z()) >= Precision::Confusion()) + aVec = gp::DX(); + else + aVec = gp::DY(); + } + aSrcDstNormals[anInd] = aSrcDstDirections[anInd].Crossed(aVec).Normalized(); + aSrcDstNormals[1 - anInd] = aSrcDstNormals[anInd]; + } + } + } + + // Reverse the normal if it was not done before + if (!hasNormal[0] && theIsReverse) + aSrcDstNormals[0].Reverse(); // Calculate transformation gp_Trsf aTrsf; - gp_Vec aSrcDir(aSourceDir->x(), aSourceDir->y(), aSourceDir->z()); - gp_Vec aDstDir(aDestDir->x(), aDestDir->y(), aDestDir->z()); + gp_Vec aSrcDir = aSrcDstNormals[0]; + gp_Vec aDstDir = aSrcDstNormals[1]; + // Calculate rotation gp_Quaternion aRot(aSrcDir, aDstDir); - gp_Vec aTrans(aDestLoc->x() - aSourceLoc->x(), - aDestLoc->y() - aSourceLoc->y(), - aDestLoc->z() - aSourceLoc->z()); + aTrsf.SetRotation(aRot); + // Calculate translation + gp_Vec aSrcLoc(aSrcDstPoints[0].XYZ()); + gp_Vec aDstLoc(aSrcDstPoints[1].XYZ()); + if (!theIsCentering) + aDstLoc = aSrcLoc + gp_Vec(aDstDir) * (aDstLoc-aSrcLoc).Dot(aDstDir); + aSrcLoc.Transform(aTrsf); + gp_Vec aTrans = aDstLoc - aSrcLoc; aTrsf.SetTransformation(aRot, aTrans); - // Transform the shape with copying it - const TopoDS_Shape& aShape = theAttractiveShape->impl(); - BRepBuilderAPI_Transform* aBuilder = new BRepBuilderAPI_Transform(aShape, aTrsf, true); - if(aBuilder) { - setImpl(aBuilder); - myDone = aBuilder->IsDone() == Standard_True; - if (myDone) { - TopoDS_Shape aResult; - if(aBuilder->Shape().ShapeType() == TopAbs_COMPOUND) - aResult = GeomAlgoAPI_DFLoader::refineResult(aBuilder->Shape()); - else - aResult = aBuilder->Shape(); - // fill data map to keep correct orientation of sub-shapes - for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) { - std::shared_ptr aCurrentShape(new GeomAPI_Shape()); - aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current())); - myMap.bind(aCurrentShape, aCurrentShape); - } - myShape->setImpl(new TopoDS_Shape(aResult)); - myMkShape = new GeomAlgoAPI_MakeShape (aBuilder); + if (theSimpleTransform) { // just add transformation + TopLoc_Location aDelta(aTrsf); + TopoDS_Shape aResult = aSourceShape.Moved(aDelta); + myShape->setImpl(new TopoDS_Shape(aResult)); + // store the accumulated information about the result and this delta + //myTrsf = std::shared_ptr(new GeomAPI_Trsf(new gp_Trsf(aTrsf * aSourceShape.Location().Transformation()))); + myTrsf = std::shared_ptr(new GeomAPI_Trsf(new gp_Trsf(aTrsf))); + myDone = true; // it is allways true for simple transformation generation + } else { // internal rebuild of the shape + // Transform the shape with copying it + BRepBuilderAPI_Transform* aBuilder = new BRepBuilderAPI_Transform(aSourceShape, aTrsf, true); + if(aBuilder) { + setImpl(aBuilder); + myDone = aBuilder->IsDone() == Standard_True; + if (myDone) { + TopoDS_Shape aResult = aBuilder->Shape(); + // fill data map to keep correct orientation of sub-shapes + for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) { + std::shared_ptr aCurrentShape(new GeomAPI_Shape()); + aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current())); + myMap.bind(aCurrentShape, aCurrentShape); + } + myShape->setImpl(new TopoDS_Shape(aResult)); + myMkShape = new GeomAlgoAPI_MakeShape (aBuilder); + } } } } @@ -74,8 +222,11 @@ void GeomAlgoAPI_Placement::build( //============================================================================ const bool GeomAlgoAPI_Placement::isValid() const { - BRepCheck_Analyzer aChecker(myShape->impl()); - return (aChecker.IsValid() == Standard_True); + if (myShape.get()) { // only for not-simple transform + BRepCheck_Analyzer aChecker(myShape->impl()); + return (aChecker.IsValid() == Standard_True); + } + return true; } //============================================================================ @@ -110,9 +261,14 @@ GeomAlgoAPI_MakeShape * GeomAlgoAPI_Placement::makeShape() const return myMkShape; } +std::shared_ptr GeomAlgoAPI_Placement::transformation() const +{ + return myTrsf; +} + //============================================================================ GeomAlgoAPI_Placement::~GeomAlgoAPI_Placement() { - if (myImpl) + if (!empty()) myMap.clear(); -} \ No newline at end of file +}