]> SALOME platform Git repositories - modules/hydro.git/commitdiff
Salome HOME
Polyline 3d first implementstion.
authoradv <adv@opencascade.com>
Fri, 29 Nov 2013 07:05:29 +0000 (07:05 +0000)
committeradv <adv@opencascade.com>
Fri, 29 Nov 2013 07:05:29 +0000 (07:05 +0000)
src/HYDROData/CMakeLists.txt
src/HYDROData/HYDROData_BSplineOperation.cxx
src/HYDROData/HYDROData_BSplineOperation.h
src/HYDROData/HYDROData_Polyline3D.cxx [new file with mode: 0644]
src/HYDROData/HYDROData_Polyline3D.h [new file with mode: 0644]
src/HYDROData/HYDROData_PolylineXY.cxx
src/HYDROData/HYDROData_PolylineXY.h
src/HYDROData/HYDROData_ProfileUZ.cxx
src/HYDROData/HYDROData_ProfileUZ.h
src/HYDROData/test_HYDROData_BSplineOperation.cxx

index bd03c1f1c226cf1230f5b128db30c02120f0cb26..3a8387600db2456da268a7219e00a650c3212837 100644 (file)
@@ -25,6 +25,7 @@ set(PROJECT_HEADERS
     HYDROData_OperationsFactory.h
 #    HYDROData_Polyline.h
     HYDROData_PolylineXY.h
     HYDROData_OperationsFactory.h
 #    HYDROData_Polyline.h
     HYDROData_PolylineXY.h
+    HYDROData_Polyline3D.h
     HYDROData_Profile.h
     HYDROData_ProfileUZ.h
     HYDROData_Region.h
     HYDROData_Profile.h
     HYDROData_ProfileUZ.h
     HYDROData_Region.h
@@ -60,6 +61,7 @@ set(PROJECT_SOURCES
     HYDROData_OperationsFactory.cxx
 #    HYDROData_Polyline.cxx
     HYDROData_PolylineXY.cxx
     HYDROData_OperationsFactory.cxx
 #    HYDROData_Polyline.cxx
     HYDROData_PolylineXY.cxx
+    HYDROData_Polyline3D.cxx
     HYDROData_Profile.cxx
     HYDROData_ProfileUZ.cxx
     HYDROData_Region.cxx
     HYDROData_Profile.cxx
     HYDROData_ProfileUZ.cxx
     HYDROData_Region.cxx
index df0b2e44fa4dc521ec71d83776c1d3676e092603..128f4aec593a9fe7f293f13afe2af93464f503ef 100644 (file)
@@ -1,41 +1,41 @@
-#include<HYDROData_BSplineOperation.h>
 
 
-#include<TColgp_HArray1OfPnt.hxx>
-#include<GeomAPI_Interpolate.hxx>
-#include<GeomConvert_BSplineCurveToBezierCurve.hxx>
-#include<Geom_BezierCurve.hxx>
+#include <HYDROData_BSplineOperation.h>
+
+#include <TColgp_HArray1OfPnt.hxx>
+
+#include <GeomAPI_Interpolate.hxx>
+#include <GeomConvert_BSplineCurveToBezierCurve.hxx>
+#include <Geom_BezierCurve.hxx>
+
+#include <QPainterPath>
 
 HYDROData_BSplineOperation::HYDROData_BSplineOperation(
 
 HYDROData_BSplineOperation::HYDROData_BSplineOperation(
-  const QList<double>& thePoints,
-  const double theZValue,
-  const bool theIsClosed)
+  const NCollection_Sequence<gp_XYZ>& thePoints,
+  const bool                          theIsClosed )
 {
   // fill array for algorithm by the received coordinates
 {
   // fill array for algorithm by the received coordinates
-  int aLen = thePoints.size() / 2;
-  Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt (1, aLen);
-  QList<double>::const_iterator aListIter = thePoints.begin();
-  for (int ind = 1; ind <= aLen; ind++) {
-    gp_Pnt aPnt(gp::Origin());
-    aPnt.SetX(*aListIter);
-    aListIter++;
-    aPnt.SetY(*aListIter);
-    aListIter++;
-    aPnt.SetZ(theZValue);
-    aHCurvePoints->SetValue(ind, aPnt);
+  int aNbPoints = thePoints.Size();
+
+  Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt( 1, aNbPoints );
+  for ( int i = 1; i <= aNbPoints; i++ )
+  {
+    gp_Pnt aPnt( thePoints.Value( i ) );
+    aHCurvePoints->SetValue( i, aPnt );
   }
   }
+
   // compute BSpline
   // compute BSpline
-  GeomAPI_Interpolate aGBC(aHCurvePoints, theIsClosed, gp::Resolution());
+  GeomAPI_Interpolate aGBC( aHCurvePoints, theIsClosed, gp::Resolution() );
   aGBC.Perform();
   aGBC.Perform();
-  if (aGBC.IsDone()) {
+  if ( aGBC.IsDone() )
     myCurve = aGBC.Curve();
     myCurve = aGBC.Curve();
-  }
 }
 
 QPainterPath HYDROData_BSplineOperation::ComputePath() const
 {
   QPainterPath aResult;
 }
 
 QPainterPath HYDROData_BSplineOperation::ComputePath() const
 {
   QPainterPath aResult;
-  if (myCurve.IsNull()) // returns an empty Path if original curve is invalid
+  if ( myCurve.IsNull() ) // returns an empty Path if original curve is invalid
     return aResult;
     return aResult;
+
   GeomConvert_BSplineCurveToBezierCurve aConverter(myCurve);
   int a, aNumArcs = aConverter.NbArcs();
   for(a = 1; a <= aNumArcs; a++) {
   GeomConvert_BSplineCurveToBezierCurve aConverter(myCurve);
   int a, aNumArcs = aConverter.NbArcs();
   for(a = 1; a <= aNumArcs; a++) {
index 96be8d0983a97ac28430075d3c370143e3d5ba2a..6c91bf864bc0a74e9b20c90b4ee6e718e1bc727d 100644 (file)
@@ -1,11 +1,16 @@
+
 #ifndef HYDROData_BSplineOperation_HeaderFile
 #define HYDROData_BSplineOperation_HeaderFile
 
 #include <HYDROData.h>
 #ifndef HYDROData_BSplineOperation_HeaderFile
 #define HYDROData_BSplineOperation_HeaderFile
 
 #include <HYDROData.h>
-#include <QList>
-#include <QPainterPath>
+
 #include <Geom_BSplineCurve.hxx>
 
 #include <Geom_BSplineCurve.hxx>
 
+#include <NCollection_Sequence.hxx>
+
+class QPainterPath;
+class gp_XYZ;
+
 /**\class HYDROData_BSplineOperation
  *
  * \brief Allows to work with splines: create, convert to Qt ToolPath.
 /**\class HYDROData_BSplineOperation
  *
  * \brief Allows to work with splines: create, convert to Qt ToolPath.
@@ -19,20 +24,19 @@ class HYDRODATA_EXPORT HYDROData_BSplineOperation
 public:
 
   //! Creates a spline by list of coordinates: pairs X and Y
 public:
 
   //! Creates a spline by list of coordinates: pairs X and Y
-  //! \param thePoints coordinates in format X1, Y1, X2, Y2, etc. must be even number of elements
-  //! \param theZValue constant value of the spline Z coordinate
+  //! \param thePoints coordinates of curve
   //! \param theIsClosed flag indicating that the result spline should be closed
   //! \param theIsClosed flag indicating that the result spline should be closed
-  HYDROData_BSplineOperation(const QList<double>& thePoints,
-                          const double theZValue,
-                          const bool theIsClosed);
+  HYDROData_BSplineOperation( const NCollection_Sequence<gp_XYZ>& thePoints,
+                              const bool theIsClosed );
   
   //! Returns the BSpline curve passing through the points
   //! \returns Null if Computation of BSpline was failed
   
   //! Returns the BSpline curve passing through the points
   //! \returns Null if Computation of BSpline was failed
-  Handle(Geom_BSplineCurve) Curve() const {return myCurve;}
+  Handle(Geom_BSplineCurve) Curve() const { return myCurve; }
   
   //! Performs conversion from BSpline curve to QPainterPath made from Bezier curves
   //! \returns computed PainterPath, not stored in this class, so calling of this method is not fast
   QPainterPath ComputePath() const;
   
   //! Performs conversion from BSpline curve to QPainterPath made from Bezier curves
   //! \returns computed PainterPath, not stored in this class, so calling of this method is not fast
   QPainterPath ComputePath() const;
+
 private:
   Handle(Geom_BSplineCurve) myCurve; ///< resulting BSpline, null if something is wrong
 };
 private:
   Handle(Geom_BSplineCurve) myCurve; ///< resulting BSpline, null if something is wrong
 };
diff --git a/src/HYDROData/HYDROData_Polyline3D.cxx b/src/HYDROData/HYDROData_Polyline3D.cxx
new file mode 100644 (file)
index 0000000..bb8d172
--- /dev/null
@@ -0,0 +1,184 @@
+
+#include "HYDROData_Polyline3D.h"
+
+#include "HYDROData_Document.h"
+#include "HYDROData_PolylineXY.h"
+#include "HYDROData_ProfileUZ.h"
+
+#include <gp_Pnt2d.hxx>
+#include <gp_XY.hxx>
+#include <gp_XYZ.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+
+#include <QStringList>
+
+#define PYTHON_POLYLINE_ID "KIND_POLYLINE"
+
+IMPLEMENT_STANDARD_HANDLE(HYDROData_Polyline3D,HYDROData_Object)
+IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Polyline3D,HYDROData_Object)
+
+
+HYDROData_Polyline3D::HYDROData_Polyline3D()
+: HYDROData_Object()
+{
+}
+
+HYDROData_Polyline3D::~HYDROData_Polyline3D()
+{
+}
+
+QStringList HYDROData_Polyline3D::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
+{
+  QStringList aResList;
+
+  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+  if ( aDocument.IsNull() )
+    return aResList;
+
+  QString aDocName = aDocument->GetDocPyName();
+  QString aPolylineName = GetName();
+
+  aResList << QString( "%1 = %2.CreateObject( %3 );" )
+              .arg( aPolylineName ).arg( aDocName ).arg( PYTHON_POLYLINE_ID );
+  aResList << QString( "%1.SetName( \"%1\" );" ).arg( aPolylineName );
+  aResList << QString( "" );
+
+  // TODO
+
+  return aResList;
+}
+
+TopoDS_Shape HYDROData_Polyline3D::GetTopShape() const
+{
+  return getTopShape();
+}
+
+TopoDS_Shape HYDROData_Polyline3D::GetShape3D() const
+{
+  return getShape3D();
+}
+
+void HYDROData_Polyline3D::Update()
+{
+  removeTopShape();
+  removeShape3D();
+
+  Handle(HYDROData_PolylineXY) aPolylineXY = GetPolylineXY();
+  Handle(HYDROData_ProfileUZ) aProfileUZ = GetProfileUZ();
+  if ( aPolylineXY.IsNull() || aProfileUZ.IsNull() )
+    return;
+
+  bool anIsSectionClosed = aPolylineXY->IsClosedSection( 0 );
+  HYDROData_IPolyline::SectionType aSectionType = aPolylineXY->GetSectionType( 0 );
+  HYDROData_IPolyline::PointsList aPolylinePoints = aPolylineXY->GetPoints( 0 );
+  HYDROData_IPolyline::PointsList aProfilePoints = aProfileUZ->GetPoints();
+  if ( aPolylinePoints.IsEmpty() || aProfilePoints.IsEmpty() )
+    return;
+
+  const HYDROData_IPolyline::Point& aFirstPoint = aPolylinePoints.First();
+  const HYDROData_IPolyline::Point& aLastPoint = aPolylinePoints.Last();
+
+  const HYDROData_IPolyline::Point& aFirstParPoint = aProfilePoints.First();
+  const HYDROData_IPolyline::Point& aLastParPoint = aProfilePoints.Last();
+
+  double aPolylineCommonDist = aPolylineXY->GetDistance( 0, aPolylinePoints.Size() - 1 );
+  double aParCommonDist = gp_Pnt2d( aFirstParPoint.X(), 0 ).Distance( gp_Pnt2d( aLastParPoint.X(), 0 ) );
+
+  NCollection_Sequence<Polyline3DPoint> aResPoints;
+  
+  // Add first point as is
+  aResPoints.Append( Polyline3DPoint( aFirstPoint.X(), aFirstPoint.Y(), aFirstParPoint.Y() ) );
+
+  for ( int i = 2, aNbPoints = aPolylinePoints.Size(); i < aNbPoints; ++i )
+  {
+    const HYDROData_IPolyline::Point& aPolylinePoint = aPolylinePoints.Value( i );
+
+    double aDistance = aPolylineXY->GetDistance( 0, i - 1 );
+
+    double aParLen = ( aDistance / aPolylineCommonDist ) * aParCommonDist;
+    double aDepth = aProfileUZ->GetDepthFromDistance( aParLen );
+
+    Polyline3DPoint aCompPoint( aPolylinePoint.X(), aPolylinePoint.Y(), aDepth );
+    aResPoints.Append( aCompPoint );
+  }
+
+  // Add last point as is
+  aResPoints.Append( Polyline3DPoint( aLastPoint.X(), aLastPoint.Y(), aLastParPoint.Y() ) );
+
+  TopoDS_Wire aResWire = HYDROData_PolylineXY::BuildWire( aSectionType, anIsSectionClosed, aResPoints );
+  SetTopShape( aResWire );
+  SetShape3D( aResWire );
+} 
+
+bool HYDROData_Polyline3D::SetPolylineXY( const Handle(HYDROData_PolylineXY)& thePolyline )
+{
+  if ( thePolyline.IsNull() )
+    return false;
+  
+  Handle(HYDROData_PolylineXY) aPrevPolyline = GetPolylineXY();
+  if ( IsEqual( aPrevPolyline, thePolyline ) )
+    return true;
+
+  SetReferenceObject( thePolyline, DataTag_PolylineXY );
+
+  // Indicate model of the need to update the polyline presentation
+  SetToUpdate( true );
+
+  return true;
+}
+
+Handle(HYDROData_PolylineXY) HYDROData_Polyline3D::GetPolylineXY() const
+{
+  return Handle(HYDROData_PolylineXY)::DownCast( 
+           GetReferenceObject( DataTag_PolylineXY ) );
+}
+
+void HYDROData_Polyline3D::RemovePolylineXY()
+{
+  Handle(HYDROData_PolylineXY) aPrevPolyline = GetPolylineXY();
+  if ( aPrevPolyline.IsNull() )
+    return;
+
+  ClearReferenceObjects( DataTag_PolylineXY );
+
+  // Indicate model of the need to update the polyline presentation
+  SetToUpdate( true );
+}
+
+bool HYDROData_Polyline3D::SetProfileUZ( const Handle(HYDROData_ProfileUZ)& theProfile )
+{
+  if ( theProfile.IsNull() )
+    return false;
+  
+  Handle(HYDROData_ProfileUZ) aPrevProfile = GetProfileUZ();
+  if ( IsEqual( aPrevProfile, theProfile ) )
+    return true;
+
+  SetReferenceObject( theProfile, DataTag_ProfileUZ );
+
+  // Indicate model of the need to update the polyline presentation
+  SetToUpdate( true );
+
+  return true;
+}
+
+Handle(HYDROData_ProfileUZ) HYDROData_Polyline3D::GetProfileUZ() const
+{
+  return Handle(HYDROData_ProfileUZ)::DownCast( 
+           GetReferenceObject( DataTag_ProfileUZ ) );
+}
+
+void HYDROData_Polyline3D::RemoveProfileUZ()
+{
+  Handle(HYDROData_ProfileUZ) aPrevProfile = GetProfileUZ();
+  if ( aPrevProfile.IsNull() )
+    return;
+
+  ClearReferenceObjects( DataTag_ProfileUZ );
+
+  // Indicate model of the need to update the polyline presentation
+  SetToUpdate( true );
+}
+
diff --git a/src/HYDROData/HYDROData_Polyline3D.h b/src/HYDROData/HYDROData_Polyline3D.h
new file mode 100644 (file)
index 0000000..f45091b
--- /dev/null
@@ -0,0 +1,116 @@
+
+#ifndef HYDROData_Polyline3D_HeaderFile
+#define HYDROData_Polyline3D_HeaderFile
+
+#include "HYDROData_Object.h"
+
+DEFINE_STANDARD_HANDLE(HYDROData_Polyline3D, HYDROData_Object)
+
+class Handle(HYDROData_PolylineXY);
+class Handle(HYDROData_ProfileUZ);
+class gp_XYZ;
+
+/**\class HYDROData_Polyline3D
+ * \brief 
+ *
+ */
+class HYDROData_Polyline3D : public HYDROData_Object
+{
+public:
+
+  typedef gp_XYZ                                Polyline3DPoint;
+  typedef NCollection_Sequence<Polyline3DPoint> Polyline3DPoints;
+
+protected:
+  /**
+   * Enumeration of tags corresponding to the persistent object parameters.
+   */
+  enum DataTag
+  {
+    DataTag_First = HYDROData_Object::DataTag_First + 100, ///< first tag, to reserve
+    DataTag_PolylineXY,     ///< reference hydraulic axis
+    DataTag_ProfileUZ,      ///< reference profiles
+  };
+
+public:
+  DEFINE_STANDARD_RTTI(HYDROData_Polyline3D);
+
+  /**
+   * Returns the kind of this object. Must be redefined in all objects of known type.
+   */
+  HYDRODATA_EXPORT virtual const ObjectKind GetKind() const {return KIND_STREAM;}
+
+  /**
+   * Dump object to Python script representation.
+   */
+  HYDRODATA_EXPORT virtual QStringList DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const;
+
+  /**
+   * Returns the top shape of the object.
+   */
+  HYDRODATA_EXPORT virtual TopoDS_Shape GetTopShape() const;
+
+  /**
+   * Returns the 3d shape of the object.
+   */
+  HYDRODATA_EXPORT virtual TopoDS_Shape GetShape3D() const;
+
+  /**
+   * Update the shape presentations of stream.
+   * Call this method whenever you made changes for stream data.
+   */
+  HYDRODATA_EXPORT virtual void Update();
+
+
+public:      
+  // Public methods to work with 3D polyline
+  
+  /**
+   * Sets reference x,y polyline object for 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual bool SetPolylineXY( const Handle(HYDROData_PolylineXY)& thePolyline );
+
+  /**
+   * Returns reference x,y polyline object of 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual Handle(HYDROData_PolylineXY) GetPolylineXY() const;
+
+  /**
+   * Remove reference x,y polyline object from 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual void RemovePolylineXY();
+
+
+  /**
+   * Sets reference u,z profile object for 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual bool SetProfileUZ( const Handle(HYDROData_ProfileUZ)& theProfile );
+
+  /**
+   * Returns reference u,z profile object of 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual Handle(HYDROData_ProfileUZ) GetProfileUZ() const;
+
+  /**
+   * Remove reference u,z profile object from 3D polyline.
+   */
+  HYDRODATA_EXPORT virtual void RemoveProfileUZ();
+
+
+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_Polyline3D();
+
+  /**
+   * Destructs properties of the object and object itself, removes it from the document.
+   */
+  virtual HYDRODATA_EXPORT ~HYDROData_Polyline3D();
+};
+
+#endif
index 6c17dd6dc14dc37024eeebd86601e657c545f64f..0d79dd238678eeb86abac756dc34ea566189eda2 100755 (executable)
@@ -9,6 +9,11 @@
 #include <BRepBuilderAPI_MakeEdge.hxx>
 #include <BRepBuilderAPI_MakeWire.hxx>
 
 #include <BRepBuilderAPI_MakeEdge.hxx>
 #include <BRepBuilderAPI_MakeWire.hxx>
 
+#include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <GeomAdaptor_Curve.hxx>
+
+#include <GCPnts_AbscissaPoint.hxx>
+
 #include <ImageComposer_MetaTypes.h>
 
 #include <gp_Pnt.hxx>
 #include <ImageComposer_MetaTypes.h>
 
 #include <gp_Pnt.hxx>
@@ -80,7 +85,7 @@ QStringList HYDROData_PolylineXY::DumpToPython( MapOfTreatedObjects& theTreatedO
     HYDROData_PolylineXY::PointsList aSectPointsList = GetPoints( i );
     for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k )
     {
     HYDROData_PolylineXY::PointsList aSectPointsList = GetPoints( i );
     for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k )
     {
-      const HYDROData_PolylineXY::Point& aSectPoint = aSectPointsList.Value( k );
+      const Point& aSectPoint = aSectPointsList.Value( k );
 
       aResList << QString( "%1.AddPoint( %2, QPointF( %3, %4 ) );" ).arg( aPolylineName )
         .arg( i - 1 ).arg( aSectPoint.X() ).arg( aSectPoint.Y() );
 
       aResList << QString( "%1.AddPoint( %2, QPointF( %3, %4 ) );" ).arg( aPolylineName )
         .arg( i - 1 ).arg( aSectPoint.X() ).arg( aSectPoint.Y() );
@@ -105,6 +110,85 @@ TopoDS_Shape HYDROData_PolylineXY::GetShape()
   return getPolylineShape();
 }
 
   return getPolylineShape();
 }
 
+TopoDS_Wire HYDROData_PolylineXY::BuildWire( const SectionType&                  theType,
+                                             const bool&                         theIsClosed,
+                                             const NCollection_Sequence<gp_XYZ>& thePoints )
+{
+  BRepBuilderAPI_MakeWire aMakeWire;
+  
+  if( theType == SECTION_POLYLINE )
+  {
+    for( int i = 1, n = thePoints.Size(); i <= n; ++i )
+    {
+      const gp_XYZ& aFirstPoint = thePoints.Value( i );
+
+      gp_XYZ aLastPoint;
+      if ( i == n )
+      {
+        if( theIsClosed )
+          aLastPoint = thePoints.Value( 1 );
+        else
+          break;
+      }
+      else
+      {
+        aLastPoint = thePoints.Value( i + 1 );
+      }
+
+      gp_Pnt aPnt1( aFirstPoint.X(), aFirstPoint.Y(), aFirstPoint.Z() );
+      gp_Pnt aPnt2( aLastPoint.X(), aLastPoint.Y(), aLastPoint.Z() );
+
+      TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aPnt1, aPnt2 ).Edge();
+      aMakeWire.Add( anEdge );
+    }
+  }
+  else //if( theType == PolylineSection::SECTION_SPLINE )
+  {
+    HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed );
+
+    TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSpline.Curve() ).Edge();
+    aMakeWire.Add( anEdge );
+  }
+
+  TopoDS_Wire aWire;
+  aMakeWire.Build();
+  if ( aMakeWire.IsDone() )
+    aWire = aMakeWire;
+
+  return aWire;
+}
+
+QPainterPath HYDROData_PolylineXY::BuildPainterPath( const SectionType&                  theType,
+                                                     const bool&                         theIsClosed,
+                                                     const NCollection_Sequence<gp_XYZ>& thePoints )
+{
+  QPainterPath aPath;
+  if ( thePoints.IsEmpty() )
+    return aPath;
+
+  if ( theType == SECTION_POLYLINE )
+  {
+    aPath.moveTo( thePoints.Value( 1 ).X(), thePoints.Value( 1 ).Y() );
+
+    for( int i = 2, n = thePoints.Size(); i <= n; ++i )
+    {
+      const gp_XYZ& aSectPoint = thePoints.Value( i );
+
+      aPath.lineTo( aSectPoint.X(), aSectPoint.Y() );
+    }
+
+    if( theIsClosed )
+      aPath.closeSubpath();
+  }
+  else
+  {
+    HYDROData_BSplineOperation aBSpline( thePoints, theIsClosed );
+    aPath = aBSpline.ComputePath();
+  }
+
+  return aPath;
+}
+
 void HYDROData_PolylineXY::Update()
 {
   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
 void HYDROData_PolylineXY::Update()
 {
   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
@@ -125,50 +209,17 @@ void HYDROData_PolylineXY::Update()
     PointsList aSectPointsList = GetPoints( aSectionId - 1 );
     if ( aSectPointsList.IsEmpty() )
       continue;
     PointsList aSectPointsList = GetPoints( aSectionId - 1 );
     if ( aSectPointsList.IsEmpty() )
       continue;
-
-    BRepBuilderAPI_MakeWire aMakeSectionWire;
-    if( aSectionType == SECTION_POLYLINE )
+    
+    NCollection_Sequence<gp_XYZ> aPoints;
+    for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
     {
     {
-      for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
-      {
-        const Point& aFirstPoint = aSectPointsList.Value( i );
-
-        Point aLastPoint;
-        if ( i == n )
-        {
-          if( anIsSectionClosed )
-            aLastPoint = aSectPointsList.Value( 1 );
-          else
-            break;
-        }
-        else
-        {
-          aLastPoint = aSectPointsList.Value( i + 1 );
-        }
-
-        gp_Pnt aPnt1( aFirstPoint.X(), aFirstPoint.Y(), 0.0 );
-        gp_Pnt aPnt2( aLastPoint.X(), aLastPoint.Y(), 0.0 );
+      const Point& aSectPoint = aSectPointsList.Value( i );
 
 
-        TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aPnt1, aPnt2 ).Edge();
-        aMakeSectionWire.Add( anEdge );
-      }
+      gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
+      aPoints.Append( aPoint );
     }
     }
-    else //if( aSectionType == PolylineSection::SECTION_SPLINE )
-    {
-      QList<double> aPoints;
-      for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
-      {
-        const Point& aSectPoint = aSectPointsList.Value( i );
-        aPoints << aSectPoint.X() << aSectPoint.Y();
-      }
 
 
-      HYDROData_BSplineOperation aBSpline( aPoints, 0.0, anIsSectionClosed );
-
-      TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSpline.Curve() ).Edge();
-      aMakeSectionWire.Add( anEdge );
-    }
-   
-    TopoDS_Wire aSectionWire = aMakeSectionWire.Wire();
+    TopoDS_Wire aSectionWire = BuildWire( aSectionType, anIsSectionClosed, aPoints );
     aSectionWiresList.Append( aSectionWire );
     aMakeWire.Add( aSectionWire );
   }
     aSectionWiresList.Append( aSectionWire );
     aMakeWire.Add( aSectionWire );
   }
