LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_ShapesGroup.cc)
SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_ShapesGroup.cc)
- LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_SplittedShapesGroup.cc)
- SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_SplittedShapesGroup.cc)
+ LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_SplitShapesGroup.cc)
+ SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyHYDROData_SplitShapesGroup.cc)
LIST(APPEND _output ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyTCollection_AsciiString.cc)
SET(${outfiles} ${${outfiles}} ${CMAKE_CURRENT_BINARY_DIR}/sipHYDROPyTCollection_AsciiString.cc)
HYDROData_River.h
HYDROData_ShapesGroup.h
HYDROData_ShapesTool.h
- HYDROData_SplittedShapesGroup.h
+ HYDROData_SplitShapesGroup.h
HYDROData_SplitToZonesTool.h
HYDROData_Stream.h
HYDROData_StreamAltitude.h
HYDROData_River.cxx
HYDROData_ShapesGroup.cxx
HYDROData_ShapesTool.cxx
- HYDROData_SplittedShapesGroup.cxx
+ HYDROData_SplitShapesGroup.cxx
HYDROData_SplitToZonesTool.cxx
HYDROData_Stream.cxx
HYDROData_StreamAltitude.cxx
#include "HYDROData_PolylineXY.h"
#include "HYDROData_StricklerTable.h"
#include "HYDROData_LandCoverMap.h"
-#include "HYDROData_SplittedShapesGroup.h"
+#include "HYDROData_SplitShapesGroup.h"
#include "HYDROData_Region.h"
#include "HYDROData_Tool.h"
#include "HYDROData_GeomTool.h"
// Update names of regions and its zones
UpdateRegionsNames( GetRegions(), anOldCaseName, theName );
- HYDROData_SequenceOfObjects aGroups = GetSplittedGroups();
+ HYDROData_SequenceOfObjects aGroups = GetSplitGroups();
HYDROData_SequenceOfObjects::Iterator anIter;
anIter.Init( aGroups );
for ( ; anIter.More(); anIter.Next() )
{
- Handle(HYDROData_SplittedShapesGroup) aGroup =
- Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() );
+ Handle(HYDROData_SplitShapesGroup) aGroup =
+ Handle(HYDROData_SplitShapesGroup)::DownCast( anIter.Value() );
if ( aGroup.IsNull() )
continue;
// At first we remove previously created objects
RemoveRegions();
- RemoveSplittedGroups();
+ RemoveSplitGroups();
Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
if ( aDocument.IsNull() )
void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc,
const HYDROData_SplitToZonesTool::SplitDataList& theEdges )
{
- QMap<QString,Handle(HYDROData_SplittedShapesGroup)> aSplittedEdgesGroupsMap;
+ QMap<QString,Handle(HYDROData_SplitShapesGroup)> aSplitEdgesGroupsMap;
HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theEdges );
while( anIter.hasNext() )
QString aStr = aSplitData.ObjectNames.join(" ");
cout << " CCase: Names = "<<aStr.toStdString() << " size = " <<aSplitData.ObjectNames.size() <<endl;
#endif
- Handle(HYDROData_SplittedShapesGroup) aSplittedGroup;
- if ( !aSplittedEdgesGroupsMap.contains( anObjName ) )
+ Handle(HYDROData_SplitShapesGroup) aSplitGroup;
+ if ( !aSplitEdgesGroupsMap.contains( anObjName ) )
{
- aSplittedGroup = addNewSplittedGroup( CALCULATION_GROUPS_PREF + anObjName );
- aSplittedEdgesGroupsMap.insert( anObjName, aSplittedGroup );
+ aSplitGroup = addNewSplitGroup( CALCULATION_GROUPS_PREF + anObjName );
+ aSplitEdgesGroupsMap.insert( anObjName, aSplitGroup );
}
else
{
- aSplittedGroup = aSplittedEdgesGroupsMap[ anObjName ];
+ aSplitGroup = aSplitEdgesGroupsMap[ anObjName ];
}
- if ( aSplittedGroup.IsNull() )
+ if ( aSplitGroup.IsNull() )
continue;
- aSplittedGroup->AddShape( aSplitData.Shape );
+ aSplitGroup->AddShape( aSplitData.Shape );
}
}
myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes();
}
-HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const
+HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplitGroups() const
{
- return GetReferenceObjects( DataTag_SplittedGroups );
+ return GetReferenceObjects( DataTag_SplitGroups );
}
-void HYDROData_CalculationCase::RemoveSplittedGroups()
+void HYDROData_CalculationCase::RemoveSplitGroups()
{
- myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes();
+ myLab.FindChild( DataTag_SplitGroups ).ForgetAllAttributes();
}
double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const
return aNewRegion;
}
-Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup( const QString& theName )
+Handle(HYDROData_SplitShapesGroup) HYDROData_CalculationCase::addNewSplitGroup( const QString& theName )
{
- TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild();
+ TDF_Label aNewLab = myLab.FindChild( DataTag_SplitGroups ).NewChild();
- Handle(HYDROData_SplittedShapesGroup) aNewGroup =
- Handle(HYDROData_SplittedShapesGroup)::DownCast(
- HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) );
- AddReferenceObject( aNewGroup, DataTag_SplittedGroups );
+ Handle(HYDROData_SplitShapesGroup) aNewGroup =
+ Handle(HYDROData_SplitShapesGroup)::DownCast(
+ HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLIT_GROUP ) );
+ AddReferenceObject( aNewGroup, DataTag_SplitGroups );
aNewGroup->SetName( theName );
HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs;
// Get groups definitions
- HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
+ HYDROData_SequenceOfObjects aSplitGroups = GetSplitGroups();
- HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups );
+ HYDROData_SequenceOfObjects::Iterator anIter( aSplitGroups );
for ( ; anIter.More(); anIter.Next() )
{
// Get shapes group
class Handle(HYDROData_Zone);
class Handle(HYDROData_PolylineXY);
class Handle(HYDROData_ShapesGroup);
-class Handle(HYDROData_SplittedShapesGroup);
+class Handle(HYDROData_SplitShapesGroup);
class Handle(HYDROData_Document);
class Handle(HYDROData_StricklerTable);
class Handle(HYDROData_LandCoverMap);
DataTag_Region, ///< reference regions
DataTag_Polyline, ///< reference boundary polyline
DataTag_GeometryGroup, ///< reference geometry groups
- DataTag_SplittedGroups, ///< reference splitted groups
+ DataTag_SplitGroups, ///< reference split groups
DataTag_CustomRules, ///< custom rules
DataTag_AssignmentMode, ///< assignment mode
DataTag_StricklerTable, ///< reference Strickler table
/**
* Updates the name of this object.
- * Reimplemented to update the names of regions, zones and splitted groups.
+ * Reimplemented to update the names of regions, zones and split groups.
*/
HYDRODATA_EXPORT virtual void SetName( const QString& theName );
/**
* Returns all reference geometry groups of calculation case.
*/
- HYDRODATA_EXPORT virtual HYDROData_SequenceOfObjects GetSplittedGroups() const;
+ HYDRODATA_EXPORT virtual HYDROData_SequenceOfObjects GetSplitGroups() const;
/**
* Removes all reference geometry groups from calculation case.
*/
- HYDRODATA_EXPORT virtual void RemoveSplittedGroups();
+ HYDRODATA_EXPORT virtual void RemoveSplitGroups();
/**
* Exports the calculation case data (shell and groups) to GEOM module.
bool isPrefix = true );
/**
- * Add new one splitted edges group for calculation case.
+ * Add new one split edges group for calculation case.
*/
- Handle(HYDROData_SplittedShapesGroup) addNewSplittedGroup( const QString& theName );
+ Handle(HYDROData_SplitShapesGroup) addNewSplitGroup( const QString& theName );
/**
* Exports the given faces as shell and the given groups to GEOM module.
* \param theGeomEngine GEOM module engine
* \param theStudy SALOMEDS study, is used for publishing of GEOM objects
* \param theFaces the list of faces to make shell
- * \param theSplittedGroups the list of groups
+ * \param theSplitGroups the list of groups
* \return true in case of success
*/
#ifndef LIGHT_MODE
case KIND_NATURAL_OBJECT: return "KIND_NATURAL_OBJECT";
case KIND_DUMMY_3D: return "KIND_DUMMY_3D";
case KIND_SHAPES_GROUP: return "KIND_SHAPES_GROUP";
- case KIND_SPLITTED_GROUP: return "KIND_SPLITTED_GROUP";
+ case KIND_SPLIT_GROUP: return "KIND_SPLIT_GROUP";
case KIND_STREAM_ALTITUDE: return "KIND_STREAM_ALTITUDE";
case KIND_OBSTACLE_ALTITUDE: return "KIND_OBSTACLE_ALTITUDE";
case KIND_STRICKLER_TABLE: return "KIND_STRICKLER_TABLE";
const ObjectKind KIND_NATURAL_OBJECT = 20;
const ObjectKind KIND_DUMMY_3D = 21;
const ObjectKind KIND_SHAPES_GROUP = 22;
-const ObjectKind KIND_SPLITTED_GROUP = 23;
+const ObjectKind KIND_SPLIT_GROUP = 23;
const ObjectKind KIND_STREAM_ALTITUDE = 24;
const ObjectKind KIND_OBSTACLE_ALTITUDE = 25;
const ObjectKind KIND_STRICKLER_TABLE = 26;
#include <boost/math/special_functions/fpclassify.hpp>
-static const Standard_GUID GUID_SELF_SPLITTED("997995aa-5c19-40bf-9a60-ab4b70ad04d8");
+static const Standard_GUID GUID_SELF_SPLIT("997995aa-5c19-40bf-9a60-ab4b70ad04d8");
static const Standard_GUID GUID_HAS_LOCAL_POINTS("FD8841AA-FC44-42fa-B6A7-0F682CCC6F27");
static const Standard_GUID GUID_HAS_GLOBAL_POINTS("330D0E81-742D-4ea3-92D4-484877CFA7C1");
ClearReferences();
SetOperatorName( "" );
SetArgs( "" );
- SetIsSelfSplitted( false );
+ SetIsSelfSplit( false );
}
bool anIsByTwoPoints = IsByTwoPoints();
return QByteArray(aData, aLen);
}
-void HYDROData_Image::SetIsSelfSplitted(bool theFlag)
+void HYDROData_Image::SetIsSelfSplit(bool theFlag)
{
if (theFlag) {
- TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLITTED);
+ TDataStd_UAttribute::Set(myLab, GUID_SELF_SPLIT);
} else {
- myLab.ForgetAttribute(GUID_SELF_SPLITTED);
+ myLab.ForgetAttribute(GUID_SELF_SPLIT);
}
Changed( Geom_2d );
}
-bool HYDROData_Image::IsSelfSplitted() const
+bool HYDROData_Image::IsSelfSplit() const
{
- return myLab.IsAttribute(GUID_SELF_SPLITTED);
+ return myLab.IsAttribute(GUID_SELF_SPLIT);
}
QPointF HYDROData_Image::generateThirdPoint( const QPointF& thePointA,
/**
- * Marks the image as self-splitted.
- * \param theFlag is true for self-splitted image
+ * Marks the image as self-split.
+ * \param theFlag is true for self-plit image
*/
- HYDRODATA_EXPORT void SetIsSelfSplitted(bool theFlag);
+ HYDRODATA_EXPORT void SetIsSelfSplit(bool theFlag);
/**
- * Checks that the image is self-splitted.
- * \returns true if image is self-splitted
+ * Checks that the image is self-split.
+ * \returns true if image is self-split
*/
- HYDRODATA_EXPORT bool IsSelfSplitted() const;
+ HYDRODATA_EXPORT bool IsSelfSplit() const;
private:
#include "HYDROData_Region.h"
#include "HYDROData_River.h"
#include "HYDROData_ShapesGroup.h"
-#include "HYDROData_SplittedShapesGroup.h"
+#include "HYDROData_SplitShapesGroup.h"
#include "HYDROData_Stream.h"
#include "HYDROData_StreamAltitude.h"
#include "HYDROData_VisualState.h"
case KIND_VISUAL_STATE: aResult = new HYDROData_VisualState(); break;
case KIND_DUMMY_3D: aResult = new HYDROData_DummyObject3D(); break;
case KIND_SHAPES_GROUP: aResult = new HYDROData_ShapesGroup(); break;
- case KIND_SPLITTED_GROUP: aResult = new HYDROData_SplittedShapesGroup(); break;
+ case KIND_SPLIT_GROUP: aResult = new HYDROData_SplitShapesGroup(); break;
case KIND_STREAM_ALTITUDE: aResult = new HYDROData_StreamAltitude(); break;
case KIND_OBSTACLE_ALTITUDE: aResult = new HYDROData_ObstacleAltitude(); break;
case KIND_STRICKLER_TABLE: aResult = new HYDROData_StricklerTable(); break;
aCurve.Intersect(aToolCurves[aTSI], aParams);
}
- std::deque<HYDROData_TopoCurve> aSplittedCurves;
- theIsIntersected |= aCurve.Cut(aParams, aSplittedCurves);
+ std::deque<HYDROData_TopoCurve> aSplitCurves;
+ theIsIntersected |= aCurve.Cut(aParams, aSplitCurves);
std::deque<HYDROData_TopoCurve>::const_iterator aCIt =
- aSplittedCurves.begin();
+ aSplitCurves.begin();
std::deque<HYDROData_TopoCurve>::const_iterator aLastCIt =
- aSplittedCurves.end();
+ aSplitCurves.end();
for (; aCIt != aLastCIt; ++aCIt)
{
aResult.push_back(aCIt->Wire());
#include <BRep_Builder.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <GCPnts_QuasiUniformDeflection.hxx>
+#include <TopLoc_Location.hxx>
+#include <Geom_Plane.hxx>
+#include <NCollection_Array1.hxx>
#ifdef WIN32
#pragma warning( disable: 4996 )
//so just write all points "as-is"
//External wire will be written in clockwise direction
//any other wires (holes) - in anticlockwise direction
- for (int j = 1; j <= aNPnts.Size(); j++)
+ for (int j = aNPnts.Size(); j >= 1; j--)
{
x.push_back( aNPnts(j).X());
y.push_back( aNPnts(j).Y());
}
//first point is same as the last one => closed polygon
- x.push_back( aNPnts(1).X());
- y.push_back( aNPnts(1).Y());
+ x.push_back( aNPnts.Last().X());
+ y.push_back( aNPnts.Last().Y());
}
{
if (!anObj)
return;
- TopoDS_Wire W;
TopoDS_Edge E;
int nParts = anObj->nParts;
- gp_Pln pln(gp_Pnt(0,0,0), gp_Dir(0,0,1));
+ Handle_Geom_Plane aPlaneSur = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
+
+ BRep_Builder BB;
+ BB.MakeFace(F);
TopTools_SequenceOfShape aWires;
for ( int i = 0 ; i < nParts ; i++ )
EndIndex = anObj->panPartStart[i + 1];
else
EndIndex = anObj->nVertices;
-
- NCollection_List<TopoDS_Vertex> aVertices;
- gp_Pnt FP (anObj->padfX[StartIndex], anObj->padfY[StartIndex], 0);
- TopoDS_Vertex V = BRepLib_MakeVertex(FP).Vertex();
- aVertices.Append(V);
+
+ TopoDS_Wire W;
+ BB.MakeWire(W);
+
+ //First point is same as the last point
+ int NbPnts = EndIndex - StartIndex - 1;
+ NCollection_Array1<TopoDS_Vertex> VPoints(0, NbPnts);
+ int j = NbPnts;
+ for ( int k = StartIndex; k < EndIndex; k++ )
+ {
+ gp_Pnt P (anObj->padfX[k], anObj->padfY[k], 0);
+ VPoints.ChangeValue(j) = BRepLib_MakeVertex(P).Vertex();
+ j--;
+ }
- for ( int k = StartIndex + 1; k < EndIndex; k++ )
+ for ( int k = 0; k < VPoints.Size() - 1; k++ )
{
- gp_Pnt P1 (anObj->padfX[k - 1], anObj->padfY[k-1], 0); //prev point
- gp_Pnt P2 (anObj->padfX[k], anObj->padfY[k], 0); //current point
+ gp_Pnt P1 = BRep_Tool::Pnt(VPoints(k));
+ gp_Pnt P2 = BRep_Tool::Pnt(VPoints(k + 1));
if (P1.Distance(P2) < Precision::Confusion())
continue;
- TopoDS_Vertex V = BRepLib_MakeVertex(P2).Vertex();
- Handle_Geom_TrimmedCurve aTC = GC_MakeSegment(P1,P2).Value();
- TopoDS_Edge E = BRepLib_MakeEdge(aTC, aVertices.Last(), V).Edge();
- aVertices.Append(V);
- aBuilder.Add(E);
+ Handle_Geom_TrimmedCurve aTC = GC_MakeSegment(P1, P2).Value();
+ TopoDS_Edge E;
+ if ( k != VPoints.Size() - 2)
+ E = BRepLib_MakeEdge(aTC, VPoints(k), VPoints(k + 1)).Edge();
+ else
+ //the last edge => use first and last vertices
+ E = BRepLib_MakeEdge(aTC, VPoints.First(), VPoints.Value(VPoints.Upper() - 1)).Edge();
+ //Add edge to wire
+ //If SHP file is correct then the outer wire and the holes will have the correct orientations
+ BB.Add(W, E);
}
-
- aBuilder.Build();
- W = TopoDS::Wire(aBuilder.Shape());
+ //Wire must be closed anyway
+ W.Closed (BRep_Tool::IsClosed (W));
W.Orientation(TopAbs_FORWARD);
- BRepBuilderAPI_MakeFace aDB(pln, W);
- TopoDS_Face aDummyFace = TopoDS::Face(aDB.Shape());
- BRepTopAdaptor_FClass2d FClass(aDummyFace, Precision::PConfusion());
- if ( i == 0 && FClass.PerformInfinitePoint() != TopAbs_OUT)
- W.Reverse();
- if ( i > 0 && FClass.PerformInfinitePoint() != TopAbs_IN)
- W.Reverse();
-
- aWires.Append(W);
+ BB.Add(F, W);
}
- BRepBuilderAPI_MakeFace aFBuilder(pln, TopoDS::Wire(aWires(1)));
- for (int i = 2; i <= aWires.Length(); i++)
- aFBuilder.Add(TopoDS::Wire(aWires(i)));
- F = TopoDS::Face(aFBuilder.Shape());
-
+ //Add surface to the face
+ BB.UpdateFace(F, aPlaneSur, TopLoc_Location(), Precision::Confusion());
+ F.Closed(Standard_True);
}
int HYDROData_ShapeFile::ImportPolygons(const QString theFileName, QStringList& thePolygonsList, TopTools_SequenceOfShape& theFaces, int& theShapeTypeOfFile)
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// 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_SplitShapesGroup.h"
+
+IMPLEMENT_STANDARD_HANDLE(HYDROData_SplitShapesGroup,HYDROData_ShapesGroup)
+IMPLEMENT_STANDARD_RTTIEXT(HYDROData_SplitShapesGroup,HYDROData_ShapesGroup)
+
+HYDROData_SplitShapesGroup::HYDROData_SplitShapesGroup()
+: HYDROData_ShapesGroup()
+{
+}
+
+HYDROData_SplitShapesGroup::~HYDROData_SplitShapesGroup()
+{
+}
+
+
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// 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
+//
+
+#ifndef HYDROData_SplitShapesGroup_HeaderFile
+#define HYDROData_SplitShapesGroup_HeaderFile
+
+#include <HYDROData_ShapesGroup.h>
+
+DEFINE_STANDARD_HANDLE(HYDROData_SplitShapesGroup, HYDROData_ShapesGroup)
+
+
+/**\class HYDROData_SplitShapesGroup
+ * \brief Class that stores/retreives the sequence of split shapes.
+ */
+class HYDROData_SplitShapesGroup : public HYDROData_ShapesGroup
+{
+protected:
+ /**
+ * Enumeration of tags corresponding to the persistent object parameters.
+ */
+ enum DataTag
+ {
+ DataTag_First = HYDROData_ShapesGroup::DataTag_First + 100 ///< first tag, to reserve
+ };
+
+public:
+ DEFINE_STANDARD_RTTI(HYDROData_SplitShapesGroup);
+
+ /**
+ * Returns the kind of this object. Must be redefined in all objects of known type.
+ */
+ HYDRODATA_EXPORT virtual const ObjectKind GetKind() const { return KIND_SPLIT_GROUP; }
+
+protected:
+
+ friend class HYDROData_Iterator;
+
+ /**
+ * Creates new object in the internal data structure. Use higher level objects
+ * to create objects with real content.
+ */
+ HYDRODATA_EXPORT HYDROData_SplitShapesGroup();
+
+ /**
+ * Destructs properties of the object and object itself, removes it from the document.
+ */
+ virtual HYDRODATA_EXPORT ~HYDROData_SplitShapesGroup();
+};
+
+#endif
+++ /dev/null
-// Copyright (C) 2014-2015 EDF-R&D
-// 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_SplittedShapesGroup.h"
-
-IMPLEMENT_STANDARD_HANDLE(HYDROData_SplittedShapesGroup,HYDROData_ShapesGroup)
-IMPLEMENT_STANDARD_RTTIEXT(HYDROData_SplittedShapesGroup,HYDROData_ShapesGroup)
-
-HYDROData_SplittedShapesGroup::HYDROData_SplittedShapesGroup()
-: HYDROData_ShapesGroup()
-{
-}
-
-HYDROData_SplittedShapesGroup::~HYDROData_SplittedShapesGroup()
-{
-}
-
-
+++ /dev/null
-// Copyright (C) 2014-2015 EDF-R&D
-// 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
-//
-
-#ifndef HYDROData_SplittedShapesGroup_HeaderFile
-#define HYDROData_SplittedShapesGroup_HeaderFile
-
-#include <HYDROData_ShapesGroup.h>
-
-DEFINE_STANDARD_HANDLE(HYDROData_SplittedShapesGroup, HYDROData_ShapesGroup)
-
-
-/**\class HYDROData_SplittedShapesGroup
- * \brief Class that stores/retreives the sequence of splitted shapes.
- */
-class HYDROData_SplittedShapesGroup : public HYDROData_ShapesGroup
-{
-protected:
- /**
- * Enumeration of tags corresponding to the persistent object parameters.
- */
- enum DataTag
- {
- DataTag_First = HYDROData_ShapesGroup::DataTag_First + 100 ///< first tag, to reserve
- };
-
-public:
- DEFINE_STANDARD_RTTI(HYDROData_SplittedShapesGroup);
-
- /**
- * Returns the kind of this object. Must be redefined in all objects of known type.
- */
- HYDRODATA_EXPORT virtual const ObjectKind GetKind() const { return KIND_SPLITTED_GROUP; }
-
-protected:
-
- friend class HYDROData_Iterator;
-
- /**
- * Creates new object in the internal data structure. Use higher level objects
- * to create objects with real content.
- */
- HYDRODATA_EXPORT HYDROData_SplittedShapesGroup();
-
- /**
- * Destructs properties of the object and object itself, removes it from the document.
- */
- virtual HYDRODATA_EXPORT ~HYDROData_SplittedShapesGroup();
-};
-
-#endif
//! Cuts the curve in the given parameter of the given edge and
//! fills the cut part.
//! Returns 'true' if:
- //! - the curve is open and was splitted into two parts or
+ //! - the curve is open and was split into two parts or
//! - the curve is closed and was cut into an open curve.
HYDRODATA_EXPORT bool Cut(
const std::list<TopoDS_Edge>::iterator& theEdgePosition,
*/
void onCreateRegion( const QList<SUIT_DataObject*>& theZonesList );
/**
- * Case objects must be splitted to zones if the case has been modified or new.
+ * Case objects must be split to zones if the case has been modified or new.
*/
void onNext( const int );
void onLastViewClosed( SUIT_ViewManager* );
bool isChildObject = aKind == KIND_DUMMY_3D ||
aKind == KIND_ZONE ||
aKind == KIND_SHAPES_GROUP ||
- aKind == KIND_SPLITTED_GROUP;
+ aKind == KIND_SPLIT_GROUP;
if ( isUnrecognized || isChildObject ) {
isCanCopy = false;
break;
const ObjectKind aKind = theModelObject->GetKind();
bool visibility = aKind == KIND_IMAGE || aKind == KIND_POLYLINEXY || aKind == KIND_POLYLINE ||
- aKind == KIND_SHAPES_GROUP || aKind == KIND_SPLITTED_GROUP || aKind == KIND_ZONE ||
+ aKind == KIND_SHAPES_GROUP || aKind == KIND_SPLIT_GROUP || aKind == KIND_ZONE ||
aKind == KIND_IMMERSIBLE_ZONE || aKind == KIND_REGION || aKind == KIND_BATHYMETRY ||
aKind == KIND_OBSTACLE || aKind == KIND_STREAM || aKind == KIND_CHANNEL ||
aKind == KIND_DIGUE || aKind == KIND_DUMMY_3D || aKind == KIND_LAND_COVER_MAP;
HYDROData_SequenceOfObjects aCalcGroups = aCaseObj->GetGeometryGroups();
buildObjectPartition( aGuiObj, aCalcGroups, tr( "OBJECT_GROUPS" ), false );
- HYDROData_SequenceOfObjects aCalcSplitGroups = aCaseObj->GetSplittedGroups();
- buildObjectPartition( aGuiObj, aCalcSplitGroups, tr( "CASE_SPLITTED_GROUPS" ), false );
+ HYDROData_SequenceOfObjects aCalcSplitGroups = aCaseObj->GetSplitGroups();
+ buildObjectPartition( aGuiObj, aCalcSplitGroups, tr( "CASE_SPLIT_GROUPS" ), false );
#endif
}
else
return;
+ QStringList SortedListOfAttr = anAttrNames.toList();
+ SortedListOfAttr.sort();
//
Handle_HYDROData_LandCoverMap aLCM = Handle(HYDROData_LandCoverMap)::DownCast( aSeq(1) );
bool IsLinear = aLCM->CheckLinear();
- HYDROGUI_ExportLandCoverMapDlg aDlg( module()->getApp()->desktop(), IsLinear, anAttrNames.toList());
+ HYDROGUI_ExportLandCoverMapDlg aDlg( module()->getApp()->desktop(), IsLinear, SortedListOfAttr);
if ( aDlg.exec() == HYDROGUI_ExportLandCoverMapDlg::Accepted )
{
//In our case : aSeq.Size() == 1
aLayout->addWidget( myDeflLabel, 3, 0, 1, 1 );
aLayout->addWidget( myDeflSpinBox, 3, 1, 2, 2 );
}
+ else
+ {
+ myDeflSpinBox = NULL;
+ myDeflLabel = NULL;
+ myDiscrLabel = NULL;
+ }
setMinimumSize( 300, 100 );
double HYDROGUI_ExportLandCoverMapDlg::getDeflValue() const
{
- return myDeflSpinBox->value();
+ if (myDeflSpinBox)
+ return myDeflSpinBox->value();
+ else
+ return -1; //value is not needed
}
// Split land cover(s) inside edited land cover map
if ( myOperationId == SplitLandCoverId )
{
- bool aLandCoverSplitted = false;
+ bool aLandCoverSplit = false;
if ( !aPolyline.IsNull() )
- aLandCoverSplitted = aLandCoverMapObj->Split( aPolyline );
+ aLandCoverSplit = aLandCoverMapObj->Split( aPolyline );
else if ( !aFace.IsNull() )
{
// Get the complete boundary of the object face as the splitting polyline
continue;
bool aSplitResult = aLandCoverMapObj->Split( aShape );
- aLandCoverSplitted = ( i==0 ? aSplitResult : aLandCoverSplitted && aSplitResult );
+ aLandCoverSplit = ( i==0 ? aSplitResult : aLandCoverSplit && aSplitResult );
}
}
- if ( !aLandCoverSplitted )
+ if ( !aLandCoverSplit )
{
- theErrorMsg = tr( "LAND_COVER_NOT_SPLITTED" );
+ theErrorMsg = tr( "LAND_COVER_NOT_SPLIT" );
return false;
}
}
bool anIsImageHasRefs = false;
bool anIsFusedImage = false;
bool anIsCutImage = false;
- bool anIsSplittedImage = false;
+ bool anIsSplitImage = false;
bool anIsMustObjectBeUpdated = false;
bool anIsPolyline = false;
bool anIsPolyline3D = false;
else if( anOperatorName == ImageComposer_CutOperator::Type() )
anIsCutImage = true;
else if( anOperatorName == ImageComposer_CropOperator::Type() )
- anIsSplittedImage = true;
+ anIsSplitImage = true;
}
}
}
anIsDigue = true;
else if( anObjectKind == KIND_DUMMY_3D )
anIsDummyObject3D = true;
- else if( anObjectKind == KIND_SHAPES_GROUP || anObjectKind == KIND_SPLITTED_GROUP )
+ else if( anObjectKind == KIND_SHAPES_GROUP || anObjectKind == KIND_SPLIT_GROUP )
anIsGroup = true;
}
theMenu->addAction( action( EditFusedImageId ) );
else if( anIsCutImage )
theMenu->addAction( action( EditCutImageId ) );
- else if( anIsSplittedImage )
- theMenu->addAction( action( EditSplittedImageId ) );
+ else if( anIsSplitImage )
+ theMenu->addAction( action( EditSplitImageId ) );
}
//RKV: BUG#98: theMenu->addAction( action( ObserveImageId ) );
createAction( EditCutImageId, "EDIT_CUT_IMAGE", "EDIT_CUT_IMAGE_ICO" );
createAction( SplitImageId, "SPLIT_IMAGE", "SPLIT_IMAGE_ICO" );
- createAction( EditSplittedImageId, "EDIT_SPLITTED_IMAGE", "EDIT_SPLITTED_IMAGE_ICO" );
+ createAction( EditSplitImageId, "EDIT_SPLIT_IMAGE", "EDIT_SPLIT_IMAGE_ICO" );
createAction( RecognizeContoursId, "RECOGNIZE_CONTOURS", "RECOGNIZE_CONTOURS_ICO" );
anOp = new HYDROGUI_TwoImagesOp( aModule, HYDROGUI_TwoImagesOp::Cut, theId == EditCutImageId );
break;
case SplitImageId:
- case EditSplittedImageId:
- anOp = new HYDROGUI_TwoImagesOp( aModule, HYDROGUI_TwoImagesOp::Split, theId == EditSplittedImageId );
+ case EditSplitImageId:
+ anOp = new HYDROGUI_TwoImagesOp( aModule, HYDROGUI_TwoImagesOp::Split, theId == EditSplitImageId );
break;
case ImportObstacleFromFileId:
anOp = new HYDROGUI_ImportObstacleFromFileOp( aModule );
EditCutImageId,
SplitImageId,
- EditSplittedImageId,
+ EditSplitImageId,
ImportObstacleFromFileId,
ImportGeomObjectAsObstacleId,
anObjectKind == KIND_LAND_COVER_MAP
#ifdef DEB_GROUPS
|| anObjectKind == KIND_SHAPES_GROUP ||
- anObjectKind == KIND_SPLITTED_GROUP
+ anObjectKind == KIND_SPLIT_GROUP
#endif
)
{
{
case Fuse: aName = theIsEdit ? tr( "EDIT_FUSED_IMAGE" ) : tr( "FUSE_IMAGES" ); break;
case Cut: aName = theIsEdit ? tr( "EDIT_CUT_IMAGE" ) : tr( "CUT_IMAGES" ); break;
- case Split: aName = theIsEdit ? tr( "EDIT_SPLITTED_IMAGE" ) : tr( "SPLIT_IMAGE" ); break;
+ case Split: aName = theIsEdit ? tr( "EDIT_SPLIT_IMAGE" ) : tr( "SPLIT_IMAGE" ); break;
default: break;
}
setName( aName );
Handle(HYDROData_Image) aSelectedImage = Handle(HYDROData_Image)::DownCast( anObject1 );
if( !aSelectedImage.IsNull() )
{
- aSelectedImage->SetIsSelfSplitted( true );
+ aSelectedImage->SetIsSelfSplit( true );
aSelectedImage->SetImage( aResult->Image() );
aSelectedImage->SetTrsf( aResult->Trsf() );
aResult->Remove();
<translation>icon_split_image.png</translation>
</message>
<message>
- <source>EDIT_SPLITTED_IMAGE_ICO</source>
- <translation>icon_edit_splitted_image.png</translation>
+ <source>EDIT_SPLIT_IMAGE_ICO</source>
+ <translation>icon_edit_split_image.png</translation>
</message>
<message>
<translation>LAND COVER MAP</translation>
</message>
<message>
- <source>CASE_SPLITTED_GROUPS</source>
+ <source>CASE_SPLIT_GROUPS</source>
<translation>Split groups</translation>
</message>
<message>
<translation>Edit polyline 3D</translation>
</message>
<message>
- <source>DSK_EDIT_SPLITTED_IMAGE</source>
+ <source>DSK_EDIT_SPLIT_IMAGE</source>
<translation>Edit split image</translation>
</message>
<message>
<translation>Edit profile</translation>
</message>
<message>
- <source>MEN_EDIT_SPLITTED_IMAGE</source>
+ <source>MEN_EDIT_SPLIT_IMAGE</source>
<translation>Edit split image</translation>
</message>
<message>
<translation>Edit polyline 3D</translation>
</message>
<message>
- <source>STB_EDIT_SPLITTED_IMAGE</source>
+ <source>STB_EDIT_SPLIT_IMAGE</source>
<translation>Edit split image</translation>
</message>
<message>
<translation>Edit fused image</translation>
</message>
<message>
- <source>EDIT_SPLITTED_IMAGE</source>
+ <source>EDIT_SPLIT_IMAGE</source>
<translation>Edit split image</translation>
</message>
<message>
<translation>Land cover can not be removed.</translation>
</message>
<message>
- <source>LAND_COVER_NOT_SPLITTED</source>
- <translation>Land cover can not be splitted.</translation>
+ <source>LAND_COVER_NOT_SPLIT</source>
+ <translation>Land cover can not be split.</translation>
</message>
<message>
<source>LAND_COVER_NOT_MERGED</source>
</message>
<message>
<source>SPLIT_POLYLINE_BY_TOOL_WARNING_MSG</source>
- <translation>The splitted polyline is not intersected by the tool.</translation>
+ <translation>The split polyline is not intersected by the tool.</translation>
</message>
</context>
HYDROData_IInterpolator.sip
HYDROData_Entity.sip
HYDROData_ShapesGroup.sip
- HYDROData_SplittedShapesGroup.sip
+ HYDROData_SplitShapesGroup.sip
HYDROData_IPolyline.sip
HYDROData_IAltitudeObject.sip
HYDROData_AltitudeObject.sip
%Include HYDROData_River.sip
%Include HYDROData_SequenceOfObjects.sip
%Include HYDROData_ShapesGroup.sip
-%Include HYDROData_SplittedShapesGroup.sip
+%Include HYDROData_SplitShapesGroup.sip
%Include HYDROData_Stream.sip
%Include HYDROData_StreamAltitude.sip
%Include HYDROData_StricklerTable.sip
DataTag_Region, ///< reference regions
DataTag_Polyline, ///< reference boundary polyline
DataTag_GeometryGroup, ///< reference geometry groups
- DataTag_SplittedGroups, ///< reference splitted groups
+ DataTag_SplitGroups, ///< reference split groups
DataTag_CustomRules, ///< custom rules
DataTag_AssignmentMode, ///< assignment mode
DataTag_StricklerTable, ///< reference Strickler table
/**
* Returns all reference geometry groups of calculation case.
*/
- HYDROData_SequenceOfObjects GetSplittedGroups() const;
+ HYDROData_SequenceOfObjects GetSplitGroups() const;
/**
* Removes all reference geometry groups from calculation case.
*/
- void RemoveSplittedGroups();
+ void RemoveSplitGroups();
/**
aRes = new HYDROData_ShapesGroup( *dynamic_cast<HYDROData_ShapesGroup*>( theObject ) );
break;
}
- case KIND_SPLITTED_GROUP:
+ case KIND_SPLIT_GROUP:
{
- aRes = new HYDROData_SplittedShapesGroup( *dynamic_cast<HYDROData_SplittedShapesGroup*>( theObject ) );
+ aRes = new HYDROData_SplitShapesGroup( *dynamic_cast<HYDROData_SplitShapesGroup*>( theObject ) );
break;
}
case KIND_OBSTACLE_ALTITUDE:
const ObjectKind KIND_ZONE;
const ObjectKind KIND_REGION;
const ObjectKind KIND_SHAPES_GROUP;
-const ObjectKind KIND_SPLITTED_GROUP;
+const ObjectKind KIND_SPLIT_GROUP;
const ObjectKind KIND_OBSTACLE_ALTITUDE;
const ObjectKind KIND_STRICKLER_TABLE;
const ObjectKind KIND_LAND_COVER_MAP;
sipClass = sipClass_HYDROData_ShapesGroup;
break;
- case KIND_SPLITTED_GROUP:
- sipClass = sipClass_HYDROData_SplittedShapesGroup;
+ case KIND_SPLIT_GROUP:
+ sipClass = sipClass_HYDROData_SplitShapesGroup;
break;
case KIND_STREAM_ALTITUDE:
/**
- * Marks the image as self-splitted.
- * \param theFlag is true for self-splitted image
+ * Marks the image as self-split.
+ * \param theFlag is true for self-split image
*/
- void SetIsSelfSplitted(bool theFlag);
+ void SetIsSelfSplit(bool theFlag);
/**
- * Checks that the image is self-splitted.
- * \returns true if image is self-splitted
+ * Checks that the image is self-split.
+ * \returns true if image is self-split
*/
- bool IsSelfSplitted() const;
+ bool IsSelfSplit() const;
protected:
// HYDROData_Entity sub-classes provide a unique kind ID.
switch ( sipCpp->GetKind() )
{
- case KIND_SPLITTED_GROUP:
- sipClass = sipClass_HYDROData_SplittedShapesGroup;
+ case KIND_SPLIT_GROUP:
+ sipClass = sipClass_HYDROData_SplitShapesGroup;
break;
case KIND_UNKNOWN:
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// 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
+//
+
+%ExportedHeaderCode
+#include <HYDROData_SplitShapesGroup.h>
+%End
+
+class HYDROData_SplitShapesGroup : public HYDROData_ShapesGroup
+{
+
+%TypeHeaderCode
+#include <HYDROData_SplitShapesGroup.h>
+%End
+
+protected:
+
+ /**
+ * Creates new object in the internal data structure. Use higher level objects
+ * to create objects with real content.
+ */
+ HYDROData_SplitShapesGroup();
+
+ /**
+ * Destructs properties of the object and object itself, removes it from the document.
+ */
+ virtual ~HYDROData_SplitShapesGroup();
+};
+++ /dev/null
-// Copyright (C) 2014-2015 EDF-R&D
-// 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
-//
-
-%ExportedHeaderCode
-#include <HYDROData_SplittedShapesGroup.h>
-%End
-
-class HYDROData_SplittedShapesGroup : public HYDROData_ShapesGroup
-{
-
-%TypeHeaderCode
-#include <HYDROData_SplittedShapesGroup.h>
-%End
-
-protected:
-
- /**
- * Creates new object in the internal data structure. Use higher level objects
- * to create objects with real content.
- */
- HYDROData_SplittedShapesGroup();
-
- /**
- * Destructs properties of the object and object itself, removes it from the document.
- */
- virtual ~HYDROData_SplittedShapesGroup();
-};
../HYDROData/HYDROData_River.cxx
../HYDROData/HYDROData_ShapesGroup.cxx
../HYDROData/HYDROData_ShapesTool.cxx
- ../HYDROData/HYDROData_SplittedShapesGroup.cxx
+ ../HYDROData/HYDROData_SplitShapesGroup.cxx
../HYDROData/HYDROData_SplitToZonesTool.cxx
../HYDROData/HYDROData_Stream.cxx
../HYDROData/HYDROData_StreamAltitude.cxx
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_NATURAL_OBJECT ) );
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_DUMMY_3D ) );
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_SHAPES_GROUP ) );
- CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_SPLITTED_GROUP ) );
+ CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_SPLIT_GROUP ) );
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_STREAM_ALTITUDE ) );
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_OBSTACLE_ALTITUDE ) );
CPPUNIT_ASSERT_EQUAL( false, isOK( f, aDoc, KIND_STRICKLER_TABLE ) );
