src/HYDROData/HYDROData_Bathymetry.cxx

   1 // Copyright (C) 2014-2015  EDF-R&D
   2 // This library is free software; you can redistribute it and/or
   3 // modify it under the terms of the GNU Lesser General Public
   4 // License as published by the Free Software Foundation; either
   5 // version 2.1 of the License, or (at your option) any later version.
   6 //
   7 // This library is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10 // Lesser General Public License for more details.
  11 //
  12 // You should have received a copy of the GNU Lesser General Public
  13 // License along with this library; if not, write to the Free Software
  14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  15 //
  16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  17 //
  18
  19 #include "HYDROData_Bathymetry.h"
  20 #include "HYDROData_Document.h"
  21 #include "HYDROData_Tool.h"
  22 #include "HYDROData_PolylineXY.h"
  23
  24 #include <boost/math/special_functions/fpclassify.hpp>
  25
  26 #include <gp_XY.hxx>
  27 #include <gp_XYZ.hxx>
  28
  29 #include <TDataStd_RealArray.hxx>
  30 #include <TDataStd_AsciiString.hxx>
  31 #include <TDataStd_Integer.hxx>
  32
  33 #include <QFile>
  34 #include <QFileInfo>
  35 #include <QPointF>
  36 #include <QPolygonF>
  37 #include <QStringList>
  38
  39 #include <math.h>
  40
  41 // #define _TIMER
  42 #ifdef _TIMER
  43 #include <OSD_Timer.hxx>
  44 #endif
  45
  46 IMPLEMENT_STANDARD_HANDLE(HYDROData_Bathymetry, HYDROData_IAltitudeObject)
  47 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Bathymetry, HYDROData_IAltitudeObject)
  48
  49 HYDROData_Bathymetry::HYDROData_Bathymetry()
  50 : HYDROData_IAltitudeObject()
  51 {
  52 }
  53
  54 HYDROData_Bathymetry::~HYDROData_Bathymetry()
  55 {
  56 }
  57
  58 QStringList HYDROData_Bathymetry::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
  59 {
  60   QStringList aResList = dumpObjectCreation( theTreatedObjects );
  61   QString aBathymetryName = GetObjPyName();
  62
  63   aResList << QString( "%1.SetAltitudesInverted( %2 );" )
  64               .arg( aBathymetryName ).arg( IsAltitudesInverted() );
  65
  66   TCollection_AsciiString aFilePath = GetFilePath();
  67   aResList << QString( "%1.ImportFromFile( \"%2\" );" )
  68               .arg( aBathymetryName ).arg( aFilePath.ToCString() );
  69
  70   aResList << QString( "" );
  71   aResList << QString( "%1.Update();" ).arg( aBathymetryName );
  72   aResList << QString( "" );
  73
  74   return aResList;
  75 }
  76
  77 void HYDROData_Bathymetry::SetAltitudePoints( const AltitudePoints& thePoints )
  78 {
  79   RemoveAltitudePoints();
  80
  81   if ( thePoints.IsEmpty() )
  82     return;
  83
  84   // Save coordinates
  85   Handle(TDataStd_RealArray) aCoordsArray =
  86     TDataStd_RealArray::Set( myLab.FindChild( DataTag_AltitudePoints ), 0, thePoints.Length() * 3 - 1 );
  87
  88   AltitudePoints::Iterator anIter( thePoints );
  89   for ( int i = 0 ; anIter.More(); ++i, anIter.Next() )
  90   {
  91     const AltitudePoint& aPoint = anIter.Value();
  92
  93     aCoordsArray->SetValue( i * 3, aPoint.X() );
  94     aCoordsArray->SetValue( i * 3 + 1, aPoint.Y() );
  95     aCoordsArray->SetValue( i * 3 + 2, aPoint.Z() );
  96   }
  97
  98   SetToUpdate( true );
  99 }
 100
 101 HYDROData_Bathymetry::AltitudePoints HYDROData_Bathymetry::GetAltitudePoints() const
 102 {
 103   AltitudePoints aPoints;
 104
 105   TDF_Label aLabel = myLab.FindChild( DataTag_AltitudePoints, false );
 106   if ( aLabel.IsNull() )
 107     return aPoints;
 108
 109   Handle(TDataStd_RealArray) aCoordsArray;
 110   if ( !aLabel.FindAttribute( TDataStd_RealArray::GetID(), aCoordsArray ) )
 111     return aPoints;
 112
 113   for ( int i = aCoordsArray->Lower(), n = aCoordsArray->Upper(); i <= n; )
 114   {
 115     if ( i + 3 > n + 1 )
 116       break;
 117
 118     AltitudePoint aPoint;
 119     aPoint.SetX( aCoordsArray->Value( i++ ) );
 120     aPoint.SetY( aCoordsArray->Value( i++ ) );
 121     aPoint.SetZ( aCoordsArray->Value( i++ ) );
 122
 123     aPoints.Append( aPoint );
 124   }
 125
 126   return aPoints;
 127 }
 128
 129 void HYDROData_Bathymetry::RemoveAltitudePoints()
 130 {
 131   TDF_Label aLabel = myLab.FindChild( DataTag_AltitudePoints, false );
 132   if ( !aLabel.IsNull() )
 133   {
 134     aLabel.ForgetAllAttributes();
 135     SetToUpdate( true );
 136   }
 137 }
 138
 139 void interpolateAltitudeForPoints( const gp_XY&                               thePoint,
 140                                    const HYDROData_Bathymetry::AltitudePoint& theFirstPoint,
 141                                    const HYDROData_Bathymetry::AltitudePoint& theSecPoint,
 142                                    HYDROData_Bathymetry::AltitudePoint&       theResPoint,
 143                                    const bool&                                theIsVertical )
 144 {
 145   double aCoordX = thePoint.X();
 146   double aCoordY = thePoint.Y();
 147
 148   if ( theIsVertical )
 149   {
 150     aCoordX = theFirstPoint.X();
 151
 152     if ( !ValuesEquals( theFirstPoint.X(), theSecPoint.X() ) )
 153     {
 154       // Recalculate X coordinate by equation of line from two points
 155       aCoordX = ( ( ( thePoint.Y() - theFirstPoint.Y() ) * ( theSecPoint.X() - theFirstPoint.X() ) ) /
 156                   ( theSecPoint.Y() - theFirstPoint.Y() ) ) + theFirstPoint.X();
 157     }
 158   }
 159   else
 160   {
 161     aCoordY = theFirstPoint.Y();
 162
 163     if ( !ValuesEquals( theFirstPoint.Y(), theSecPoint.Y() ) )
 164     {
 165       // Recalculate y by equation of line from two points
 166       aCoordY = ( ( ( thePoint.X() - theFirstPoint.X() ) * ( theSecPoint.Y() - theFirstPoint.Y() ) ) /
 167                   ( theSecPoint.X() - theFirstPoint.X() ) ) + theFirstPoint.Y();
 168     }
 169   }
 170
 171   theResPoint.SetX( aCoordX );
 172   theResPoint.SetY( aCoordY );
 173
 174   // Calculate coefficient for interpolation
 175   double aLength = Sqrt( Pow( theSecPoint.Y() - theFirstPoint.Y(), 2 ) +
 176                          Pow( theSecPoint.X() - theFirstPoint.X(), 2 ) );
 177
 178   double aInterCoeff = 0;
 179   if ( aLength != 0 )
 180    aInterCoeff = ( theSecPoint.Z() - theFirstPoint.Z() ) / aLength;
 181
 182
 183   double aNewLength = Sqrt( Pow( theResPoint.Y() - theFirstPoint.Y(), 2 ) +
 184                             Pow( theResPoint.X() - theFirstPoint.X(), 2 ) );
 185
 186   // Calculate interpolated value
 187   double aResVal = theFirstPoint.Z() + aInterCoeff * aNewLength;
 188
 189   theResPoint.SetZ( aResVal );
 190 }
 191
 192 double HYDROData_Bathymetry::GetAltitudeForPoint( const gp_XY& thePoint ) const
 193 {
 194   double anInvalidAltitude = GetInvalidAltitude();
 195   double aResAltitude = anInvalidAltitude;
 196
 197   AltitudePoints anAltitudePoints = GetAltitudePoints();
 198   if ( anAltitudePoints.IsEmpty() )
 199     return aResAltitude;
 200
 201   QPolygonF aBoundingRect;
 202
 203   // Boundary plane
 204   // [ 0 (top-left) ]          [ 1 (top-right) ]
 205   //                  thePoint
 206   // [ 2 (bot-left) ]          [ 3 (bot-right) ]
 207   AltitudePoint aBounds[ 4 ] = { AltitudePoint( -DBL_MAX, -DBL_MAX, anInvalidAltitude ),
 208                                  AltitudePoint(  DBL_MAX, -DBL_MAX, anInvalidAltitude ),
 209                                  AltitudePoint( -DBL_MAX,  DBL_MAX, anInvalidAltitude ),
 210                                  AltitudePoint(  DBL_MAX,  DBL_MAX, anInvalidAltitude ) };
 211
 212   AltitudePoints::Iterator anIter( anAltitudePoints );
 213   for ( ; anIter.More(); anIter.Next() )
 214   {
 215     const AltitudePoint& aPoint = anIter.Value();
 216
 217     double aDeltaX = Abs( aPoint.X() ) - Abs( thePoint.X() );
 218     double aDeltaY = Abs( aPoint.Y() ) - Abs( thePoint.Y() );
 219
 220     if ( ValuesEquals( aDeltaX, 0.0 ) ) // Both left and right sides
 221     {
 222       if ( ValuesEquals( aDeltaY, 0.0 ) ) // Both top and bottom sides
 223       {
 224         aResAltitude = aPoint.Z();
 225         return aResAltitude;
 226       }
 227       else if ( aDeltaY < 0 ) // top side
 228       {
 229         // top border
 230         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 0 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 0 ].Y() ) )
 231           aBounds[ 0 ] = aPoint;
 232         if ( ValuesLessEquals( aPoint.X(), aBounds[ 1 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 1 ].Y() ) )
 233           aBounds[ 1 ] = aPoint;
 234       }
 235       else
 236       {
 237         // bottom border
 238         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 2 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 2 ].Y() ) )
 239           aBounds[ 2 ] = aPoint;
 240         if ( ValuesLessEquals( aPoint.X(), aBounds[ 3 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 3 ].Y() ) )
 241           aBounds[ 3 ] = aPoint;
 242       }
 243     }
 244     else if ( aDeltaX < 0 ) // left side
 245     {
 246       if ( ValuesEquals( aDeltaY, 0.0 ) )
 247       {
 248         // Left border
 249         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 0 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 0 ].Y() ) )
 250           aBounds[ 0 ] = aPoint;
 251         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 2 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 2 ].Y() ) )
 252           aBounds[ 2 ] = aPoint;
 253       }
 254       else if ( aDeltaY < 0 )
 255       {
 256         // top left corner
 257         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 0 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 0 ].Y() ) )
 258           aBounds[ 0 ] = aPoint;
 259       }
 260       else
 261       {
 262         // bottom left corner
 263         if ( ValuesMoreEquals( aPoint.X(), aBounds[ 2 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 2 ].Y() ) )
 264           aBounds[ 2 ] = aPoint;
 265       }
 266     }
 267     else // right side
 268     {
 269       if ( ValuesEquals( aDeltaY, 0.0 ) )
 270       {
 271         // Right border
 272         if ( ValuesLessEquals( aPoint.X(), aBounds[ 1 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 1 ].Y() ) )
 273           aBounds[ 1 ] = aPoint;
 274         if ( ValuesLessEquals( aPoint.X(), aBounds[ 3 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 3 ].Y() ) )
 275           aBounds[ 3 ] = aPoint;
 276       }
 277       else if ( aDeltaY < 0 )
 278       {
 279         // top right corner
 280         if ( ValuesLessEquals( aPoint.X(), aBounds[ 1 ].X() ) && ValuesMoreEquals( aPoint.Y(), aBounds[ 1 ].Y() ) )
 281           aBounds[ 1 ] = aPoint;
 282       }
 283       else
 284       {
 285         // bottom right corner
 286         if ( ValuesLessEquals( aPoint.X(), aBounds[ 3 ].X() ) && ValuesLessEquals( aPoint.Y(), aBounds[ 3 ].Y() ) )
 287           aBounds[ 3 ] = aPoint;
 288       }
 289     }
 290
 291     // Update bounding rectangle of our global grid
 292     aBoundingRect << QPointF( aPoint.X(), aPoint.Y() );
 293   }
 294
 295   const double LIMIT = 1E300;
 296   if( fabs( aBounds[ 0 ].X() ) > LIMIT || fabs( aBounds[ 0 ].Y() ) > LIMIT ||
 297       fabs( aBounds[ 1 ].X() ) > LIMIT || fabs( aBounds[ 1 ].Y() ) > LIMIT ||
 298       fabs( aBounds[ 2 ].X() ) > LIMIT || fabs( aBounds[ 2 ].Y() ) > LIMIT ||
 299       fabs( aBounds[ 3 ].X() ) > LIMIT || fabs( aBounds[ 3 ].Y() ) > LIMIT )
 300     return anInvalidAltitude;
 301
 302
 303   // Check if requested point is inside of our bounding rectangle
 304   if ( !aBoundingRect.boundingRect().contains( thePoint.X(), thePoint.Y() ) )
 305     return aResAltitude;
 306
 307   // Calculate result altitude for point
 308   AltitudePoint aFirstPoint( aBounds[ 0 ] ), aSecPoint( aBounds[ 1 ] );
 309
 310   // At first we merge top and bottom borders
 311   if ( aBounds[ 0 ].Y() != aBounds[ 2 ].Y() || aBounds[ 0 ].X() != aBounds[ 2 ].X() )
 312     interpolateAltitudeForPoints( thePoint, aBounds[ 0 ], aBounds[ 2 ], aFirstPoint, true );
 313
 314   if ( aBounds[ 1 ].Y() != aBounds[ 3 ].Y() || aBounds[ 1 ].X() != aBounds[ 3 ].X() )
 315     interpolateAltitudeForPoints( thePoint, aBounds[ 1 ], aBounds[ 3 ], aSecPoint, true );
 316
 317   AltitudePoint aResPoint( aFirstPoint );
 318
 319   // At last we merge left and right borders
 320   if ( aFirstPoint.Y() != aSecPoint.Y() || aFirstPoint.X() != aSecPoint.X() )
 321     interpolateAltitudeForPoints( thePoint, aFirstPoint, aSecPoint, aResPoint, false );
 322
 323   aResAltitude = aResPoint.Z();
 324
 325   return aResAltitude;
 326 }
 327
 328 void HYDROData_Bathymetry::SetFilePath( const TCollection_AsciiString& theFilePath )
 329 {
 330   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_FilePath ), theFilePath );
 331 }
 332
 333 TCollection_AsciiString HYDROData_Bathymetry::GetFilePath() const
 334 {
 335   TCollection_AsciiString aRes;
 336
 337   TDF_Label aLabel = myLab.FindChild( DataTag_FilePath, false );
 338   if ( !aLabel.IsNull() )
 339   {
 340     Handle(TDataStd_AsciiString) anAsciiStr;
 341     if ( aLabel.FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
 342       aRes = anAsciiStr->Get();
 343   }
 344
 345   return aRes;
 346 }
 347
 348 void HYDROData_Bathymetry::SetAltitudesInverted( const bool theIsInverted,
 349                                                  const bool theIsUpdate )
 350 {
 351   bool anIsAltitudesInverted = IsAltitudesInverted();
 352   if ( anIsAltitudesInverted == theIsInverted )
 353     return;
 354
 355   TDataStd_Integer::Set( myLab.FindChild( DataTag_AltitudesInverted ), (Standard_Integer)theIsInverted );
 356
 357   SetToUpdate( true );
 358
 359   if ( !theIsUpdate )
 360     return;
 361
 362   // Update altitude points
 363   AltitudePoints anAltitudePoints = GetAltitudePoints();
 364   if ( anAltitudePoints.IsEmpty() )
 365     return;
 366
 367   AltitudePoints::Iterator anIter( anAltitudePoints );
 368   for ( ; anIter.More(); anIter.Next() )
 369   {
 370     AltitudePoint& aPoint = anIter.ChangeValue();
 371     aPoint.SetZ( aPoint.Z() * -1 );
 372   }
 373
 374   SetAltitudePoints( anAltitudePoints );
 375 }
 376
 377 bool HYDROData_Bathymetry::IsAltitudesInverted() const
 378 {
 379   bool aRes = false;
 380
 381   TDF_Label aLabel = myLab.FindChild( DataTag_AltitudesInverted, false );
 382   if ( !aLabel.IsNull() )
 383   {
 384     Handle(TDataStd_Integer) anIntVal;
 385     if ( aLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) )
 386       aRes = (bool)anIntVal->Get();
 387   }
 388
 389   return aRes;
 390 }
 391
 392 bool HYDROData_Bathymetry::ImportFromFile( const TCollection_AsciiString& theFileName )
 393 {
 394   // Try to open the file
 395   QFile aFile( theFileName.ToCString() );
 396   if ( !aFile.exists() || !aFile.open( QIODevice::ReadOnly ) )
 397     return false;
 398
 399   bool aRes = false;
 400
 401   QString aFileSuf = QFileInfo( aFile ).suffix().toLower();
 402
 403   AltitudePoints aPoints;
 404
 405   // Try to import the file
 406   if ( aFileSuf == "xyz" )
 407     aRes = importFromXYZFile( aFile, aPoints );
 408
 409   // Close the file
 410   aFile.close();
 411
 412
 413   // Convert from global to local CS
 414   Handle_HYDROData_Document aDoc = HYDROData_Document::Document( myLab );
 415   AltitudePoints::Iterator anIter( aPoints );
 416   for ( ; anIter.More(); anIter.Next() )
 417   {
 418     AltitudePoint& aPoint = anIter.ChangeValue();
 419     aDoc->Transform( aPoint, true );
 420   }
 421
 422   if ( aRes )
 423   {
 424     // Update file path and altitude points of this Bathymetry
 425     SetFilePath( theFileName );
 426     SetAltitudePoints( aPoints );
 427   }
 428
 429   return aRes && !aPoints.IsEmpty();
 430 }
 431
 432 bool HYDROData_Bathymetry::importFromXYZFile( QFile&          theFile,
 433                                               AltitudePoints& thePoints ) const
 434 {
 435   if ( !theFile.isOpen() )
 436     return false;
 437
 438   // Strings in file is written as:
 439   //  1. X(float) Y(float) Z(float)
 440   //  2. X(float) Y(float) Z(float)
 441   //  ...
 442
 443 #ifdef _TIMER
 444   OSD_Timer aTimer;
 445   aTimer.Start();
 446 #endif
 447
 448   bool anIsAltitudesInverted = IsAltitudesInverted();
 449   while ( !theFile.atEnd() )
 450   {
 451     QString aLine = theFile.readLine().simplified();
 452     if ( aLine.isEmpty() )
 453       continue;
 454
 455     QStringList aValues = aLine.split( ' ', QString::SkipEmptyParts );
 456     if ( aValues.length() < 3 )
 457       return false;
 458
 459     AltitudePoint aPoint;
 460
 461     QString anX = aValues.value( 0 );
 462     QString anY = aValues.value( 1 );
 463     QString aZ  = aValues.value( 2 );
 464
 465     bool isXOk = false, isYOk = false, isZOk = false;
 466
 467     aPoint.SetX( anX.toDouble( &isXOk ) );
 468     aPoint.SetY( anY.toDouble( &isYOk ) );
 469     aPoint.SetZ( aZ.toDouble( &isZOk ) );
 470
 471     if ( !isXOk || !isYOk || !isZOk )
 472       return false;
 473
 474     if ( boost::math::isnan( aPoint.X() ) || boost::math::isinf( aPoint.X() ) ||
 475          boost::math::isnan( aPoint.Y() ) || boost::math::isinf( aPoint.Y() ) ||
 476          boost::math::isnan( aPoint.Z() ) || boost::math::isinf( aPoint.Z() ) )
 477       return false;
 478
 479     // Invert the z value if requested
 480     if ( anIsAltitudesInverted )
 481       aPoint.SetZ( -aPoint.Z() );
 482
 483     thePoints.Append( aPoint );
 484   }
 485
 486 #ifdef _TIMER
 487   aTimer.Stop();
 488   std::ofstream stream( "W:/HYDRO/WORK/log.txt", std::ofstream::out );
 489   aTimer.Show( stream );
 490 #endif
 491
 492   return true;
 493 }
 494
 495
 496 Handle_HYDROData_PolylineXY HYDROData_Bathymetry::CreateBoundaryPolyline() const
 497 {
 498   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 499   Handle_HYDROData_PolylineXY aResult =
 500     Handle_HYDROData_PolylineXY::DownCast( aDocument->CreateObject( KIND_POLYLINEXY ) );
 501
 502   if( aResult.IsNull() )
 503     return aResult;
 504
 505   //search free name
 506   QString aPolylinePref = GetName() + "_Boundary";
 507   QString aPolylineName = HYDROData_Tool::GenerateObjectName( aDocument, aPolylinePref );
 508   aResult->SetName( aPolylineName );
 509
 510   double Xmin = 0.0, Xmax = 0.0, Ymin = 0.0, Ymax = 0.0;
 511   bool isFirst = true;
 512   AltitudePoints aPoints = GetAltitudePoints();
 513
 514   AltitudePoints::Iterator anIter( aPoints );
 515   for ( ; anIter.More(); anIter.Next() )
 516   {
 517     const AltitudePoint& aPoint = anIter.Value();
 518
 519     double x = aPoint.X(), y = aPoint.Y();
 520     if( isFirst || x<Xmin )
 521       Xmin = x;
 522     if( isFirst || x>Xmax )
 523       Xmax = x;
 524     if( isFirst || y<Ymin )
 525       Ymin = y;
 526     if( isFirst || y>Ymax )
 527       Ymax = y;
 528     isFirst = false;
 529   }
 530
 531   aResult->AddSection( "bound", HYDROData_IPolyline::SECTION_POLYLINE, true );
 532   aResult->AddPoint( 0, HYDROData_IPolyline::Point( Xmin, Ymin ) );
 533   aResult->AddPoint( 0, HYDROData_IPolyline::Point( Xmin, Ymax ) );
 534   aResult->AddPoint( 0, HYDROData_IPolyline::Point( Xmax, Ymax ) );
 535   aResult->AddPoint( 0, HYDROData_IPolyline::Point( Xmax, Ymin ) );
 536   aResult->Update();
 537
 538   return aResult;
 539 }
 540
 541 void HYDROData_Bathymetry::UpdateLocalCS( double theDx, double theDy )
 542 {
 543   gp_XYZ aDelta( theDx, theDy, 0 );
 544   AltitudePoints aPoints = GetAltitudePoints();
 545   AltitudePoints::Iterator anIter( aPoints );
 546   for ( int i = 0 ; anIter.More(); ++i, anIter.Next() )
 547   {
 548     AltitudePoint& aPoint = anIter.ChangeValue();
 549     aPoint += aDelta;
 550   }
 551   SetAltitudePoints( aPoints );
 552 }
 553