@@ -218,6 +269,70 @@ bool HYDROData_PolylineXY::IsClosed() const
   return anIsClosed;
 }
 
   return anIsClosed;
 }
 
+double HYDROData_PolylineXY::GetDistance( const int theSectionIndex,
+                                          const int thePointIndex ) const
+{
+  double aResDistance = -1;
+  if ( theSectionIndex < 0 || theSectionIndex >= NbSections() )
+    return aResDistance;
+
+  if ( thePointIndex == 0 )
+    return 0.0;
+
+  SectionType aSectionType = GetSectionType( theSectionIndex );
+  bool anIsSectionClosed = IsClosedSection( theSectionIndex );
+  PointsList aSectPointsList = GetPoints( theSectionIndex );
+  if ( thePointIndex < 0 || thePointIndex >= aSectPointsList.Size()  )
+    return aResDistance;
+
+  if ( aSectionType == SECTION_POLYLINE )
+  {
+    aResDistance = 0.0;
+  
+    Point aPrevPoint = aSectPointsList.Value( 1 );
+    for ( int i = 2, aNbPoints = aSectPointsList.Size(); i <= aNbPoints; ++i )
+    {
+      const Point& aSectPoint = aSectPointsList.Value( i );
+      aResDistance += gp_Pnt2d( aPrevPoint ).Distance( aSectPoint );
+      aPrevPoint = aSectPoint;
+    }
+  }
+  else
+  {
+    gp_XYZ aPointToTest;
+
+    int aSectNbPoints = aSectPointsList.Size();
+    NCollection_Sequence<gp_XYZ> aPoints;
+    for( int i = 1 ; i <= aSectNbPoints; ++i )
+    {
+      const Point& aSectPoint = aSectPointsList.Value( i );
+
+      gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
+      aPoints.Append( aPoint );
+
+      if ( thePointIndex == i - 1 )
+        aPointToTest = aPoint;
+    }
+
+    HYDROData_BSplineOperation aBSpline( aPoints, anIsSectionClosed );
+
+    Quantity_Parameter aFirstParam = aBSpline.Curve()->FirstParameter();
+    Quantity_Parameter aSecondParam = aBSpline.Curve()->LastParameter();
+
+    if ( thePointIndex != aSectNbPoints - 1 )
+    {
+      GeomAPI_ProjectPointOnCurve aProject( aPointToTest, aBSpline.Curve() );
+      aSecondParam = aProject.LowerDistanceParameter();
+    }
+
+    GeomAdaptor_Curve anAdap( aBSpline.Curve() );
+    
+    aResDistance = GCPnts_AbscissaPoint::Length( anAdap, aFirstParam, aSecondParam );
+  }
+
+  return aResDistance;
+}
+
 int HYDROData_PolylineXY::NbSections() const
 {
   Handle(TDataStd_ExtStringList) aNamesList;
 int HYDROData_PolylineXY::NbSections() const
 {
   Handle(TDataStd_ExtStringList) aNamesList;
@@ -636,34 +751,19 @@ QPainterPath HYDROData_PolylineXY::GetPainterPath() const
   SectionType aSectionType = aSectTypes.Value( 1 );
   bool anIsSectionClosed = aSectClosures.Value( 1 );
 
   SectionType aSectionType = aSectTypes.Value( 1 );
   bool anIsSectionClosed = aSectClosures.Value( 1 );
 
-  if ( aSectionType == SECTION_POLYLINE )
+  NCollection_Sequence<gp_XYZ> aPoints;
+  for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
   {
   {
-    aPath.moveTo( aSectPointsList.Value( 1 ).X(), aSectPointsList.Value( 1 ).Y() );
-
-    for( int i = 2, n = aSectPointsList.Size(); i <= n; ++i )
-    {
-      const Point& aSectPoint = aSectPointsList.Value( i );
+    const Point& aSectPoint = aSectPointsList.Value( i );
 
 
-      aPath.lineTo( aSectPoint.X(), aSectPoint.Y() );
-    }
-
-    if( anIsSectionClosed )
-      aPath.closeSubpath();
+    gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
+    aPoints.Append( aPoint );
   }
   }
-  else
-  {
-    QList<double> aPoints;
-    for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
-    {
-      const Point& aSectPoint = aSectPointsList.Value( i );
-      aPoints << aSectPoint.X() << aSectPoint.Y();
-    }
 
 
-    HYDROData_BSplineOperation aBSpline( aPoints, 0, anIsSectionClosed );
-    aPath = aBSpline.ComputePath();
-  }
+  aPath = BuildPainterPath( aSectionType, anIsSectionClosed, aPoints );
 
   return aPath;
 
   return aPath;
+
 }
 
 
 }
 
 
