X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROCurveCreator%2FCurveCreator_Curve.cxx;h=129520136437240ed6e21fce61cf9ae439a34aad;hb=8edd427af3997521bda72ca3c416cc1d490565d5;hp=69b0c38d4fc207f525c5bbc4949f1ba4c95cdfd8;hpb=2686c62a9139e3b8f81549e62063500ca52a8163;p=modules%2Fhydro.git diff --git a/src/HYDROCurveCreator/CurveCreator_Curve.cxx b/src/HYDROCurveCreator/CurveCreator_Curve.cxx index 69b0c38d..12952013 100644 --- a/src/HYDROCurveCreator/CurveCreator_Curve.cxx +++ b/src/HYDROCurveCreator/CurveCreator_Curve.cxx @@ -23,25 +23,25 @@ #include "CurveCreator_Curve.hxx" #include "CurveCreator.hxx" +#include "CurveCreator_PosPoint.hxx" #include "CurveCreator_Section.hxx" #include "CurveCreator_Displayer.h" +#include "CurveCreator_Utils.h" #include #include #include -#include -#include #include #include #include #include #include #include -#include -#include #include +//#define AIS_CURVE_DISPLAY + //======================================================================= // function: Constructor // purpose: @@ -55,6 +55,9 @@ CurveCreator_Curve::CurveCreator_Curve( const CurveCreator::Dimension theDimensi myUndoDepth (-1), myOpLevel(0) { +#ifdef AIS_CURVE_DISPLAY + myAISCurve = new CurveCreator_AISCurve( this ); +#endif } //======================================================================= @@ -104,6 +107,19 @@ std::string CurveCreator_Curve::getUniqSectionName() const void CurveCreator_Curve::setDisplayer( CurveCreator_Displayer* theDisplayer ) { myDisplayer = theDisplayer; + +#ifdef AIS_CURVE_DISPLAY + myDisplayer->displayAIS( myAISCurve, false ); +#endif +} + +//======================================================================= +// function: getDisplayer +// purpose: get curve changes Displayer +//======================================================================= +CurveCreator_Displayer* CurveCreator_Curve::getDisplayer() +{ + return myDisplayer; } //======================================================================= @@ -170,74 +186,13 @@ std::vector CurveCreator_Curve::constructSection( { std::vector aSectionRepresentation; - CurveCreator::SectionType aSectType = getSectionType( theISection ); - int aSectSize = getNbPoints( theISection ); - bool aSectIsClosed = isClosed( theISection ); - - if( aSectType == CurveCreator::Polyline ) - { - int iPoint = 0; - for( ; iPoint < ( aSectSize - 1 ) ; iPoint++ ){ - Handle_AIS_Point anAISPnt = getAISPoint(theISection, iPoint); - aSectionRepresentation.push_back( anAISPnt ); - Handle_AIS_Line aLine = getAISLine( theISection, iPoint, iPoint+1 ); - aSectionRepresentation.push_back( aLine ); - } - if( aSectSize != 0 ){ - Handle_AIS_Point anAISPnt = getAISPoint(theISection, iPoint); - aSectionRepresentation.push_back( anAISPnt ); - if( isClosed(theISection) && ( aSectSize > 1 ) ){ - Handle_AIS_Line aLine = getAISLine( theISection, iPoint, 0 ); - aSectionRepresentation.push_back( aLine ); - } - } - } - else if( aSectType == CurveCreator::Spline ) - { - std::vector aPoints; - for( int iPoint = 0; iPoint < aSectSize; iPoint++ ) - { - Handle_AIS_Point anAISPnt = getAISPoint( theISection, iPoint ); - aSectionRepresentation.push_back( anAISPnt ); - - CurveCreator::Coordinates aCoords = getPoint( theISection, iPoint ); - double aX = aCoords[0]; - double aY = aCoords[1]; - double aZ = aCoords[2]; - aPoints.push_back( aX ); - aPoints.push_back( aY ); - } - - if( aSectSize > 1 ) - { - Handle(Geom_BSplineCurve) aBSplineCurve; - // fill array for algorithm by the received coordinates - int aLen = aPoints.size() / 2; - Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt (1, aLen); - std::vector::const_iterator aListIter = aPoints.begin(); - for (int ind = 1; ind <= aLen; ind++) { - gp_Pnt aPnt(gp::Origin()); - aPnt.SetX(*aListIter); - aListIter++; - aPnt.SetY(*aListIter); - aListIter++; - aPnt.SetZ(0); - aHCurvePoints->SetValue(ind, aPnt); - } - // compute BSpline - GeomAPI_Interpolate aGBC(aHCurvePoints, aSectIsClosed, gp::Resolution()); - aGBC.Perform(); - if (aGBC.IsDone()) { - aBSplineCurve = aGBC.Curve(); - } - TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSplineCurve ).Edge(); + TopoDS_Shape aShape; + CurveCreator_Utils::constructShape( this, theISection, aShape, aSectionRepresentation ); - TopoDS_Wire aWire = BRepBuilderAPI_MakeWire( anEdge ).Wire(); + AIS_Shape* anAISShape = new AIS_Shape( aShape ); + //aShape->SetSelectionMode( AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ) ); + aSectionRepresentation.push_back( anAISShape ); - Handle(AIS_Shape) aShape = new AIS_Shape( aWire ); - aSectionRepresentation.push_back( aShape ); - } - } return aSectionRepresentation; } @@ -339,11 +294,91 @@ void CurveCreator_Curve::getCoordinates( int theISection, int theIPoint, double& } } +//#define USE_COMPOUND void CurveCreator_Curve::redisplayCurve() { if( myDisplayer ) { - myDisplayer->erase(); - myDisplayer->display( constructWire() ); +#ifdef AIS_CURVE_DISPLAY + myDisplayer->redisplayAIS(myAISCurve, false); +#else + myDisplayer->erase( false ); +//#ifndef USE_COMPOUND + myDisplayer->display( constructWire(), true ); +//#else + /*std::vector anAISObjects = constructWire(); + int aSelMode = AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ); + Handle(AIS_InteractiveContext) aContext = myDisplayer->getAISContext(); + for( int i = 0 ; i < anAISObjects.size() ; i++ ){ + Handle_AIS_InteractiveObject anAISObject = anAISObjects[i]; + //anAISObject->SetSelectionMode( aSelMode ); + aContext->Display( anAISObject, Standard_False ); + //aContext->Display( anAISObject, 0, aSelMode, Standard_False, Standard_True ); + } + aContext->UpdateCurrentViewer(); + */ +//#endif +#endif + } +} + +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::moveSectionInternal(const int theISection, + const int theNewIndex) +{ + bool res = false; + if (theISection != theNewIndex) { + CurveCreator_Section *aSection = mySections.at(theISection); + + // Remove section + CurveCreator::Sections::iterator anIter = mySections.begin() + theISection; + + mySections.erase(anIter); + + // Insert section. + anIter = mySections.begin() + theNewIndex; + mySections.insert(anIter, aSection); + res = true; + } + return res; +} + +//======================================================================= +// function: moveSection +// purpose: +//======================================================================= +bool CurveCreator_Curve::moveSection(const int theISection, + const int theNewIndex) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::MoveSection, + theISection, theNewIndex); + } + + // Update the curve. + res = moveSectionInternal(theISection, theNewIndex); + finishOperation(); + return res; +} + +void CurveCreator_Curve::convert( const SectionToPointList& thePoints, + std::map< int, std::list >& theConvPoints ) +{ + theConvPoints.clear(); + + SectionToPointList::const_iterator anIt = thePoints.begin(), aLast = thePoints.end(); + std::list aPoints; + int aSectionId, aPointId; + for ( ; anIt != aLast; anIt++ ) { + aSectionId = anIt->first; + aPointId = anIt->second; + aPoints.clear(); + if ( theConvPoints.find( aSectionId ) != theConvPoints.end() ) + aPoints = theConvPoints[aSectionId]; + aPoints.push_back( aPointId ); + theConvPoints[aSectionId] = aPoints; } } @@ -401,7 +436,7 @@ bool CurveCreator_Curve::clearInternal() { // erase curve from the viewer if( myDisplayer ) - myDisplayer->erase(); + myDisplayer->erase( true ); // Delete all allocated data. int i = 0; const int aNbSections = getNbSections(); @@ -449,12 +484,13 @@ bool CurveCreator_Curve::joinInternal( const int theISectionTo, return res; } -//! Join range of sections to one section (join all sections if -1 is passed in one of arguments) +//! Join range of sections to one section (join all sections if -1 is passed in theISectionFrom argument) bool CurveCreator_Curve::join( const int theISectionTo, const int theISectionFrom ) { + //TODO bool res = false; - if (theISectionTo != theISectionFrom) { + if ( theISectionTo != theISectionFrom ) { startOperation(); if (addEmptyDiff()) myListDiffs.back().init(this, CurveCreator_Operation::Join, theISectionTo, theISectionFrom); @@ -583,7 +619,8 @@ int CurveCreator_Curve::getNbPoints( const int theISection ) const aNbCoords += mySections[i]->myPoints.size(); } } else { - aNbCoords = mySections.at(theISection)->myPoints.size(); + if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) ) + aNbCoords = mySections.at(theISection)->myPoints.size(); } return aNbCoords/myDimension; @@ -724,35 +761,35 @@ bool CurveCreator_Curve::setSectionType( const int theISection, /***********************************************/ //! For internal use only! Undo/Redo are not used here. -bool CurveCreator_Curve::addPointsInternal( const CurveCreator::Coordinates& theCoords, - const std::vector &theISections, - const std::vector &theIPnts ) +bool CurveCreator_Curve::addPointsInternal( const CurveCreator::SectionsMap &theSectionsMap ) { bool res = false; - if( (theCoords.size()/getDimension()) == theISections.size() == theIPnts.size() ) { - for( int ind = 0; ind < theISections.size(); ind++ ) { - int anISection = theISections.at(ind); - CurveCreator_Section *aSection = - (anISection == -1 ? mySections.back() : mySections.at(anISection)); - - if( aSection ) { - int anIPnt = theIPnts.at(ind); + CurveCreator::SectionsMap::const_iterator anIt = theSectionsMap.begin(); + CurveCreator_Section *aSection = 0; + for ( ; anIt != theSectionsMap.end(); anIt++ ) { + int anISection = anIt->first; + aSection = mySections.at(anISection); + if( aSection ) { + CurveCreator::PosPointsList aSectionPoints = anIt->second; + CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin(); + for( ; aPntIt != aSectionPoints.end(); aPntIt++ ){ + int anIPnt = (*aPntIt)->myID; + CurveCreator::Coordinates aCoords = (*aPntIt)->myCoords; CurveCreator::Coordinates::iterator anIterPosition; if(anIPnt == -1) anIterPosition = aSection->myPoints.end(); else anIterPosition = aSection->myPoints.begin() + toICoord(anIPnt); CurveCreator::Coordinates::const_iterator aFirstPosition = - theCoords.begin() + toICoord(ind); + aCoords.begin(); aSection->myPoints.insert(anIterPosition, - aFirstPosition, - aFirstPosition + getDimension()); - res = true; + aCoords.begin(), aCoords.end()); } + res = true; } - if(res) - redisplayCurve(); } + if(res) + redisplayCurve(); return res; } @@ -769,34 +806,48 @@ bool CurveCreator_Curve::addPoints( const CurveCreator::Coordinates& theCoords, // Set the difference. startOperation(); if (addEmptyDiff()) { + CurveCreator_ICurve::SectionToPointCoordsList aList; + aList.push_back(std::make_pair(std::make_pair(theISection, theIPnt), theCoords)); myListDiffs.back().init(this, CurveCreator_Operation::InsertPoints, - theCoords, theISection, theIPnt); + aList); } - std::vector anISections, anIPnts; - anISections.push_back( theISection ); - anIPnts.push_back( theIPnt ); - res = addPointsInternal( theCoords, anISections, anIPnts ); + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPoints; + CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theCoords ); + aPoints.push_back( aPosPoint ); + aSectionsMap[theISection] = aPoints; + + res = addPointsInternal( aSectionsMap ); + finishOperation(); return res; } //! For internal use only! Undo/Redo are not used here. -bool CurveCreator_Curve::setPointInternal( const int theISection, - const int theIPnt, - const CurveCreator::Coordinates& theNewCoords ) +bool CurveCreator_Curve::setPointInternal( const CurveCreator::SectionsMap &theSectionsMap ) { bool res = false; // Update the curve. - if (theNewCoords.size() == myDimension) { - CurveCreator_Section *aSection = mySections.at(theISection); - int i; - for (i = 0; i < myDimension; i++) { - aSection->myPoints.at(toICoord(theIPnt) + i) = theNewCoords[i]; + CurveCreator::SectionsMap::const_iterator anIt = theSectionsMap.begin(); + CurveCreator_Section *aSection = 0; + for ( ; anIt != theSectionsMap.end(); anIt++ ) { + int anISection = anIt->first; + aSection = mySections.at(anISection); + if( aSection ) { + CurveCreator::PosPointsList aSectionPoints = anIt->second; + CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin(); + for( ; aPntIt != aSectionPoints.end(); aPntIt++ ){ + int anIPnt = (*aPntIt)->myID; + CurveCreator::Coordinates aCoords = (*aPntIt)->myCoords; + for ( int i = 0; i < myDimension; i++) + aSection->myPoints.at(toICoord(anIPnt) + i) = aCoords[i]; + } + res = true; } - redisplayCurve(); - - res = true; } + if(res) + redisplayCurve(); + return res; } @@ -809,38 +860,90 @@ bool CurveCreator_Curve::setPoint( const int theISection, // Set the difference. startOperation(); if (addEmptyDiff()) { + CurveCreator_ICurve::SectionToPointCoordsList aList; + aList.push_back(std::make_pair(std::make_pair(theISection, theIPnt), theNewCoords)); myListDiffs.back().init(this, CurveCreator_Operation::SetCoordinates, - theNewCoords, theISection, theIPnt); + aList); } - res = setPointInternal( theISection, theIPnt, theNewCoords ); + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPoints; + CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theNewCoords ); + aPoints.push_back( aPosPoint ); + aSectionsMap[theISection] = aPoints; + + int aSize1 = getNbPoints( theISection ); + res = setPointInternal( aSectionsMap ); + int aSize2 = getNbPoints( theISection ); + + finishOperation(); + + return res; +} + +//! Set coordinates of specified points from different sections +bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::SetCoordinates, + theSectionToPntCoords); + } + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPosPoints; + CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt = + theSectionToPntCoords.begin(), aLast = theSectionToPntCoords.end(); + int aSectionId, aPointId; + for ( ; anIt != aLast; anIt++ ) { + aPosPoints.clear(); + aSectionId = anIt->first.first; + aPointId = anIt->first.second; + CurveCreator::Coordinates aNewCoords = anIt->second; + CurveCreator_PosPoint* aPosPoint = + new CurveCreator_PosPoint( aPointId, aNewCoords ); + if( aSectionsMap.find(aSectionId) != aSectionsMap.end() ) + aPosPoints = aSectionsMap[aSectionId]; + aPosPoints.push_back( aPosPoint ); + aSectionsMap[aSectionId] = aPosPoints; + + } + res = setPointInternal( aSectionsMap ); finishOperation(); return res; } //! For internal use only! Undo/Redo are not used here. -bool CurveCreator_Curve::removePointsInternal( const std::vector &theISections, - const std::vector &theIPnts ) +bool CurveCreator_Curve::removePointsInternal( const SectionToPointList &thePoints ) { bool res = false; - if( theISections.size() == theIPnts.size() ) { - for( int ind = 0; ind < theISections.size(); ind++ ) { - int anISection = theISections.at(ind); - CurveCreator_Section *aSection = mySections.at(anISection); - if( aSection ) { - int anIPnt = theIPnts.at(ind); + std::map > aConvPoints; + convert( thePoints, aConvPoints ); + std::map >::const_iterator anIt = aConvPoints.begin(), + aLast = aConvPoints.end(); + CurveCreator_Section *aSection = 0; + for ( ; anIt != aLast; anIt++ ) { + int aSectionId = anIt->first; + aSection = mySections.at(aSectionId); + if( aSection ) { + std::list aSectionPoints = anIt->second; + aSectionPoints.sort(); + std::list::const_reverse_iterator aPntIt = aSectionPoints.rbegin(); + for( ; aPntIt != aSectionPoints.rend(); aPntIt++ ){ + int aPntIndx = *aPntIt; CurveCreator::Coordinates::iterator aFirstPosition; - if(anIPnt == -1) - aFirstPosition = aSection->myPoints.end(); + if(aPntIndx == -1) + aFirstPosition = aSection->myPoints.end() - getDimension(); else - aFirstPosition = aSection->myPoints.begin() + toICoord(anIPnt); + aFirstPosition = aSection->myPoints.begin() + toICoord(aPntIndx); aSection->myPoints.erase( aFirstPosition, aFirstPosition + getDimension() ); res = true; } } - if(res) - redisplayCurve(); } + if(res) + redisplayCurve(); return res; } @@ -854,15 +957,29 @@ bool CurveCreator_Curve::removePoint( const int theISection, const int theIPnt ) myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints, theISection, theIPnt); } - std::vector anISections, anIPnts; - anISections.push_back( theISection ); - anIPnts.push_back( theIPnt ); - res = removePointsInternal( anISections, anIPnts ); + SectionToPointList aListOfSectionsToPoints; + aListOfSectionsToPoints.push_back(std::make_pair(theISection, theIPnt)); + res = removePointsInternal( aListOfSectionsToPoints ); finishOperation(); return res; } -//======================================================================= +//! Remove several points from different sections with given ids +bool CurveCreator_Curve::removeSeveralPoints( const SectionToPointList &theSectionToPntIDs) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints, + theSectionToPntIDs); + } + res = removePointsInternal( theSectionToPntIDs ); + finishOperation(); + return res; +} + + //======================================================================= // function: getCoordinates // purpose: //======================================================================= @@ -883,7 +1000,12 @@ CurveCreator::Coordinates CurveCreator_Curve::getPoint( const int theISection, //======================================================================= CurveCreator::Coordinates CurveCreator_Curve::getPoints( const int theISection ) const { - return mySections.at(theISection)->myPoints; + CurveCreator::Coordinates aCoords; + if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) ) + { + aCoords = mySections.at(theISection)->myPoints; + } + return aCoords; } @@ -902,3 +1024,11 @@ std::vector CurveCreator_Curve::constructWire() co } return aCurveRepresentation; } + +void CurveCreator_Curve::getPoint( const int theISection, const int theIPoint, + gp_Pnt& thePoint ) const +{ + double anX, anY, aZ; + getCoordinates( theISection, theIPoint, anX, anY, aZ ); + thePoint = gp_Pnt( anX, anY, aZ); +}