#include "CurveCreator_Curve.hxx"
#include "CurveCreator.hxx"
+#include "CurveCreator_PosPoint.hxx"
#include "CurveCreator_Section.hxx"
#include "CurveCreator_Displayer.h"
+#include "CurveCreator_Utils.h"
-#include <AIS_Point.hxx>
-#include <AIS_Line.hxx>
#include <AIS_Shape.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
-#include <BRepBuilderAPI_MakeWire.hxx>
+#include <AIS_InteractiveObject.hxx>
#include <Geom_CartesianPoint.hxx>
#include <gp_Pnt.hxx>
#include <gp_Lin.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
-#include <TColgp_HArray1OfPnt.hxx>
-#include <GeomAPI_Interpolate.hxx>
#include <stdio.h>
: myIsLocked (false),
myDimension (theDimension),
myDisplayer (NULL),
+ myAISShape (NULL),
myNbUndos (0),
myNbRedos (0),
myUndoDepth (-1),
- myOpLevel(0)
+ myOpLevel(0),
+ mySkipSorting(false)
{
}
myDisplayer = theDisplayer;
}
+//=======================================================================
+// function: getDisplayer
+// purpose: get curve changes Displayer
+//=======================================================================
+CurveCreator_Displayer* CurveCreator_Curve::getDisplayer()
+{
+ return myDisplayer;
+}
+
//=======================================================================
// function: removeDisplayer
// purpose: remove the attached Displayer
return theIPnt * myDimension;
}
-std::vector<Handle_AIS_InteractiveObject> CurveCreator_Curve::constructSection( int theISection ) const
-{
- std::vector<Handle_AIS_InteractiveObject> 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<double> 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<double>::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_Wire aWire = BRepBuilderAPI_MakeWire( anEdge ).Wire();
-
- Handle(AIS_Shape) aShape = new AIS_Shape( aWire );
- aSectionRepresentation.push_back( aShape );
- }
- }
- return aSectionRepresentation;
-}
-
//=======================================================================
// function: setUndoDepth
// purpose:
return myUndoDepth;
}
-Handle_AIS_Point CurveCreator_Curve::getAISPoint( int theISection, int theIPoint ) const
-{
- double anX, anY, aZ;
- getCoordinates( theISection, theIPoint, anX, anY, aZ );
- gp_Pnt aPoint( anX, anY, aZ);
-
- AIS_Point* aPnt = new AIS_Point( new Geom_CartesianPoint(aPoint));
- return aPnt;
-}
-
-Handle_AIS_Line CurveCreator_Curve::getAISLine( int theISection, int theIPoint1, int theIPoint2 ) const
-{
- double anX, anY, aZ;
- getCoordinates( theISection, theIPoint1, anX, anY, aZ );
- gp_Pnt aPoint1( anX, anY, aZ);
-
- double anX2, anY2, aZ2;
- getCoordinates( theISection, theIPoint2, anX2, anY2, aZ2 );
-//MTN to avoid crash during line construction
- if( ( anX == anX2 ) && ( anY == anY2 ) && (aZ == aZ2 ) ){
- aZ2 += 1e-7;
- }
-
- gp_Pnt aPoint2( anX2, anY2, aZ2 );
-
- AIS_Line* aLine = new AIS_Line( new Geom_CartesianPoint(aPoint1), new Geom_CartesianPoint(aPoint2) );
- return aLine;
-}
-
void CurveCreator_Curve::getCoordinates( int theISection, int theIPoint, double& theX, double& theY, double& theZ ) const
{
CurveCreator::Coordinates aCoords = getPoint( theISection, theIPoint );
void CurveCreator_Curve::redisplayCurve()
{
if( myDisplayer ) {
- myDisplayer->erase();
- myDisplayer->display( constructWire() );
+ myDisplayer->eraseAll( false );
+ myAISShape = NULL;
+
+ myDisplayer->display( getAISObject( true ), true );
}
}
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::moveSectionInternal(const int theISection,
+ const int theNewIndex)
+{
+ bool res = false;
+ int aMovedSectionId = theISection >= 0 ? theISection : mySections.size()-1;
+
+ if (aMovedSectionId != theNewIndex) {
+ CurveCreator_Section *aSection = mySections.at(aMovedSectionId);
+
+ // Remove section
+ CurveCreator::Sections::iterator anIter = mySections.begin() + aMovedSectionId;
+
+ 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;
+}
+
/************ Implementation of INTERFACE methods ************/
/***********************************************/
/***********************************************/
/*** Section methods ***/
/***********************************************/
-//=======================================================================
-// function: clear
-// purpose:
-//=======================================================================
-bool CurveCreator_Curve::clear()
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::clearInternal()
{
// erase curve from the viewer
- if( myDisplayer )
- myDisplayer->erase();
+ if( myDisplayer ) {
+ myDisplayer->eraseAll( true );
+ myAISShape = NULL;
+ }
// Delete all allocated data.
int i = 0;
const int aNbSections = getNbSections();
return true;
}
-//! Join range of sections to one section (join all sections if -1 is passed in one of arguments)
-bool CurveCreator_Curve::join( const int theISectionTo,
- const int theISectionFrom )
+//=======================================================================
+// function: clear
+// purpose:
+//=======================================================================
+bool CurveCreator_Curve::clear()
{
- if (theISectionTo != theISectionFrom) {
- startOperation();
- if (addEmptyDiff())
- myListDiffs.back().init(this, CurveCreator_Operation::Join, theISectionTo, theISectionFrom);
+ bool res = false;
+ startOperation();
+ // Set the difference.
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this);
+ }
+ res = clearInternal();
+ finishOperation();
+ return res;
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::joinInternal( const std::list<int>& theSections )
+{
+ bool res = false;
+ if ( theSections.empty() )
+ return res;
+
+ int anISectionMain = theSections.front();
+ CurveCreator_Section* aSectionMain = mySections.at( anISectionMain );
+ std::list <int> aSectionsToJoin = theSections;
+ aSectionsToJoin.erase( aSectionsToJoin.begin() ); // skip the main section
+ // it is important to sort and reverse the section ids in order to correctly remove them
+ aSectionsToJoin.sort();
+ aSectionsToJoin.reverse();
+
+ std::list<int>::const_iterator anIt = aSectionsToJoin.begin(), aLast = aSectionsToJoin.end();
+ CurveCreator_Section* aSection;
+ for (; anIt != aLast; anIt++) {
+ aSection = mySections.at(*anIt);
+ aSectionMain->myPoints.insert(aSectionMain->myPoints.end(), aSection->myPoints.begin(),
+ aSection->myPoints.end());
+ res = removeSectionInternal(*anIt);
+ if ( !res )
+ break;
+ }
+
+ redisplayCurve();
+ return res;
+}
- CurveCreator_Section *aSection1 = mySections.at(theISectionTo);
- CurveCreator_Section *aSection2 = mySections.at(theISectionFrom);
+bool CurveCreator_Curve::join( const std::list<int>& theSections )
+{
+ bool res = false;
- aSection1->myPoints.insert(aSection1->myPoints.end(),
- aSection2->myPoints.begin(),
- aSection2->myPoints.end());
+ if ( !theSections.empty() )
+ {
+ startOperation();
+ if (addEmptyDiff())
+ myListDiffs.back().init(this, CurveCreator_Operation::Join, theSections);
- removeSection(theISectionFrom);
- redisplayCurve();
+ res = joinInternal( theSections );
finishOperation();
- return true;
}
- return false;
+ return res;
}
//! Get number of sections
return mySections.size();
}
+//! For internal use only! Undo/Redo are not used here.
+int CurveCreator_Curve::addSectionInternal
+ (const std::string& theName, const CurveCreator::SectionType theType,
+ const bool theIsClosed, const CurveCreator::Coordinates &thePoints)
+{
+ CurveCreator_Section *aSection = new CurveCreator_Section;
+
+ std::string aName = theName;
+ if( aName.empty() ){
+ aName = getUniqSectionName();
+ }
+ aSection->myName = aName;
+ aSection->myType = theType;
+ aSection->myIsClosed = theIsClosed;
+ aSection->myPoints = thePoints;
+ mySections.push_back(aSection);
+ redisplayCurve();
+ return mySections.size()-1;
+}
+
//=======================================================================
// function: addSection
// purpose: adds an empty section
int resISection = -1;
// Set the difference.
startOperation();
+ CurveCreator::Coordinates aCoords; //empty list
if (addEmptyDiff()) {
- CurveCreator::Coordinates aCoords; //empty list
myListDiffs.back().init(this, CurveCreator_Operation::AddSection,
theName, aCoords, theType, theIsClosed);
}
- CurveCreator_Section *aSection = new CurveCreator_Section;
- std::string aName = theName;
- if( aName.empty() ){
- aName = getUniqSectionName();
- }
- aSection->myName = aName;
- aSection->myType = theType;
- aSection->myIsClosed = theIsClosed;
- mySections.push_back(aSection);
- redisplayCurve();
+ resISection = addSectionInternal(theName, theType, theIsClosed, aCoords);
finishOperation();
- return mySections.size()-1;
+ return resISection;
}
//=======================================================================
// function: addSection
const bool theIsClosed, const CurveCreator::Coordinates &thePoints)
{
int resISection = -1;
- //// Set the difference.
- //startOperation();
- //if (addEmptyDiff()) {
- // myListDiffs.back().init(this, CurveCreator_Operation::AddSection,
- // theName, thePoints, theType, theIsClosed);
- //}
-
- // create an empty section
- resISection = addSection(theName, theType, theIsClosed);
- if( resISection != -1 ) {
- // attach the given points to created section
- CurveCreator_Section *aSection = mySections.at(resISection);
- aSection->myPoints = thePoints;
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, CurveCreator_Operation::AddSection,
+ theName, thePoints, theType, theIsClosed);
}
-
- //finishOperation();
+
+ resISection = addSectionInternal(theName, theType, theIsClosed, thePoints);
+
+ finishOperation();
return resISection;
}
-//! Removes the given sections.
-bool CurveCreator_Curve::removeSection( const int theISection )
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::removeSectionInternal( const int theISection )
{
- // Set the difference.
- startOperation();
- if (addEmptyDiff())
- myListDiffs.back().init(this, CurveCreator_Operation::RemoveSection, theISection);
-
if (theISection == -1) {
delete mySections.back();
mySections.pop_back();
mySections.erase(anIterRm);
}
redisplayCurve();
+ return true;
+}
+
+//! Removes the given sections.
+bool CurveCreator_Curve::removeSection( const int theISection )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff())
+ myListDiffs.back().init(this, CurveCreator_Operation::RemoveSection, theISection);
+
+ res = removeSectionInternal( theISection );
finishOperation();
- return true;
+ return res;
}
/**
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;
}
+void CurveCreator_Curve::setSkipSorting( const bool theIsToSkip )
+{
+ mySkipSorting = theIsToSkip;
+}
+
+bool CurveCreator_Curve::canPointsBeSorted()
+{
+ return false;
+}
+
+/**
+ * Saves points coordinates difference.
+ * \param theOldCoords the old points coordinates
+ */
+void CurveCreator_Curve::saveCoordDiff( const SectionToPointCoordsList &theOldCoords )
+{
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, theOldCoords);
+ }
+ finishOperation();
+}
+
//! Get "closed" flag of the specified section
bool CurveCreator_Curve::isClosed( const int theISection ) const
{
return mySections.at(theISection)->myIsClosed;
}
-/**
- * Set "closed" flag of the specified section (all sections if
- * \a theISection is -1).
- */
-bool CurveCreator_Curve::setClosed( const int theISection,
- const bool theIsClosed )
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::setClosedInternal( const int theISection,
+ const bool theIsClosed )
{
if (theISection == -1) {
int aSize = mySections.size();
return true;
}
-//! Returns specifyed section name
+/**
+ * Set "closed" flag of the specified section (all sections if
+ * \a theISection is -1).
+ */
+bool CurveCreator_Curve::setClosed( const int theISection,
+ const bool theIsClosed )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, CurveCreator_Operation::SetClosed,
+ theIsClosed, theISection);
+ }
+ res = setClosedInternal( theISection, theIsClosed );
+ finishOperation();
+ return res;
+}
+
+//! Returns specified section name
std::string CurveCreator_Curve::getSectionName( const int theISection ) const
{
if( ( theISection >= 0 ) && ( theISection < mySections.size() ))
return "";
}
-/** Set name of the specified section */
-bool CurveCreator_Curve::setSectionName
- ( const int theISection, const std::string& theName )
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::setSectionNameInternal( const int theISection,
+ const std::string& theName )
{
+ bool res = false;
if( ( theISection >= 0 ) && ( theISection < mySections.size() )){
mySections.at(theISection)->myName = theName;
- return true;
+ res = true;
}
- return false;
+ return res;
+}
+
+/** Set name of the specified section */
+bool CurveCreator_Curve::setSectionName( const int theISection,
+ const std::string& theName )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, CurveCreator_Operation::RenameSection,
+ theName, theISection);
+ }
+ res = setSectionNameInternal( theISection, theName );
+ finishOperation();
+ return res;
}
//! Get type of the specified section
return mySections.at(theISection)->myType;
}
-/**
- * Set type of the specified section (or all sections
- * if \a theISection is -1).
- */
-bool CurveCreator_Curve::setSectionType( const int theISection,
- const CurveCreator::SectionType theType )
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::setSectionTypeInternal( const int theISection,
+ const CurveCreator::SectionType theType )
{
if (theISection == -1) {
int i = 0;
return true;
}
+/**
+ * Set type of the specified section (or all sections
+ * if \a theISection is -1).
+ */
+bool CurveCreator_Curve::setSectionType( const int theISection,
+ const CurveCreator::SectionType theType )
+{
+ bool res = false;
+ startOperation();
+ // Set the difference.
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, CurveCreator_Operation::SetType,
+ theType, theISection);
+ }
+
+ res = setSectionTypeInternal( theISection, theType );
+
+ finishOperation();
+ return res;
+}
+
/***********************************************/
/*** Point methods ***/
/***********************************************/
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::addPointsInternal( const CurveCreator::SectionsMap &theSectionsMap )
+{
+ bool res = false;
+ 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 =
+ aCoords.begin();
+ aSection->myPoints.insert(anIterPosition,
+ aCoords.begin(), aCoords.end());
+ }
+ res = true;
+ }
+ }
+ if(res)
+ redisplayCurve();
+ return res;
+}
+
/**
* Add one point to the specified section starting from the given theIPnt index
* (or at the end of points if \a theIPnt is -1).
// Set the difference.
startOperation();
if (addEmptyDiff()) {
- myListDiffs.back().init(this, CurveCreator_Operation::AddPoints,
- theCoords, theISection);
- }
- CurveCreator_Section *aSection =
- (theISection == -1 ? mySections.back() : mySections.at(theISection));
-
- if( aSection ) {
- int anICoord = ( theIPnt == -1 ? 0 : toICoord(theIPnt) );
- CurveCreator::Coordinates::iterator anIterPosition = aSection->myPoints.end();
- if( theIPnt != -1 )
- anIterPosition = aSection->myPoints.begin() + toICoord(theIPnt);
- aSection->myPoints.insert(anIterPosition,
- theCoords.begin(), theCoords.end());
- redisplayCurve();
- res = true;
+ CurveCreator_ICurve::SectionToPointCoordsList aList;
+ aList.push_back(std::make_pair(std::make_pair(theISection, theIPnt), theCoords));
+ myListDiffs.back().init(this, CurveCreator_Operation::InsertPoints,
+ aList);
}
+ 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;
}
- //! Set coordinates of specified point
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::setPointInternal( const CurveCreator::SectionsMap &theSectionsMap )
+{
+ bool res = false;
+ // Update the curve.
+ 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;
+ }
+ }
+ if(res)
+ redisplayCurve();
+
+ return res;
+}
+
+//! Set coordinates of specified point
bool CurveCreator_Curve::setPoint( const int theISection,
const int theIPnt,
const CurveCreator::Coordinates& theNewCoords )
{
+ bool res = false;
// 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);
}
+ CurveCreator::SectionsMap aSectionsMap;
+ CurveCreator::PosPointsList aPoints;
+ CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theNewCoords );
+ aPoints.push_back( aPosPoint );
+ aSectionsMap[theISection] = aPoints;
- bool res = false;
+ int aSize1 = getNbPoints( theISection );
+ res = setPointInternal( aSectionsMap );
+ int aSize2 = getNbPoints( theISection );
- // 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];
- }
- redisplayCurve();
+ finishOperation();
+
+ return res;
+}
+
+//! Set coordinates of specified points from different sections
+bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords,
+ const bool theIsToSaveDiff )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+ if (theIsToSaveDiff && 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 = true;
}
-
+ res = setPointInternal( aSectionsMap );
finishOperation();
return res;
}
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::removePointsInternal( const SectionToPointList &thePoints )
+{
+ bool aRes = false;
+ std::map<int, std::list<int> > aConvPoints;
+ convert( thePoints, aConvPoints );
+ std::map<int, std::list<int> >::const_iterator anIt = aConvPoints.begin(),
+ aLast = aConvPoints.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ int aSectionId = anIt->first;
+ aRes = removeSectionPoints(aSectionId, anIt->second);
+ }
+ if( aRes)
+ redisplayCurve();
+
+ return aRes;
+}
+
//! Remove point with given id
bool CurveCreator_Curve::removePoint( const int theISection, const int theIPnt )
{
bool res = false;
// Set the difference.
startOperation();
+ SectionToPointList aListOfSectionsToPoints;
+ aListOfSectionsToPoints.push_back(std::make_pair(theISection, theIPnt));
if (addEmptyDiff()) {
myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints,
- theISection, theIPnt, 0);
+ aListOfSectionsToPoints);
}
- CurveCreator_Section *aSection = mySections.at(theISection);
- if( aSection ) {
- CurveCreator::Coordinates::iterator anIterPosition =
- aSection->myPoints.begin() + toICoord(theIPnt);
- aSection->myPoints.erase( anIterPosition );
- redisplayCurve();
- res = true;
+ 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:
//=======================================================================
//=======================================================================
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;
}
+void CurveCreator_Curve::constructAISObject()
+{
+ TopoDS_Shape aShape;
+ CurveCreator_Utils::constructShape( this, aShape );
-/***********************************************/
-/*** Presentation methods ***/
-/***********************************************/
-std::vector<Handle_AIS_InteractiveObject> CurveCreator_Curve::constructWire() const
-{
- std::vector<Handle_AIS_InteractiveObject> aCurveRepresentation;
- std::vector<Handle_AIS_InteractiveObject> aSectionObjects;
- for( int iSection = 0 ; iSection < getNbSections() ; iSection++ ){
- aSectionObjects = constructSection( iSection );
- for( int iObject = 0 ; iObject < aSectionObjects.size() ; iObject++ ){
- aCurveRepresentation.push_back( aSectionObjects.at(iObject) );
- }
+ myAISShape = new AIS_Shape( aShape );
+}
+
+Handle(AIS_InteractiveObject) CurveCreator_Curve::getAISObject( const bool theNeedToBuild ) const
+{
+ if ( !myAISShape && theNeedToBuild ) {
+ CurveCreator_Curve* aCurve = (CurveCreator_Curve*)this;
+ aCurve->constructAISObject();
+ }
+ return myAISShape;
+}
+
+bool CurveCreator_Curve::removeSectionPoints( const int theSectionId,
+ const std::list<int>& thePointIds )
+{
+ bool aRes = false;
+
+ CurveCreator_Section *aSection = mySections.at( theSectionId );
+ if ( !aSection )
+ return aRes;
+
+ std::list<int> aSectionPoints = thePointIds;
+ aSectionPoints.sort();
+ std::list<int>::const_reverse_iterator aPntIt = aSectionPoints.rbegin();
+ for ( ; aPntIt != aSectionPoints.rend(); aPntIt++ ) {
+ int aPntIndx = *aPntIt;
+ CurveCreator::Coordinates::iterator aFirstPosition;
+ if ( aPntIndx == -1 )
+ aFirstPosition = aSection->myPoints.end() - getDimension();
+ else
+ aFirstPosition = aSection->myPoints.begin() + toICoord( aPntIndx );
+ aSection->myPoints.erase( aFirstPosition, aFirstPosition + getDimension() );
+ aRes = true;
+ }
+ return aRes;
+}
+
+void CurveCreator_Curve::convert( const SectionToPointList& thePoints,
+ std::map< int, std::list<int> >& theConvPoints )
+{
+ theConvPoints.clear();
+
+ SectionToPointList::const_iterator anIt = thePoints.begin(), aLast = thePoints.end();
+ std::list<int> 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;
}
- return aCurveRepresentation;
}