index 315fe7f1932d9988ca6ca8893b1040509df203d2..45ea7459654e8800e7663b331f880341c2389481 100644 (file)
@@ -7,6 +7,8 @@
 DEFINE_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
 
 class QPainterPath;
 DEFINE_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
 
 class QPainterPath;
+class TopoDS_Wire;
+class gp_XYZ;
 
 /**\class HYDROData_PolylineXY
  * \brief Class that stores/retreives information about the 
 
 /**\class HYDROData_PolylineXY
  * \brief Class that stores/retreives information about the 
@@ -43,6 +45,22 @@ public:
    */
   HYDRODATA_EXPORT virtual QVariant GetDataVariant();
 
    */
   HYDRODATA_EXPORT virtual QVariant GetDataVariant();
 
+public:
+
+  /**
+   * Returns the presentation of polyline section in CAS maner.
+   */
+  HYDRODATA_EXPORT static TopoDS_Wire BuildWire( const SectionType&                  theType,
+                                                 const bool&                         theIsClosed,
+                                                 const NCollection_Sequence<gp_XYZ>& thePoints );
+
+  /**
+   * Returns the presentation of polyline section in Qt maner.
+   */
+  HYDRODATA_EXPORT static QPainterPath BuildPainterPath( const SectionType&                  theType,
+                                                         const bool&                         theIsClosed,
+                                                         const NCollection_Sequence<gp_XYZ>& thePoints );
+
 public:
 
   /**
 public:
 
   /**
@@ -62,7 +80,14 @@ public:
    */
   HYDRODATA_EXPORT bool IsClosed() const;
 
    */
   HYDRODATA_EXPORT bool IsClosed() const;
 
