+// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include <HYDROData_Document.h>
#include <HYDROData_Application.h>
#include <HYDROData_Iterator.h>
#include <HYDROData_Tool.h>
+#include <HYDROData_InterpolatorsFactory.h>
#include <TDataStd_Integer.hxx>
+#include <TDataXtd_Position.hxx>
#include <TDF_Delta.hxx>
+#include <gp_Pnt.hxx>
+
#include <QFile>
#include <QStringList>
#include <QTextStream>
IMPLEMENT_STANDARD_HANDLE(HYDROData_Document,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Document,MMgt_TShared)
-#define PYTHON_DOC_NAME "doc"
+#define PYTHON_DOC_NAME "hydro_doc"
static const int UNDO_LIMIT = 10; // number of possible undo operations in the module
static const int TAG_PROPS_NEW_ID = 1; // general properties: tag for storage of the new object ID
static const int TAG_OBJECTS = 2; // tag of the objects sub-tree
static const int TAG_HISTORY = 3; // tag of the history sub-tree (Root for History)
+static const int TAG_LOCAL_CS = 4; // tag of local coordinate system information
+static const gp_Pnt2d DEFAULT_LOCAL_CS( 0, 0 );
using namespace std;
+typedef QMap<Standard_Integer,Handle_HYDROData_Entity> MapOfOrdered;
+typedef QMap<QString,Handle_HYDROData_Entity> MapOfUnordered;
+
Handle(HYDROData_Document) HYDROData_Document::Document(const int theStudyID)
{
Handle(HYDROData_Document) aResult =
HYDROData_Application::GetApplication()->RemoveDocument(this);
}
-bool HYDROData_Document::DumpToPython( const QString& theFileName ) const
+bool HYDROData_Document::DumpToPython( const QString& theFileName,
+ const bool theIsMultiFile ) const
{
// Try to open the file
QFile aFile( theFileName );
MapOfTreatedObjects aTreatedObjects;
// Dump header for python script
- QStringList aHeaderDump = DumpToPython( aTreatedObjects );
+ QStringList aHeaderDump = DumpToPython( aTreatedObjects, theIsMultiFile );
if ( aHeaderDump.isEmpty() )
return false;
bool aRes = true;
+ // Dump the local CS data to Python
+ UpdateLCSFields();
+ QString aLCS = QString( "%1.SetLocalCS( %2, %3 )" ).arg( GetDocPyName() ).arg( myLX ).arg( myLY );
+ if( theIsMultiFile )
+ aLCS.prepend( " " );
+ HYDROData_Tool::WriteStringsToFile( aFile, QStringList() << aLCS );
+
// Dump all model objects to Python script
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMAGE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_POLYLINEXY );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_BATHYMETRY );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_PROFILE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_POLYLINE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMMERSIBLE_ZONE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_STREAM );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_CHANNEL );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_DIGUE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_OBSTACLE );
- aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_CALCULATION );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_IMAGE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_POLYLINEXY );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_BATHYMETRY );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_PROFILE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_POLYLINE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_IMMERSIBLE_ZONE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_STREAM );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_CHANNEL );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_DIGUE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_OBSTACLE );
+ aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_CALCULATION );
+
+ // Dump code to close python fuction
+ if ( aRes && theIsMultiFile )
+ {
+ QStringList aFooterScript;
+ aFooterScript << QString( "" );
+ aFooterScript << QString( " pass" );
+ HYDROData_Tool::WriteStringsToFile( aFile, aFooterScript );
+ }
+
return aRes;
}
{
QString aDocName = PYTHON_DOC_NAME;
+ /*
int aDocId = 1;
if ( DocumentId( this, aDocId ) )
aDocName += "_" + QString::number( aDocId );
+ */
return aDocName;
}
-QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
+QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects,
+ const bool theIsMultiFile ) const
{
QString aDocName = GetDocPyName();
aResScript << QString( "from HYDROPy import *" );
aResScript << QString( "from PyQt4.QtCore import *" );
aResScript << QString( "from PyQt4.QtGui import *" );
- aResScript << QString( "" );
- aResScript << QString( "%1 = HYDROData_Document.Document( %2 );" ).arg( aDocName ).arg( aDocId );
+
+ if ( theIsMultiFile )
+ {
+ aResScript << QString( "import salome" );
+ aResScript << QString( "" );
+ aResScript << QString( "def RebuildData( theStudy ):" );
+ aResScript << QString( " %1 = HYDROData_Document.Document( theStudy._get_StudyId() );" ).arg( aDocName );
+ }
+ else
+ {
+ aResScript << QString( "" );
+ aResScript << QString( "%1 = HYDROData_Document.Document( theStudy._get_StudyId() );" ).arg( aDocName );
+ }
return aResScript;
}
bool HYDROData_Document::dumpPartitionToPython( QFile& theFile,
+ const bool theIsMultiFile,
MapOfTreatedObjects& theTreatedObjects,
const ObjectKind& theObjectKind ) const
{
theTreatedObjects.insert( anObjName, anObject );
QStringList anObjDump = anObject->DumpToPython( theTreatedObjects );
+
+ if ( theIsMultiFile )
+ {
+ // For multifile dump we use the function, see the document dump header
+ QStringList::iterator anIt = anObjDump.begin();
+ for ( ; anIt != anObjDump.end(); ++anIt )
+ anIt->prepend( " " );
+ }
HYDROData_Tool::WriteStringsToFile( theFile, anObjDump );
}
return aRes;
}
+bool takeLastDigits( QString& theStr, int& aRes )
+{
+ aRes = -1;
+
+ QString anStrNum;
+ for ( int i = theStr.length() - 1; i >= 0; --i )
+ {
+ const QChar& aChar = theStr.at( i );
+ if ( !aChar.isDigit() )
+ break;
+
+ anStrNum.prepend( aChar );
+ }
+
+ if ( anStrNum.isEmpty() )
+ return false;
+
+ theStr.remove( theStr.length() - anStrNum.length(), anStrNum.length() );
+ aRes = anStrNum.toInt();
+
+ return true;
+}
+
+bool isObjectNameLessThan( const QString& theStr1, const QString& theStr2 )
+{
+ QString aStr1 = theStr1, aStr2 = theStr2;
+
+ int aNum1 = -1, aNum2 = -1;
+ if ( takeLastDigits( aStr1, aNum1 ) && takeLastDigits( aStr2, aNum2 ) )
+ {
+ if ( aStr1 == aStr2 )
+ return aNum1 < aNum2;
+ }
+
+ return theStr1 < theStr2;
+}
+
+HYDROData_SequenceOfObjects HYDROData_Document::GetObjectsLayerOrder(
+ const Standard_Boolean theIsAll ) const
+{
+ HYDROData_SequenceOfObjects anOrder;
+
+ MapOfOrdered aMapOfOrdered;
+ MapOfUnordered aMapOfUnordered;
+
+ HYDROData_Iterator anIter( this );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ Handle(HYDROData_Entity) anObject = anIter.Current();
+ if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
+ continue;
+
+ Standard_Integer anObjZLevel = -1;
+ if ( anObject->GetZLevel( anObjZLevel ) )
+ {
+ aMapOfOrdered.insert( anObjZLevel, anObject );
+ }
+ else
+ {
+ QString anObjName = anObject->GetName();
+ if ( anObjName.isEmpty() )
+ continue;
+
+ aMapOfUnordered.insert( anObjName, anObject );
+ }
+ }
+
+ MapOfOrdered::const_iterator anOrderedMapIt = aMapOfOrdered.constBegin();
+ for ( ; anOrderedMapIt != aMapOfOrdered.constEnd(); anOrderedMapIt++ )
+ {
+ const Handle(HYDROData_Entity)& anObject = anOrderedMapIt.value();
+ anOrder.Prepend( anObject );
+ }
+
+ if ( theIsAll )
+ {
+ QStringList aSortedNames = aMapOfUnordered.keys();
+ qSort( aSortedNames.begin(), aSortedNames.end(), isObjectNameLessThan );
+
+ for ( int i = 0; i < aSortedNames.length(); ++i )
+ {
+ QString anObjName = aSortedNames.value( i );
+
+ const Handle(HYDROData_Entity)& anObject = aMapOfUnordered.value( anObjName );
+ anOrder.Append( anObject );
+ }
+ }
+
+ return anOrder;
+}
+
+void HYDROData_Document::SetObjectsLayerOrder( const HYDROData_SequenceOfObjects& theOrder )
+{
+ // At first we remove previous model order
+ RemoveObjectsLayerOrder();
+
+ // Make new objects order
+ Standard_Integer aLevel = 0;
+ for ( int i = theOrder.Length(), n = 1; i >= n; --i )
+ {
+ const Handle(HYDROData_Entity)& anObject = theOrder.Value( i );
+ if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
+ continue;
+
+ anObject->SetZLevel( aLevel++ );
+ }
+}
+
+void HYDROData_Document::Show( const Handle_HYDROData_Entity& theObject )
+{
+ HYDROData_SequenceOfObjects anOrder;
+ anOrder.Append( theObject );
+ Show( anOrder );
+}
+
+void HYDROData_Document::Show( const HYDROData_SequenceOfObjects& theObjects )
+{
+ MapOfUnordered aMapOfUnordered;
+
+ for ( int i = 1, n = theObjects.Length(); i <= n; ++i )
+ {
+ const Handle(HYDROData_Entity)& anObject = theObjects.Value( i );
+ if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
+ continue;
+
+ Standard_Integer anObjZLevel = -1;
+ if ( anObject->GetZLevel( anObjZLevel ) )
+ {
+ continue; // Skip objects that already have the z-level
+ }
+ else
+ {
+ QString anObjName = anObject->GetName();
+ if ( anObjName.isEmpty() )
+ continue;
+
+ aMapOfUnordered.insert( anObjName, anObject );
+ }
+ }
+
+ if ( aMapOfUnordered.isEmpty() )
+ return; // Nothing to show
+
+ Standard_Integer aTopId = 0;
+
+ HYDROData_SequenceOfObjects aModelOrder = GetObjectsLayerOrder( Standard_False );
+ if ( !aModelOrder.IsEmpty() )
+ {
+ const Handle(HYDROData_Entity)& anObject = aModelOrder.First();
+ anObject->GetZLevel( aTopId );
+ aTopId++;
+ }
+
+ aTopId += aMapOfUnordered.size() - 1;
+
+ QStringList aSortedNames = aMapOfUnordered.keys();
+ qSort( aSortedNames.begin(), aSortedNames.end(), isObjectNameLessThan );
+
+ for ( int i = 0; i < aSortedNames.length(); ++i )
+ {
+ QString anObjName = aSortedNames.value( i );
+
+ const Handle(HYDROData_Entity)& anObject = aMapOfUnordered.value( anObjName );
+ anObject->SetZLevel( aTopId-- );
+ }
+}
+
+void HYDROData_Document::RemoveObjectsLayerOrder()
+{
+ HYDROData_Iterator anIter( this );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ Handle(HYDROData_Entity) anObject = anIter.Current();
+ if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
+ continue;
+
+ anObject->RemoveZLevel();
+ }
+}
+
void HYDROData_Document::StartOperation()
{
myDoc->NewCommand();
myTransactionsAfterSave++;
}
-Handle(HYDROData_Entity) HYDROData_Document::CreateObject(const ObjectKind theKind)
+Handle(HYDROData_Entity) HYDROData_Document::CreateObject( const ObjectKind theKind )
{
- return HYDROData_Iterator::CreateObject(this, theKind);
+ return HYDROData_Iterator::CreateObject( this, theKind );
+}
+
+Handle(HYDROData_Entity) HYDROData_Document::FindObjectByName(
+ const QString& theName,
+ const ObjectKind theObjectKind ) const
+{
+ Handle(HYDROData_Entity) anObject;
+ if ( theName.isEmpty() )
+ return anObject;
+
+ QStringList aNamesList;
+ aNamesList << theName;
+
+ HYDROData_SequenceOfObjects aSeqOfObjs = FindObjectsByNames( aNamesList, theObjectKind );
+ if( aSeqOfObjs.IsEmpty() )
+ return anObject;
+
+ anObject = aSeqOfObjs.First();
+ return anObject;
+}
+
+HYDROData_SequenceOfObjects HYDROData_Document::FindObjectsByNames(
+ const QStringList& theNames,
+ const ObjectKind theObjectKind ) const
+{
+ HYDROData_SequenceOfObjects aResSeq;
+
+ QStringList aNamesList = theNames;
+
+ HYDROData_Iterator anIter( this, theObjectKind );
+ for( ; anIter.More(); anIter.Next() )
+ {
+ Handle(HYDROData_Entity) anObject = anIter.Current();
+ if( anObject.IsNull() )
+ continue;
+
+ QString anObjName = anObject->GetName();
+ if ( anObjName.isEmpty() || !aNamesList.contains( anObjName ) )
+ continue;
+
+ aResSeq.Append( anObject );
+
+ aNamesList.removeAll( anObjName );
+ if ( aNamesList.isEmpty() )
+ break;
+ }
+
+ return aResSeq;
}
HYDROData_Document::HYDROData_Document()
myDoc->SetUndoLimit(UNDO_LIMIT);
NewID(); // needed to have at least one attribute in initial document to avoid errors
myTransactionsAfterSave = 0;
+ myLX = -1;
+ myLY = -1;
+
+ myInterpolatorsFactory = 0;
}
HYDROData_Document::HYDROData_Document(const Handle(TDocStd_Document)& theDoc)
{
myDoc = theDoc;
myTransactionsAfterSave = 0;
+ myLX = -1;
+ myLY = -1;
+
+ myInterpolatorsFactory = 0;
}
HYDROData_Document::~HYDROData_Document()
{
return myDoc->Main().FindChild(TAG_OBJECTS);
}
+
+TDF_Label HYDROData_Document::LabelOfLocalCS() const
+{
+ return myDoc->Main().FindChild(TAG_LOCAL_CS);
+}
+
+void HYDROData_Document::GetLocalCS( double& theLX, double& theLY ) const
+{
+ TDF_Label aLocalCSLab = LabelOfLocalCS();
+
+ Handle( TDataXtd_Position ) aLocalCS;
+ if( aLocalCSLab.FindAttribute( TDataXtd_Position::GetID(), aLocalCS ) )
+ {
+ gp_Pnt aLocalCS3d = aLocalCS->GetPosition();
+ theLX = aLocalCS3d.X();
+ theLY = aLocalCS3d.Y();
+ }
+ else
+ {
+ theLX = DEFAULT_LOCAL_CS.X();
+ theLY = DEFAULT_LOCAL_CS.Y();
+ }
+}
+
+void HYDROData_Document::SetLocalCS( double theLX, double theLY )
+{
+ UpdateLCSFields();
+
+ // update the local CS data in attribute
+ TDF_Label aLocalCSLab = LabelOfLocalCS();
+ Handle( TDataXtd_Position ) aLocalCS;
+ if( !aLocalCSLab.FindAttribute( TDataXtd_Position::GetID(), aLocalCS ) )
+ aLocalCS = TDataXtd_Position::Set( aLocalCSLab );
+
+ gp_Pnt aLocalCS3d( theLX, theLY, 0 );
+ aLocalCS->SetPosition( aLocalCS3d );
+
+ // calculate delta for coordinates
+ double aDX = myLX - theLX;
+ double aDY = myLY - theLY;
+
+ // update the local CS data in internal fields
+ myLX = theLX;
+ myLY = theLY;
+
+ //update all objects in the document
+ HYDROData_Iterator anIterator( this, KIND_UNKNOWN );
+ for( ; anIterator.More(); anIterator.Next() )
+ anIterator.Current()->UpdateLocalCS( aDX, aDY );
+}
+
+void HYDROData_Document::UpdateLCSFields() const
+{
+ if( myLX >= 0 && myLY >= 0 )
+ return;
+
+ double aLX, aLY;
+ GetLocalCS( aLX, aLY );
+ HYDROData_Document* aThat = const_cast<HYDROData_Document*>( this );
+ aThat->myLX = aLX;
+ aThat->myLY = aLY;
+}
+
+void HYDROData_Document::Transform( double& X, double& Y, bool IsToLocalCS ) const
+{
+ UpdateLCSFields();
+ if( IsToLocalCS )
+ {
+ X -= myLX;
+ Y -= myLY;
+ }
+ else
+ {
+ X += myLX;
+ Y += myLY;
+ }
+}
+
+void HYDROData_Document::Transform( gp_Pnt& thePnt, bool IsToLocalCS ) const
+{
+ double X = thePnt.X();
+ double Y = thePnt.Y();
+ double Z = thePnt.Z();
+ Transform( X, Y, IsToLocalCS );
+ thePnt = gp_Pnt( X, Y, Z );
+}
+
+void HYDROData_Document::Transform( gp_XYZ& thePnt, bool IsToLocalCS ) const
+{
+ double X = thePnt.X();
+ double Y = thePnt.Y();
+ double Z = thePnt.Z();
+ Transform( X, Y, IsToLocalCS );
+ thePnt = gp_XYZ( X, Y, Z );
+}
+
+void HYDROData_Document::Transform( gp_XY& thePnt, bool IsToLocalCS ) const
+{
+ double X = thePnt.X();
+ double Y = thePnt.Y();
+ Transform( X, Y, IsToLocalCS );
+ thePnt = gp_XY( X, Y );
+}
+
+HYDROData_InterpolatorsFactory* HYDROData_Document::GetInterpolatorsFactory()
+{
+ if ( !myInterpolatorsFactory ) {
+ myInterpolatorsFactory = new HYDROData_InterpolatorsFactory();
+ }
+
+ return myInterpolatorsFactory;
+}
\ No newline at end of file