{
std::vector<double> aResultProfile;
- if ( theProfileIndex > 0 && theProfileIndex < (int) myResultProfiles.size() ) {
+ if ( theProfileIndex >= 0 && theProfileIndex < (int) myResultProfiles.size() ) {
aResultProfile = myResultProfiles.at( theProfileIndex );
}
void HYDROData_IProfilesInterpolator::Reset()
{
+ // Reset input parameters
myProfile1.clear();
myProfile2.clear();
myParameters.clear();
SetResultProfilesNumber( DEFAULT_RESULT_PROFILES_NB );
+ // Reset result data
+ ClearResults();
+}
+
+std::vector<double> HYDROData_IProfilesInterpolator::GetFirstProfile() const
+{
+ return myProfile1;
+}
+
+std::vector<double> HYDROData_IProfilesInterpolator::GetSecondProfile() const
+{
+ return myProfile2;
+}
+
+void HYDROData_IProfilesInterpolator::ClearResults()
+{
+ // Clear result data
myResultProfiles.clear();
+ // Reset errors
SetErrorCode( OK );
SetErrorMessage( "" );
+}
+
+int HYDROData_IProfilesInterpolator::GetNbProfilesToCompute() const
+{
+ return myResultProfilesNumber;
+}
+
+void HYDROData_IProfilesInterpolator::InsertResultProfile( const std::vector<double>& theProfile )
+{
+ myResultProfiles.push_back( theProfile );
}
\ No newline at end of file
/**
* Perform interpolation calculations.
*/
- HYDRODATA_EXPORT virtual InterpolationError Calculate() = 0;
+ HYDRODATA_EXPORT virtual void Calculate() = 0;
+ /**
+ * Get number of calculated profiles ( could be less than the number of profiles to be computed set as a parameter ).
+ * @return the number of really calculated profiles
+ */
HYDRODATA_EXPORT virtual int GetCalculatedProfilesNumber() const;
/**
*/
HYDRODATA_EXPORT virtual void SetErrorMessage( const std::string& theMessage );
+ /**
+ * Get the first profile.
+ * \return the first profile points
+ */
+ HYDRODATA_EXPORT std::vector<double> GetFirstProfile() const;
+
+ /**
+ * Get the second profile.
+ * \return the second profile points
+ */
+ HYDRODATA_EXPORT std::vector<double> GetSecondProfile() const;
+
+ /**
+ * Get number of profiles to compute.
+ * \return the current value of number of result profiles parameter
+ */
+ HYDRODATA_EXPORT virtual int GetNbProfilesToCompute() const;
+
+ /**
+ * Clear result data (including errors).
+ */
+ HYDRODATA_EXPORT void ClearResults();
+
+ /**
+ * Insert the calculated profile to the resuls.
+ * \param theProfile the profile to insert
+ */
+ HYDRODATA_EXPORT void InsertResultProfile( const std::vector<double>& theProfile );
+
private:
std::vector<double> myProfile1, myProfile2; ///< the two input profiles
int myResultProfilesNumber; ///< the number of profiles to compute
return aDescription;
}
-InterpolationError HYDROData_LinearInterpolator::Calculate()
+void HYDROData_LinearInterpolator::Calculate()
{
- return OK;
+ // Reset result data
+ ClearResults();
+
+ // Check input data
+ std::vector<double> aProfile1 = GetFirstProfile();
+ std::vector<double> aProfile2 = GetSecondProfile();
+ int aNbProfilesToCompute = GetNbProfilesToCompute();
+
+ int aSize1 = aProfile1.size();
+ int aSize2 = aProfile2.size();
+
+ div_t aDiv1 = std::div( aSize1, 3 );
+ div_t aDiv2 = std::div( aSize2, 3 );
+
+ if ( aNbProfilesToCompute < 1 ||
+ aSize1 < 2 || aDiv1.rem != 0 ||
+ aSize2 < 2 || aDiv2.rem != 0 ) {
+ SetErrorCode( InvalidParametersError );
+ return;
+ }
+
+ bool isSame = false;
+ if ( aSize1 < aSize2 ) {
+ isSame = std::equal( aProfile1.begin(), aProfile1.end(), aProfile2.begin() );
+ } else {
+ isSame = std::equal( aProfile2.begin(), aProfile2.end(), aProfile1.begin() );
+ }
+
+ if ( isSame ) {
+ SetErrorCode( InvalidParametersError );
+ return;
+ }
+
+ // Linear interpolation
+ InterpolationError aStatus = OK;
+
+ // the first profile should have the equal or less number of points than the second profile
+ int aNbPoints1 = aDiv1.quot;
+ int aNbPoints2 = aDiv2.quot;
+ if ( aNbPoints1 > aNbPoints2 ) {
+ aProfile1.swap( aProfile2 );
+ std::swap( aNbPoints1, aNbPoints2 );
+ }
+
+ for ( int k = 0; k <= aNbProfilesToCompute - 1; k++ ) {
+ std::vector<double> aResultProfile; ///< the k-th computed profile
+
+ double aRelParam = (double)( k + 1 ) / ( aNbProfilesToCompute + 1 );
+ for ( int i = 0; i <= aNbPoints1 - 1; i++ ) {
+ double aRel = ( aNbPoints2 - 1 ) / ( aNbPoints1 - 1 );
+ int aPointIndex = (int) std::floor( aRel * i ); ///< point index in the second profile
+ int anXindex1 = i * 3;
+ int anXindex2 = aPointIndex * 3;
+
+ double anXi = ( aProfile1[anXindex1] * ( 1 - aRelParam ) ) + ( aProfile2[anXindex2] * aRelParam );
+ double anYi = ( aProfile1[anXindex1 + 1] * ( 1 - aRelParam ) ) + ( aProfile2[anXindex2 + 1] * aRelParam );
+ double aZi = ( aProfile1[anXindex1 + 2] * ( 1 - aRelParam ) ) + ( aProfile2[anXindex2 + 2] * aRelParam );
+
+ aResultProfile.push_back( anXi );
+ aResultProfile.push_back( anYi );
+ aResultProfile.push_back( aZi );
+ }
+
+ InsertResultProfile( aResultProfile );
+ }
+
+ SetErrorCode( aStatus );
}
\ No newline at end of file
/**
*
*/
- HYDRODATA_EXPORT virtual InterpolationError Calculate();
+ HYDRODATA_EXPORT virtual void Calculate();
};
#endif
#include "HYDROData_ShapesGroup.h"
#include "HYDROData_ShapesTool.h"
#include "HYDROData_IAltitudeObject.h"
+#include "HYDROData_IProfilesInterpolator.h"
#include "HYDROData_Tool.h"
#include <TDataStd_RealArray.hxx>
GetReferenceObject( DataTag_BottomPolyline ) );
}
-bool HYDROData_Stream::Interpolate( const HYDROData_IProfilesInterpolator* theInterpolator )
+bool HYDROData_Stream::Interpolate( HYDROData_IProfilesInterpolator* theInterpolator )
{
- ///< \todo this is just a stub
- return true;
+ // Get the document
+ Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+ if ( aDocument.IsNull() ) {
+ return false;
+ }
+
+ if ( theInterpolator->GetCalculatedProfilesNumber() < 1 ) {
+ theInterpolator->Calculate();
+ }
+
+ if ( theInterpolator->GetErrorCode() != OK ) {
+ return false;
+ }
+
+ bool isOK = true;
+
+ for ( int aProfileInd = 0; aProfileInd < theInterpolator->GetCalculatedProfilesNumber(); aProfileInd++ ) {
+ // Get calculated point coordinates
+ std::vector<double> aResultCoords = theInterpolator->GetResultProfile( aProfileInd );
+ div_t aDiv = std::div( aResultCoords.size(), 3 );
+ if ( aDiv.rem != 0 ) {
+ isOK = false;
+ continue;
+ }
+
+ // Create profile object
+ Handle(HYDROData_Profile) aProfile =
+ Handle(HYDROData_Profile)::DownCast( aDocument->CreateObject( KIND_PROFILE ) );
+ QString aBaseName = GetName() + "_interp_profile";
+ QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName );
+ aProfile->SetName( aName );
+
+ // Fill the profile with points
+ HYDROData_Profile::ProfilePoints aProfilePoints;
+
+ int aPointsNb = aDiv.quot;
+ for ( int aPointInd = 0; aPointInd <= aPointsNb - 1; aPointInd++ ) {
+ int anXindex = aPointInd * 3;
+ double anX = aResultCoords[ anXindex ];
+ double anY = aResultCoords[ anXindex + 1 ];
+ double aZ = aResultCoords[ anXindex + 2 ];
+
+ aProfilePoints.Append( gp_XYZ( anX, anY, aZ ) );
+ }
+
+ aProfile->SetProfilePoints( aProfilePoints );
+
+ // Add profile to the stream
+ isOK = AddProfile( aProfile ) && isOK;
+ }
+
+ return isOK;
}
\ No newline at end of file
* \param theInterpolator the interpolator
* \return true in case of success
*/
- HYDRODATA_EXPORT virtual bool Interpolate( const HYDROData_IProfilesInterpolator* theInterpolator );
+ HYDRODATA_EXPORT virtual bool Interpolate( HYDROData_IProfilesInterpolator* theInterpolator );
protected:
if ( !aRiver.IsNull() )
{
startDocOperation();
- //aRiver->Interpolate( anIterp );
+ aRiver->Interpolate( anIterp );
if ( anIterp->GetErrorCode() == OK )
commitDocOperation();
else
if ( anIterp )
{
updateInterpolator( anIterp );
- if ( anIterp->Calculate() == OK )
+ anIterp->Calculate();
+ if ( anIterp->GetErrorCode() == OK )
{
- TopoDS_Shape aShape = previewShape( anIterp, aDlg->profileNumber() );
+ TopoDS_Shape aShape = previewShape( anIterp );
if ( !aShape.IsNull() )
{
myPreview = new AIS_Shape( aShape );
return aRes;
}
-TopoDS_Shape HYDROGUI_ProfileInterpolateOp::previewShape( HYDROData_IProfilesInterpolator* theInterp, int theNumber ) const
+TopoDS_Shape HYDROGUI_ProfileInterpolateOp::previewShape( HYDROData_IProfilesInterpolator* theInterp ) const
{
TopoDS_Compound aPreviewShape;
if ( theInterp )
{
BRep_Builder aBuilder;
aBuilder.MakeCompound( aPreviewShape );
- for ( int i = 0; i < theNumber; i++ )
+ for ( int i = 0; i < theInterp->GetCalculatedProfilesNumber(); i++ )
{
NCollection_Sequence<gp_XYZ> pointSeq;
std::vector<double> aPoints = theInterp->GetResultProfile( i );
- for ( int i = 0; i < aPoints.size(); i += 3 )
+ for ( int i = 0; i < (int) aPoints.size(); i += 3 )
pointSeq.Append( gp_XYZ( aPoints[i], aPoints[i+1], aPoints[i+2] ) );
TopoDS_Shape aWire = HYDROData_PolylineXY::BuildWire( HYDROData_IPolyline::SECTION_SPLINE, false, pointSeq );
if ( !aWire.IsNull() )
ParamsList parameters( const QString& ) const;
QString parameters( const ParamsList& ) const;
- TopoDS_Shape previewShape( HYDROData_IProfilesInterpolator*, int ) const;
+ TopoDS_Shape previewShape( HYDROData_IProfilesInterpolator* ) const;
private slots:
void updatePreview();