-  
+   /**
+   * Returns the distance beetwen first and point with index thePointIndex
+   * at the section with index theSectionIndex. -1 is returned if error is occurred.
+   */
+  HYDRODATA_EXPORT double GetDistance( const int theSectionIndex,
+                                       const int thePointIndex ) const;
+
+
   /**
    * Returns number of sections.
    */
   /**
    * Returns number of sections.
    */
index d8ccba4e236cad9d0652b775da8e489342ec95bc..80fe9987309b306ecf9dc7ac997a2718e8577ec7 100755 (executable)
@@ -4,6 +4,7 @@
 #include "HYDROData_Tool.h"
 
 #include <gp_XY.hxx>
 #include "HYDROData_Tool.h"
 
 #include <gp_XY.hxx>
+#include <gp_Pnt2d.hxx>
 
 #include <TColStd_ListIteratorOfListOfReal.hxx>
 
 
 #include <TColStd_ListIteratorOfListOfReal.hxx>
 
@@ -30,6 +31,42 @@ TopoDS_Shape HYDROData_ProfileUZ::GetShape()
   return TopoDS_Shape();
 }
 
   return TopoDS_Shape();
 }
 
+double HYDROData_ProfileUZ::GetDepthFromDistance( const double& theDistance ) const
+{
+  double aResDepth = 0.0;
+
+  HYDROData_IPolyline::PointsList aPoints = GetPoints();
+  int aNbPoints = aPoints.Size();
+  if ( aNbPoints < 2 )
+    return aResDepth;
+
+  double aCompDist = 0.0;
+  HYDROData_IPolyline::Point aPrevPoint = aPoints.First();
+  for ( int i = 2; i <= aNbPoints; ++i )
+  {
+    const Point& aCurPoint = aPoints.Value( i );
+
+    double aPntDist = gp_Pnt2d( aPrevPoint.X(), 0 ).Distance( gp_Pnt2d( aCurPoint.X(), 0 ) );
+
+    aCompDist += aPntDist;
+
+    if ( theDistance < aCompDist )
+    {
+      double aComPntDist = gp_Pnt2d( aPoints.First().X(), 0 ).Distance( gp_Pnt2d( aPrevPoint.X(), 0 ) );
+
+      double aFindDist = theDistance - aComPntDist;
+      double aRatio = aFindDist / ( aPntDist - aFindDist );
+
+      aResDepth = ( aPrevPoint.Y() + aRatio * aCurPoint.Y() ) / ( 1 + aRatio );
+      break;
+    }
+
+    aPrevPoint = aCurPoint;
+  }
+
+  return aResDepth;
+}
+
 int HYDROData_ProfileUZ::NbSections() const
 {
   return 1;
 int HYDROData_ProfileUZ::NbSections() const
 {
   return 1;
index 3ec8fabcca118782ec206729e4b2436770f17a55..c485e944b5bc20a0f1861b368fe1e7bf81daa628 100644 (file)
@@ -37,6 +37,11 @@ public:
    */
   HYDRODATA_EXPORT virtual TopoDS_Shape GetShape();
 
    */
   HYDRODATA_EXPORT virtual TopoDS_Shape GetShape();
 
+  /**
+   * Returns the 3D presentation of all points.
+   */
+  HYDRODATA_EXPORT virtual double GetDepthFromDistance( const double& theDistance ) const;
+
 
   /**
    * Returns number of sections.
 
   /**
    * Returns number of sections.
index 33658760d4d4e1fac0460e4fd671c8ba9d90fd9f..f5310176fb5bfbf9d1a1a895e71f6e809f0d821a 100644 (file)
@@ -7,22 +7,27 @@
 void test_HYDROData_BSplineOperation::testCurve()
 {
   // prepare points: function of sin(x)
 void test_HYDROData_BSplineOperation::testCurve()
 {
   // prepare points: function of sin(x)
-  QList<double> aPoints;
-  double x;
-  for(x = 0; x < 6.28; x += 0.1)
-    aPoints<<x<<sin(x);
+  NCollection_Sequence<gp_XYZ> aPoints;
+  for ( double x = 0; x < 6.28; x += 0.1 )
+  {
+    gp_XYZ aPoint( x, sin( x ), 0.0 );
+    aPoints.Append( aPoint );
+  }
   // compute BSpline
   // compute BSpline
-  HYDROData_BSplineOperation aBSpline(aPoints, 0, false);
+  HYDROData_BSplineOperation aBSpline( aPoints, false );
+  
   Handle(Geom_BSplineCurve) aBS = aBSpline.Curve();
   Handle(Geom_BSplineCurve) aBS = aBSpline.Curve();
-  CPPUNIT_ASSERT(!aBS.IsNull());
-  CPPUNIT_ASSERT(!aBS->IsClosed());
-  CPPUNIT_ASSERT_EQUAL(aBS->Continuity(), GeomAbs_C2);
+  CPPUNIT_ASSERT( !aBS.IsNull() );
+  CPPUNIT_ASSERT( !aBS->IsClosed() );
+  CPPUNIT_ASSERT_EQUAL( aBS->Continuity(), GeomAbs_C2 );
+
   // check that values of BSpline are not far from original "sin" function
   // in all points of the curve
   // check that values of BSpline are not far from original "sin" function
   // in all points of the curve
-  for(x = 0; x < 6.29; x += 0.001) {
-    double aDiff = aBS->Value(x).Y() - sin(aBS->Value(x).X());
-    if (aDiff < 0) aDiff = -aDiff;
-    CPPUNIT_ASSERT(aDiff < 3.e-6); // this number is found manually
+  for ( double x = 0; x < 6.29; x += 0.001 )
+  {
+    double aDiff = aBS->Value( x ).Y() - sin( aBS->Value( x ).X() );
+    if ( aDiff < 0 ) aDiff = -aDiff;
+    CPPUNIT_ASSERT( aDiff < 3.e-6 ); // this number is found manually
   }
 }
 
   }
 }
 
@@ -30,15 +35,21 @@ void test_HYDROData_BSplineOperation::testPath()
 {
   // prepare points: function of sin(x)
   static const double aScale = 10000000.;
 {
   // prepare points: function of sin(x)
   static const double aScale = 10000000.;
-  QList<double> aPoints;
-  double x;
-  for(x = 0; x < 6.28; x += 0.1)
-    aPoints<<x*aScale<<sin(x) * aScale;
+
+  NCollection_Sequence<gp_XYZ> aPoints;
+  for ( double x = 0; x < 6.28; x += 0.1 )
+  {
+    gp_XYZ aPoint( x * aScale, sin( x ) * aScale, 0.0 );
+    aPoints.Append( aPoint );
+  }
+
   // convert to QPainterPath
   // convert to QPainterPath
-  HYDROData_BSplineOperation aBSpline(aPoints, 0, false);
-  CPPUNIT_ASSERT(!aBSpline.Curve().IsNull());
+  HYDROData_BSplineOperation aBSpline( aPoints, false );
+
+  CPPUNIT_ASSERT( !aBSpline.Curve().IsNull() );
+
   QPainterPath aPath = aBSpline.ComputePath();
   QPainterPath aPath = aBSpline.ComputePath();
-  CPPUNIT_ASSERT(!aPath.isEmpty());
+  CPPUNIT_ASSERT( !aPath.isEmpty() );
   
   /*
   QImage aPic(1300, 600, QImage::Format_RGB32);
   
   /*
   QImage aPic(1300, 600, QImage::Format_RGB32);
@@ -50,7 +61,7 @@ void test_HYDROData_BSplineOperation::testPath()
      
   // check that values of Path are not far from original "sin" function
   // in all points of the curve
      
   // check that values of Path are not far from original "sin" function
   // in all points of the curve
-  QList<QPolygonF> aPolyF = aPath.toSubpathPolygons(QTransform());
+  QList<QPolygonF> aPolyF = aPath.toSubpathPolygons( QTransform() );
   QList<QPolygonF>::iterator aFIter = aPolyF.begin();
   for(; aFIter != aPolyF.end();aFIter++) {
     QPolygon aPoly = aFIter->toPolygon();
   QList<QPolygonF>::iterator aFIter = aPolyF.begin();
   for(; aFIter != aPolyF.end();aFIter++) {
     QPolygon aPoly = aFIter->toPolygon();