src/HYDRO_tests/test_HYDROData_LandCoverMap.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 <test_HYDROData_LandCoverMap.h>
  20 #include <HYDROData_CalculationCase.h>
  21 #include <HYDROData_Document.h>
  22 #include <HYDROData_LandCoverMap.h>
  23 #include <HYDROData_ImmersibleZone.h>
  24 #include <HYDROData_PolylineXY.h>
  25 #include <HYDROData_StricklerTable.h>
  26 #include <HYDROData_Tool.h>
  27 #include <HYDROData_ShapeFile.h>
  28 #include <HYDROGUI_LandCoverMapPrs.h>
  29 #include <TopoDS_Edge.hxx>
  30 #include <TopoDS_Wire.hxx>
  31 #include <TopoDS_Face.hxx>
  32 #include <TopoDS.hxx>
  33 #include <TestViewer.h>
  34 #include <TestShape.h>
  35 #include <TopTools_ListOfShape.hxx>
  36 #include <AIS_DisplayMode.hxx>
  37 #include <BRepMesh_IncrementalMesh.hxx>
  38 #include <QString>
  39 #include <QColor>
  40 #include <QMap>
  41 #include <QDir>
  42 #include <BRepTools.hxx>
  43 #include <BRep_Builder.hxx>
  44 #include <BRepCheck_Analyzer.hxx>
  45 #include <OSD_Timer.hxx>
  46 #include <TopTools_ListIteratorOfListOfShape.hxx>
  47
  48 #define _DEVDEBUG_
  49 #include "HYDRO_trace.hxx"
  50
  51 extern QString REF_DATA_PATH;
  52 const QString DEF_STR_PATH = qgetenv( "HYDRO_ROOT_DIR" ) + "/share/salome/resources/hydro/def_strickler_table_06.txt";
  53 extern QString TMP_DIR;
  54
  55 void test_HYDROData_LandCoverMap::test_add_2_objects()
  56 {
  57   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
  58
  59   Handle(HYDROData_LandCoverMap) aMap =
  60     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
  61
  62   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
  63
  64   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 50 << 20 << 30 << 50 << 15 << 30 );
  65   //DEBTRACE("--- ajout test1 " << aLC1);
  66   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
  67
  68   TopoDS_Face aLC2 = Face2d( QList<double>() << 30 << 20 << 60 << 10 << 70 << 35 << 40 << 40 );
  69   //DEBTRACE("--- ajout test2 " << aLC2);
  70   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, "test2" ) );
  71
  72   HYDROData_LandCoverMap::Explorer anIt( aMap );
  73   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
  74   //DEBTRACE(anIt.Face() << " " << anIt.StricklerType());
  75   CPPUNIT_ASSERT_EQUAL( QString( "test1" ), anIt.StricklerType() );
  76   anIt.Next();
  77   //DEBTRACE(anIt.Face() << " " << anIt.StricklerType());
  78   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
  79   CPPUNIT_ASSERT_EQUAL( QString( "test2" ), anIt.StricklerType() );
  80   anIt.Next();
  81   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
  82
  83   //DEBTRACE("--- show")
  84   TestViewer::show( aMap->GetShape(), AIS_Shaded, true, "LandCoverMap_Add_2_Objects" );
  85   CPPUNIT_ASSERT_IMAGES
  86
  87   anIt.Init(*aMap);
  88   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
  89   //DEBTRACE(anIt.Face() << " " << anIt.StricklerType());
  90   CPPUNIT_ASSERT_EQUAL( QString( "test1" ), anIt.StricklerType() );
  91   anIt.Next();
  92   //DEBTRACE(anIt.Face() << " " << anIt.StricklerType());
  93   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
  94   CPPUNIT_ASSERT_EQUAL( QString( "test2" ), anIt.StricklerType() );
  95   anIt.Next();
  96   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
  97
  98   aDoc->Close();
  99 }
 100
 101 void test_HYDROData_LandCoverMap::test_split()
 102 {
 103   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 104
 105   Handle(HYDROData_LandCoverMap) aMap =
 106     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 107
 108   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 109
 110   TopoDS_Face aLC = Face2d( QList<double>() << 10 << 10 << 50 << 20 << 30 << 50 << 15 << 30 );
 111   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC, "test1" ) );
 112
 113   Handle(HYDROData_PolylineXY) aPolyline =
 114     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 115   TopoDS_Wire aWire = Wire2d( QList<double>() << 10 << 40 << 30 << 10 << 40 << 10 << 60 << 10, false );
 116   aPolyline->SetShape( aWire );
 117
 118   CPPUNIT_ASSERT_EQUAL( true, aMap->Split( aPolyline ) );
 119
 120   TestViewer::show( aMap->GetShape(), AIS_Shaded, true, "LandCoverMap_Split_1" );
 121   TestViewer::show( aWire, 0, true, Qt::blue );
 122   CPPUNIT_ASSERT_IMAGES
 123
 124   HYDROData_LandCoverMap::Explorer anIt( aMap );
 125   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
 126   CPPUNIT_ASSERT_EQUAL( QString( "test1" ), anIt.StricklerType() );
 127   anIt.Next();
 128   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
 129   CPPUNIT_ASSERT_EQUAL( QString( "test1" ), anIt.StricklerType() );
 130   anIt.Next();
 131   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
 132
 133   aDoc->Close();
 134 }
 135
 136 void test_HYDROData_LandCoverMap::test_incomplete_split()
 137 {
 138   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 139
 140   Handle(HYDROData_LandCoverMap) aMap =
 141     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 142
 143   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 144
 145   TopoDS_Face aLC = Face2d( QList<double>() << 10 << 10 << 50 << 20 << 30 << 50 << 15 << 30 );
 146   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC, "test1" ) );
 147
 148   Handle(HYDROData_PolylineXY) aPolyline =
 149     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 150   TopoDS_Wire aWire = Wire2d( QList<double>() << 10 << 40 << 30 << 10 << 40 << 10, false );
 151   aPolyline->SetShape( aWire );
 152
 153   CPPUNIT_ASSERT_EQUAL( false, aMap->Split( aPolyline ) );
 154
 155   TestViewer::show( aMap->GetShape(), AIS_Shaded, true, "LandCoverMap_Split_2" );
 156   TestViewer::show( aWire, 0, true, Qt::green );
 157   CPPUNIT_ASSERT_IMAGES
 158
 159   HYDROData_LandCoverMap::Explorer anIt( aMap );
 160   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
 161   CPPUNIT_ASSERT_EQUAL( QString( "test1" ), anIt.StricklerType() );
 162   anIt.Next();
 163   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
 164
 165   aDoc->Close();
 166 }
 167
 168 void test_HYDROData_LandCoverMap::test_merge()
 169 {
 170   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 171
 172   Handle(HYDROData_LandCoverMap) aMap =
 173     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 174
 175   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 176
 177   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 178
 179   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 180
 181   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 182                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 183                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 184                                               31 << 114 );
 185   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, "test2" ) );
 186
 187   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 188                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 189   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, "test3" ) );
 190
 191   //TestViewer::show( aMap->GetShape(), AIS_Shaded, true );
 192   //TestViewer::AssertEqual( "LandCoverMap_Before_Merge" );
 193
 194   //BRepTools::Write( aMap->GetShape(), "c:\\map.brep" );
 195
 196   QString aType1, aType2;
 197   gp_Pnt2d aPnt1( 25, 35 );
 198   gp_Pnt2d aPnt2( 45, 55 );
 199   //gp_Pnt2d aPnt3( 45, 10 );
 200   //gp_Pnt2d aPnt4( 45, 80 );
 201   TopTools_ListOfShape aList;
 202   aList.Append( aMap->FindByPoint( aPnt1, aType1 ) );
 203   aList.Append( aMap->FindByPoint( aPnt2, aType2 ) );
 204   CPPUNIT_ASSERT_EQUAL( true, aMap->Merge( aList, "new" ) );
 205
 206   TestViewer::show( aMap->GetShape(), AIS_Shaded, true, "LandCoverMap_Merge_1" );
 207   //TestViewer::show( BRepBuilderAPI_MakeEdge( gp_Pnt(aPnt1.X(), aPnt1.Y(), 0), gp_Pnt(aPnt2.X(), aPnt2.Y(), 0) ).Edge(), QColor( Qt::blue ), AIS_Shaded );
 208   CPPUNIT_ASSERT_IMAGES
 209
 210   aDoc->Close();
 211 }
 212
 213 void test_HYDROData_LandCoverMap::test_merge_refs_691()
 214 {
 215   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 216
 217   Handle(HYDROData_PolylineXY) Polyline_4 =
 218     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 219   Polyline_4->SetName( "test_Polyline_4" );
 220   Polyline_4->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 221   Polyline_4->AddPoint( 0, gp_XY( -242.741935, -16.129032 ) );
 222   Polyline_4->AddPoint( 0, gp_XY( -339.516129, -95.161290 ) );
 223   Polyline_4->AddPoint( 0, gp_XY( -204.032258, -167.740000 ) );
 224   Polyline_4->AddPoint( 0, gp_XY( -86.290000, -158.060000 ) );
 225   Polyline_4->AddPoint( 0, gp_XY( -83.064516, -37.096774 ) );
 226   Polyline_4->AddPoint( 0, gp_XY( -116.935484, 17.741935 ) );
 227   Polyline_4->AddSection( "Section_2", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 228   Polyline_4->AddPoint( 1, gp_XY( -239.516129, -295.161290 ) );
 229   Polyline_4->AddPoint( 1, gp_XY( -204.030000, -167.740000 ) );
 230   Polyline_4->AddPoint( 1, gp_XY( -86.290000, -158.060000 ) );
 231   Polyline_4->AddPoint( 1, gp_XY( -2.419355, -288.709677 ) );
 232   Polyline_4->AddPoint( 1, gp_XY( -165.322581, -351.612903 ) );
 233   Polyline_4->Update();
 234
 235   Handle(HYDROData_LandCoverMap) aMap =
 236     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 237
 238   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_4, "test" ) );
 239
 240   TopTools_ListOfShape aList;
 241   HYDROData_LandCoverMap::Explorer anIt( aMap );
 242   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
 243   CPPUNIT_ASSERT_EQUAL( QString( "test" ), anIt.StricklerType() );
 244   aList.Append( anIt.Face() );
 245   anIt.Next();
 246   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
 247   CPPUNIT_ASSERT_EQUAL( QString( "test" ), anIt.StricklerType() );
 248   aList.Append( anIt.Face() );
 249   anIt.Next();
 250   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
 251
 252   BRepCheck_Analyzer aCheck1( aMap->GetShape() );
 253   CPPUNIT_ASSERT_EQUAL( true, (bool)aCheck1.IsValid() );
 254
 255   CPPUNIT_ASSERT_EQUAL( true, aMap->Merge( aList, "test" ) );
 256
 257   BRepCheck_Analyzer aCheck2( aMap->GetShape() );
 258   CPPUNIT_ASSERT_EQUAL( true, (bool)aCheck2.IsValid() );
 259
 260   // we try construct the triangulation to check that it is correct
 261   BRepMesh_IncrementalMesh anIncMesh( aMap->GetShape(), 0.01 );
 262   CPPUNIT_ASSERT_EQUAL( true, (bool)anIncMesh.IsDone() );
 263   BRepCheck_Analyzer aCheck3( aMap->GetShape() );
 264   CPPUNIT_ASSERT_EQUAL( true, (bool)aCheck3.IsValid() );
 265
 266   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 267   TestViewer::show( aPrs, AIS_Shaded, 0, true, "LandCoverMap_Merge_2" );
 268   CPPUNIT_ASSERT_IMAGES
 269
 270   aDoc->Close();
 271 }
 272
 273 void test_HYDROData_LandCoverMap::test_remove()
 274 {
 275   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 276
 277   Handle(HYDROData_LandCoverMap) aMap =
 278     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 279
 280   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 281
 282   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 283
 284   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 285
 286   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 287                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 288                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 289                                               31 << 114 );
 290   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, "test2" ) );
 291
 292   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 293                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 294   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, "test3" ) );
 295
 296   QString aType1, aType2;
 297   gp_Pnt2d aPnt1( 25, 35 );
 298   gp_Pnt2d aPnt2( 45, 55 );
 299   TopTools_ListOfShape aList;
 300   aList.Append( aMap->FindByPoint( aPnt1, aType1 ) );
 301   aList.Append( aMap->FindByPoint( aPnt2, aType2 ) );
 302   CPPUNIT_ASSERT_EQUAL( true, aMap->Remove( aList ) );
 303
 304   TestViewer::show( aMap->GetShape(), AIS_Shaded, true, "LandCoverMap_Remove_1" );
 305   CPPUNIT_ASSERT_IMAGES
 306
 307   aDoc->Close();
 308 }
 309
 310 void test_HYDROData_LandCoverMap::test_merge_faces_boxes()
 311 {
 312   TopoDS_Shape pp1, pp2, pp3, pp4;
 313   BRep_Builder BB;
 314   BRepTools::Read(pp1, (REF_DATA_PATH + "/pp1.brep").toStdString().c_str(), BB);
 315   BRepTools::Read(pp2, (REF_DATA_PATH + "/pp2.brep").toStdString().c_str(), BB);
 316   BRepTools::Read(pp3, (REF_DATA_PATH + "/pp3.brep").toStdString().c_str(), BB);
 317   BRepTools::Read(pp4, (REF_DATA_PATH + "/pp4.brep").toStdString().c_str(), BB);
 318
 319   CPPUNIT_ASSERT(!pp1.IsNull());
 320   CPPUNIT_ASSERT(!pp2.IsNull());
 321   CPPUNIT_ASSERT(!pp3.IsNull());
 322   CPPUNIT_ASSERT(!pp4.IsNull());
 323
 324   //Test mergeFaces() func // boxes // USD == true
 325   {
 326     TopTools_ListOfShape Faces;
 327     Faces.Append(pp1);
 328     Faces.Append(pp2);
 329     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 330     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_11" );
 331     CPPUNIT_ASSERT_IMAGES
 332     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_FACE);
 333     BRepCheck_Analyzer aBCA(aMergedFace);
 334     CPPUNIT_ASSERT(aBCA.IsValid());
 335   }
 336   {
 337     TopTools_ListOfShape Faces;
 338     Faces.Append(pp1);
 339     Faces.Append(pp3);
 340     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 341     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_12" );
 342     CPPUNIT_ASSERT_IMAGES
 343     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 344     BRepCheck_Analyzer aBCA(aMergedFace);
 345     CPPUNIT_ASSERT(aBCA.IsValid());
 346   }
 347   {
 348     TopTools_ListOfShape Faces;
 349     Faces.Append(pp1);
 350     Faces.Append(pp2);
 351     Faces.Append(pp4);
 352     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 353     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_13" );
 354     CPPUNIT_ASSERT_IMAGES
 355     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 356     BRepCheck_Analyzer aBCA(aMergedFace);
 357     CPPUNIT_ASSERT(aBCA.IsValid());
 358   }
 359   {
 360     TopTools_ListOfShape Faces;
 361     Faces.Append(pp1);
 362     Faces.Append(pp3);
 363     Faces.Append(pp4);
 364     Faces.Append(pp2);
 365     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 366     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_14" );
 367     CPPUNIT_ASSERT_IMAGES
 368     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_FACE);
 369     BRepCheck_Analyzer aBCA(aMergedFace);
 370     CPPUNIT_ASSERT(aBCA.IsValid());
 371   }
 372   //
 373
 374   //Test mergeFaces() func // boxes // USD == false
 375   {
 376     TopTools_ListOfShape Faces;
 377     Faces.Append(pp1);
 378     Faces.Append(pp2);
 379     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 380     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_21" );
 381     CPPUNIT_ASSERT_IMAGES
 382     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_SHELL);
 383     BRepCheck_Analyzer aBCA(aMergedFace);
 384     CPPUNIT_ASSERT(aBCA.IsValid());
 385   }
 386   {
 387     TopTools_ListOfShape Faces;
 388     Faces.Append(pp1);
 389     Faces.Append(pp3);
 390     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 391     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_22" );
 392     CPPUNIT_ASSERT_IMAGES
 393     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 394     BRepCheck_Analyzer aBCA(aMergedFace);
 395     CPPUNIT_ASSERT(aBCA.IsValid());
 396   }
 397   {
 398     TopTools_ListOfShape Faces;
 399     Faces.Append(pp1);
 400     Faces.Append(pp2);
 401     Faces.Append(pp4);
 402     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 403     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_23" );
 404     CPPUNIT_ASSERT_IMAGES
 405     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 406     BRepCheck_Analyzer aBCA(aMergedFace);
 407     CPPUNIT_ASSERT(aBCA.IsValid());
 408   }
 409   {
 410     TopTools_ListOfShape Faces;
 411     Faces.Append(pp1);
 412     Faces.Append(pp3);
 413     Faces.Append(pp4);
 414     Faces.Append(pp2);
 415     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 416     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_boxes_24" );
 417     CPPUNIT_ASSERT_IMAGES
 418     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_SHELL);
 419     BRepCheck_Analyzer aBCA(aMergedFace);
 420     CPPUNIT_ASSERT(aBCA.IsValid());
 421   }
 422 }
 423
 424
 425 void test_HYDROData_LandCoverMap::test_merge_faces_circles()
 426 {
 427   TopoDS_Shape ff1, ff2, ff3;
 428   BRep_Builder BB;
 429   BRepTools::Read(ff1, (REF_DATA_PATH + "/ff1.brep").toStdString().c_str(), BB);
 430   BRepTools::Read(ff2, (REF_DATA_PATH + "/ff2.brep").toStdString().c_str(), BB);
 431   BRepTools::Read(ff3, (REF_DATA_PATH + "/ff3.brep").toStdString().c_str(), BB);
 432
 433   CPPUNIT_ASSERT(!ff1.IsNull());
 434   CPPUNIT_ASSERT(!ff2.IsNull());
 435   CPPUNIT_ASSERT(!ff3.IsNull());
 436
 437   //Test mergeFaces() func // circles // USD == true
 438   {
 439     TopTools_ListOfShape Faces;
 440     Faces.Append(ff1);
 441     Faces.Append(ff2);
 442     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 443     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_11" );
 444     CPPUNIT_ASSERT_IMAGES
 445     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_FACE);
 446     BRepCheck_Analyzer aBCA(aMergedFace);
 447     CPPUNIT_ASSERT(aBCA.IsValid());
 448   }
 449   {
 450     TopTools_ListOfShape Faces;
 451     Faces.Append(ff1);
 452     Faces.Append(ff3);
 453     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 454     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_12" );
 455     CPPUNIT_ASSERT_IMAGES
 456     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 457     BRepCheck_Analyzer aBCA(aMergedFace);
 458     CPPUNIT_ASSERT(aBCA.IsValid());
 459   }
 460   {
 461     TopTools_ListOfShape Faces;
 462     Faces.Append(ff1);
 463     Faces.Append(ff2);
 464     Faces.Append(ff3);
 465     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 466     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_13" );
 467     CPPUNIT_ASSERT_IMAGES
 468     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 469     BRepCheck_Analyzer aBCA(aMergedFace);
 470     CPPUNIT_ASSERT(aBCA.IsValid());
 471   }
 472   {
 473     TopTools_ListOfShape Faces;
 474     Faces.Append(ff1);
 475     Faces.Append(ff3);
 476     Faces.Append(ff2);
 477     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 478     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_14" );
 479     CPPUNIT_ASSERT_IMAGES
 480     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 481     BRepCheck_Analyzer aBCA(aMergedFace);
 482     CPPUNIT_ASSERT(aBCA.IsValid());
 483   }
 484   //
 485
 486   //Test mergeFaces() func // circles // USD == false
 487   {
 488     TopTools_ListOfShape Faces;
 489     Faces.Append(ff1);
 490     Faces.Append(ff2);
 491     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 492     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_21" );
 493     CPPUNIT_ASSERT_IMAGES
 494     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_SHELL);
 495     BRepCheck_Analyzer aBCA(aMergedFace);
 496     CPPUNIT_ASSERT(aBCA.IsValid());
 497   }
 498   {
 499     TopTools_ListOfShape Faces;
 500     Faces.Append(ff1);
 501     Faces.Append(ff3);
 502     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 503     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_22" );
 504     CPPUNIT_ASSERT_IMAGES
 505     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 506     BRepCheck_Analyzer aBCA(aMergedFace);
 507     CPPUNIT_ASSERT(aBCA.IsValid());
 508   }
 509   {
 510     TopTools_ListOfShape Faces;
 511     Faces.Append(ff1);
 512     Faces.Append(ff2);
 513     Faces.Append(ff3);
 514     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 515     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_23" );
 516     CPPUNIT_ASSERT_IMAGES
 517     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 518     BRepCheck_Analyzer aBCA(aMergedFace);
 519     CPPUNIT_ASSERT(aBCA.IsValid());
 520   }
 521   {
 522     TopTools_ListOfShape Faces;
 523     Faces.Append(ff1);
 524     Faces.Append(ff3);
 525     Faces.Append(ff2);
 526     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 527     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_24" );
 528     CPPUNIT_ASSERT_IMAGES
 529     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 530     BRepCheck_Analyzer aBCA(aMergedFace);
 531     CPPUNIT_ASSERT(aBCA.IsValid());
 532   }
 533 }
 534
 535 void test_HYDROData_LandCoverMap::test_import_dbf()
 536 {
 537   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 538
 539   Handle(HYDROData_LandCoverMap) aMap =
 540     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 541
 542   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 543   QString aFileName = REF_DATA_PATH + "/t1.dbf";
 544   QStringList aDBFV;
 545   QStringList aST;
 546   aDBFV.append("100");
 547   aDBFV.append("200");
 548   aDBFV.append("300");
 549   aST.append("water");
 550   aST.append("forest");
 551   aST.append("road");
 552   // aST.size() == aDBFV.size()!!
 553   Handle(HYDROData_PolylineXY) aPolyline =
 554     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 555   TopoDS_Wire aWire = Wire2d( QList<double>() << 10 << 40 << 30 << 10 << 40 << 10 << 60 << 10 );
 556   aPolyline->SetShape( aWire );
 557   for (int i = 0; i < 3; i++)
 558     aMap->Add(aPolyline, "");
 559   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 50 << 20 << 30 << 50 << 15 << 30 );
 560   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 561
 562   CPPUNIT_ASSERT_EQUAL( true, aMap->Split( aPolyline ) );
 563   QList<int> Inds = QList<int>() << 1 << 2 << 3;
 564   aMap->ImportDBF(aFileName, "TESTFIELD1", aDBFV, aST, Inds);
 565   HYDROData_LandCoverMap::Explorer anIt( aMap );
 566   CPPUNIT_ASSERT_EQUAL( QString( "forest" ), anIt.StricklerType() );
 567   anIt.Next();
 568   CPPUNIT_ASSERT_EQUAL( QString( "road" ), anIt.StricklerType() );
 569
 570   aDoc->Close();
 571 }
 572 #include <QTest>
 573 void test_HYDROData_LandCoverMap::test_land_cover_prs_by_types()
 574 {
 575   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 576
 577   Handle(HYDROData_StricklerTable) aTable =
 578     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 579   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 580
 581   Handle(HYDROData_LandCoverMap) aMap =
 582     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 583
 584   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 585   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Zones de champs cultivé à végétation basse")) );
 586
 587   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 588                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 589                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 590                                               31 << 114 );
 591   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Zones de champs cultivé à végétation haute")) );
 592
 593   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 594                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 595   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, QString::fromUtf8("Zones de champs, prairies, sans cultures")) );
 596
 597   // build presentation object
 598   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 599   aPrs->SetTable( aTable );
 600   // show presentation in viewer
 601   TestViewer::show( aPrs, AIS_Shaded, 4, true, "LandCoverMap_PrsByTypes" );
 602   // select one of faces (first)
 603  TestViewer::select( 200, 300 );
 604   QTest::qWait(1000);
 605    TestViewer::select( 220, 300 );
 606   QTest::qWait(1000);
 607    TestViewer::select( 250, 300 );
 608   QTest::qWait(1000);
 609    TestViewer::select( 300, 300 );
 610   QTest::qWait(1000);
 611    TestViewer::select( 200, 350 );
 612   QTest::qWait(1000);
 613    TestViewer::select( 200, 500 );
 614   QTest::qWait(1000);
 615    TestViewer::select( 250, 400 );
 616   QTest::qWait(1000);
 617    TestViewer::select( 300, 99 );
 618   QTest::qWait(1000);
 619
 620   CPPUNIT_ASSERT_IMAGES
 621   TestViewer::eraseAll(true, true);
 622   aDoc->Close();
 623 }
 624
 625 void test_HYDROData_LandCoverMap::test_land_cover_prs_by_coeff()
 626 {
 627   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 628
 629   Handle(HYDROData_StricklerTable) aTable =
 630     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 631   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 632
 633   Handle(HYDROData_LandCoverMap) aMap =
 634     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 635
 636   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 637   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Zones de champs cultivé à végétation basse")) );
 638
 639   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 640                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 641                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 642                                               31 << 114 );
 643   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Zones de champs cultivé à végétation haute")) );
 644
 645   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 646                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 647   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, QString::fromUtf8("Zones de champs, prairies, sans cultures")) );
 648
 649   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 650   aPrs->SetTable( aTable );
 651   TestViewer::showColorScale( true );
 652   aPrs->SetColorScale( TestViewer::colorScale() );
 653   TestViewer::show( aPrs, AIS_Shaded, 4, true, "LandCoverMap_PrsByCoeff" );
 654
 655   CPPUNIT_ASSERT_IMAGES
 656
 657   TestViewer::showColorScale( false );
 658   aDoc->Close();
 659 }
 660
 661 void test_HYDROData_LandCoverMap::test_dump_python()
 662 {
 663   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 664
 665   Handle(HYDROData_StricklerTable) aTable =
 666     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 667   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 668   aTable->SetName( "DefStr" );
 669
 670   Handle(HYDROData_LandCoverMap) aMap =
 671     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 672   aMap->SetName( "test_LCM" );
 673
 674   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 675
 676   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 677
 678   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 679
 680   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 681                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 682                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 683                                               31 << 114 );
 684   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, "test2" ) );
 685
 686   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 687                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 688   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, "test3" ) );
 689
 690   QString aBaseName = "lc_dump.py";
 691   QString aBaseShp = "lc_dump.shp";
 692   QString aBaseDbf = "lc_dump.dbf";
 693   QString aTmpPath = TMP_DIR + "/" + aBaseName;
 694   CPPUNIT_ASSERT_EQUAL( true, aDoc->DumpToPython( aTmpPath, false ) );
 695
 696   //TODO: CPPUNIT_ASSERT_SCRIPTS_EQUAL( aBaseName, true, false, 20 );
 697   //TODO: CPPUNIT_ASSERT_FILES_EQUAL( aBaseShp );
 698   //TODO: CPPUNIT_ASSERT_FILES_EQUAL( aBaseDbf );
 699
 700   aDoc->Close();
 701 }
 702
 703 void test_HYDROData_LandCoverMap::test_transparent_prs()
 704 {
 705   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 706
 707   Handle(HYDROData_StricklerTable) aTable =
 708     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 709   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 710
 711   Handle(HYDROData_PolylineXY) aPoly =
 712     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 713   aPoly->AddSection( "", HYDROData_PolylineXY::SECTION_SPLINE, true );
 714   aPoly->AddPoint( 0, gp_XY( 0, 0 ) );
 715   aPoly->AddPoint( 0, gp_XY( 20, 0 ) );
 716   aPoly->AddPoint( 0, gp_XY( 10, 10 ) );
 717   aPoly->Update();
 718
 719   Handle(HYDROData_ImmersibleZone) aZone =
 720     Handle(HYDROData_ImmersibleZone)::DownCast( aDoc->CreateObject( KIND_IMMERSIBLE_ZONE ) );
 721   aZone->SetPolyline( aPoly );
 722   aZone->Update();
 723
 724   Handle(HYDROData_LandCoverMap) aMap =
 725     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 726   aMap->LocalPartition( Face2d( QList<double>() << 1 << 1 << 10 << 10 << 10 << 20 ), QString::fromUtf8("Zones de champs cultivé à végétation haute"));
 727   aMap->LocalPartition( Face2d( QList<double>() << 5 << 5 << 10 << 5 << 10 << 8 << 5 << 12 << 5 << 8 ), QString::fromUtf8("Zones de champs cultivé à végétation haute"));
 728   aMap->SetName( "test_LCM" );
 729
 730   TestViewer::show( aZone->GetTopShape(), AIS_Shaded, true, "LandCoverMap_TransparentPrs" );
 731
 732   aMap->SetTransparency( 0.5 );
 733   CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.5, aMap->GetTransparency(), 1E-6 );
 734
 735   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 736   aPrs->SetTable( aTable );
 737   TestViewer::show( aPrs, AIS_Shaded, 0, true, "" );
 738
 739   CPPUNIT_ASSERT_IMAGES
 740   aDoc->Close();
 741 }
 742
 743 void test_HYDROData_LandCoverMap::test_add_triangles()
 744 {
 745   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 746
 747   Handle(HYDROData_PolylineXY) Polyline_1 =
 748     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 749
 750   Polyline_1->SetName( "Polyline_1" );
 751   Polyline_1->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 752   Polyline_1->AddPoint( 0, gp_XY( -264.84, 323.44 ) );
 753   Polyline_1->AddPoint( 0, gp_XY( 254.45, 301.19 ) );
 754   Polyline_1->AddPoint( 0, gp_XY( -291.54, -47.48 ) );
 755   Polyline_1->Update();
 756
 757   Handle(HYDROData_PolylineXY) Polyline_2 =
 758     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 759   Polyline_2->SetName( "Polyline_2" );
 760   Polyline_2->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
 761   Polyline_2->AddPoint( 0, gp_XY( -42.28, -351.63 ) );
 762   Polyline_2->AddPoint( 0, gp_XY( 218.84, -146.88 ) );
 763   Polyline_2->AddPoint( 0, gp_XY( 413.20, -235.91 ) );
 764   Polyline_2->AddPoint( 0, gp_XY( 466.62, -388.72 ) );
 765   Polyline_2->Update();
 766
 767   Handle(HYDROData_PolylineXY) Polyline_3 =
 768     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 769   Polyline_3->SetName( "Polyline_3" );
 770   Polyline_3->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 771   Polyline_3->AddPoint( 0, gp_XY( -108.31, 213.65 ) );
 772   Polyline_3->AddPoint( 0, gp_XY( 127.60, 382.79 ) );
 773   Polyline_3->AddPoint( 0, gp_XY( 192.88, -91.99 ) );
 774   Polyline_3->Update();
 775
 776   Handle(HYDROData_PolylineXY) Polyline_4 =
 777     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 778   Polyline_4->SetName( "Polyline_4" );
 779   Polyline_4->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 780   Polyline_4->AddPoint( 0, gp_XY( 215.52, 344.61 ) );
 781   Polyline_4->AddPoint( 0, gp_XY( 68.25, 258.52 ) );
 782   Polyline_4->AddPoint( 0, gp_XY( 200.58, 154.65 ) );
 783   Polyline_4->Update();
 784
 785   Handle(HYDROData_PolylineXY) Polyline_5 =
 786     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 787   Polyline_5->SetName( "Polyline_5" );
 788   Polyline_5->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
 789   Polyline_5->AddPoint( 0, gp_XY( 16.15, -58.08 ) );
 790   Polyline_5->AddPoint( 0, gp_XY( 116.47, 84.21 ) );
 791   Polyline_5->AddPoint( 0, gp_XY( 266.59, 29.43 ) );
 792   Polyline_5->Update();
 793
 794   Handle(HYDROData_LandCoverMap) aMap =
 795     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 796
 797   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_1, "" ) );
 798   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_3, "" ) );
 799   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_4, "" ) );
 800
 801   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 802   TopoDS_Shape aSh = aMap->GetShape();
 803   TestViewer::show( aPrs, AIS_Shaded, 0, true, "LandCover_Triangles" );
 804   CPPUNIT_ASSERT_IMAGES
 805
 806   CPPUNIT_ASSERT_EQUAL( true, aMap->Split( Polyline_5 ) );
 807   Handle(HYDROGUI_LandCoverMapPrs) aPrs2 = new HYDROGUI_LandCoverMapPrs( aMap );
 808   TestViewer::show( aPrs2, AIS_Shaded, 0, true, "LandCover_Triangles_Split" );
 809   CPPUNIT_ASSERT_IMAGES
 810
 811   aDoc->Close();
 812 }
 813
 814 void test_HYDROData_LandCoverMap::test_assign_to_calc_case()
 815 {
 816   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 817
 818   Handle(HYDROData_LandCoverMap) aMap =
 819     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 820   Handle(HYDROData_CalculationCase) aCalcCase =
 821     Handle(HYDROData_CalculationCase)::DownCast( aDoc->CreateObject( KIND_CALCULATION ) );
 822
 823   aCalcCase->SetLandCoverMap( aMap );
 824   CPPUNIT_ASSERT_EQUAL( aMap->myLab, aCalcCase->GetLandCoverMap()->myLab );
 825
 826   aDoc->Close();
 827 }
 828
 829 void test_HYDROData_LandCoverMap::test_shp_import_cyp()
 830 {
 831   //TestViewer::eraseAll(true);
 832
 833   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 834   QString aFileName = REF_DATA_PATH + "/cyprus_natural.shp";
 835   HYDROData_ShapeFile anImporter;
 836   QStringList PolygonList;
 837   TopTools_SequenceOfShape PolygonFaces;
 838   int Type = -1;
 839   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces, Type);
 840   CPPUNIT_ASSERT(aStat == 1);
 841   CPPUNIT_ASSERT_EQUAL(5, Type);
 842   CPPUNIT_ASSERT_EQUAL(268, PolygonFaces.Length());
 843
 844   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 845   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 846
 847   for ( int i = 1; i <= 20; i++ )
 848   {
 849     TopoDS_Shape aShape = PolygonFaces(i);
 850     if ( aShape.IsNull() )
 851       continue;
 852     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 853   }
 854
 855   LCM->StoreLandCovers(aMapFace2ST);
 856   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "cyprus_natural_all" );
 857   CPPUNIT_ASSERT_IMAGES
 858   aDoc->Close();
 859 }
 860
 861 void test_HYDROData_LandCoverMap::test_shp_import_clc_dec()
 862 {
 863   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 864   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
 865   HYDROData_ShapeFile anImporter;
 866   QStringList PolygonList;
 867   TopTools_SequenceOfShape PolygonFaces;
 868   int Type = -1;
 869   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces, Type);
 870   CPPUNIT_ASSERT(aStat == 1);
 871   CPPUNIT_ASSERT_EQUAL(5, Type);
 872   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
 873
 874   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 875   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 876
 877   for ( int i = 150; i <= 160; i++ )
 878   {
 879     TopoDS_Shape aShape = PolygonFaces(i);
 880     if ( aShape.IsNull() )
 881       continue;
 882     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 883   }
 884
 885   LCM->StoreLandCovers(aMapFace2ST);
 886   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "clc_dec_150_350" );
 887   CPPUNIT_ASSERT_IMAGES
 888   aDoc->Close();
 889 }
 890
 891 void test_HYDROData_LandCoverMap::test_shp_import_nld_areas()
 892 {
 893   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 894   QString aFileName = REF_DATA_PATH + "/NLD_water_areas_dcw.shp";
 895   HYDROData_ShapeFile anImporter;
 896   QStringList PolygonList;
 897   TopTools_SequenceOfShape PolygonFaces;
 898   int Type = -1;
 899   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces, Type);
 900   CPPUNIT_ASSERT(aStat == 1);
 901   CPPUNIT_ASSERT_EQUAL(5, Type);
 902   CPPUNIT_ASSERT_EQUAL(127, PolygonFaces.Length());
 903
 904   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 905   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 906
 907   for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 908   {
 909     TopoDS_Shape aShape = PolygonFaces(i);
 910     if ( aShape.IsNull() )
 911       continue;
 912     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 913   }
 914
 915   LCM->StoreLandCovers(aMapFace2ST);
 916   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "NLD_water_areas_dcw" );
 917   CPPUNIT_ASSERT_IMAGES
 918   aDoc->Close();
 919 }
 920
 921 void test_HYDROData_LandCoverMap::test_shp_loop_back()
 922 {
 923   QString aFFileName = REF_DATA_PATH + "/CLC06-cut_1.shp";
 924   QString aSFileName = REF_DATA_PATH + "/CLC06-cut_1_res.shp";
 925
 926   //This test verify only some geom data (shp+shx) without any dbf reading/writing
 927   {
 928     //DEBTRACE("aFFileName: " << aFFileName.toStdString());
 929     //DEBTRACE("aSFileName: " << aSFileName.toStdString());
 930     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 931     HYDROData_ShapeFile anImporter;
 932     QStringList PolygonList;
 933     TopTools_SequenceOfShape PolygonFaces;
 934     int Type = -1;
 935
 936     //import LCM from file (#2-4; #12-14 polygons)
 937     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aFFileName, PolygonList, PolygonFaces, Type));
 938     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 939     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 940
 941     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(2) ), "" );
 942     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(3) ), "" );
 943     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(4) ), "" );
 944     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(12) ), "" );
 945     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(13) ), "" );
 946     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(14) ), "" );
 947
 948     LCM->StoreLandCovers(aMapFace2ST);
 949     LCM->SetName("lcm_1");
 950
 951     TopoDS_Shape aSh = LCM->GetShape();
 952     BRepCheck_Analyzer aBCA(aSh);
 953     CPPUNIT_ASSERT(aBCA.IsValid());
 954
 955     //export lcm
 956     HYDROData_ShapeFile anExporter;
 957     QStringList aNonExpList;
 958     anExporter.Export(aDoc, aSFileName, LCM, aNonExpList);
 959     CPPUNIT_ASSERT (aNonExpList.empty());
 960
 961     aDoc->Close();
 962   }
 963   {
 964     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
 965     HYDROData_ShapeFile anImporter;
 966     QStringList PolygonList;
 967     TopTools_SequenceOfShape PolygonFaces;
 968     int Type = -1;
 969
 970     //import all
 971     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aSFileName, PolygonList, PolygonFaces, Type));
 972     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 973     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 974     CPPUNIT_ASSERT_EQUAL(PolygonFaces.Length(), 6);
 975     for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 976       aMapFace2ST.Add( TopoDS::Face( PolygonFaces(i) ), "" );
 977
 978     LCM->StoreLandCovers(aMapFace2ST);
 979     LCM->SetName("lcm_2");
 980
 981     TopoDS_Shape OutSh = LCM->GetShape();
 982     BRepCheck_Analyzer aBCA(OutSh);
 983     CPPUNIT_ASSERT(aBCA.IsValid());
 984
 985     TestViewer::show( OutSh, AIS_Shaded, true, "CLC06-cut_1_res" );
 986     CPPUNIT_ASSERT_IMAGES
 987
 988     aDoc->Close();
 989   }
 990   CPPUNIT_ASSERT_EQUAL(0, remove(aSFileName.toStdString().c_str()));
 991 }
 992
 993 void test_HYDROData_LandCoverMap::test_add_2_section_poly()
 994 {
 995   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( 1 );
 996
 997   Handle(HYDROData_PolylineXY) Polyline_12 =
 998     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 999   Polyline_12->SetName( "Polyline_12" );
1000
1001   Polyline_12->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1002   Polyline_12->AddPoint( 0, gp_XY( -148.70, 145.68 ) );
1003   Polyline_12->AddPoint( 0, gp_XY( -81.71, 210.97 ) );
1004   Polyline_12->AddPoint( 0, gp_XY( -21.09, 122.79 ) );
1005   Polyline_12->AddPoint( 0, gp_XY( -106.30, 102.44 ) );
1006   Polyline_12->AddSection( "Section_2", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1007   Polyline_12->AddPoint( 1, gp_XY( -7.09, 227.08 ) );
1008   Polyline_12->AddPoint( 1, gp_XY( 46.32, 228.78 ) );
1009   Polyline_12->AddPoint( 1, gp_XY( 69.64, 165.61 ) );
1010   Polyline_12->AddPoint( 1, gp_XY( 13.68, 156.28 ) );
1011
1012   Polyline_12->Update();
1013
1014   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1015   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_12, "" ) );
1016
1017   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "lcm_poly_2_sections" );
1018   CPPUNIT_ASSERT_IMAGES
1019
1020   aDoc->Close();
1021 }
1022
1023 void test_HYDROData_LandCoverMap::test_split_2()
1024 {
1025   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( 1 );
1026
1027   Handle(HYDROData_PolylineXY) Polyline_1 =
1028     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1029   Polyline_1->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1030   Polyline_1->AddPoint( 0, gp_XY( -264.84, 323.44 ) );
1031   Polyline_1->AddPoint( 0, gp_XY( 254.45, 301.19 ) );
1032   Polyline_1->AddPoint( 0, gp_XY( -291.54, -47.48 ) );
1033   Polyline_1->Update();
1034
1035   Handle(HYDROData_PolylineXY) Polyline_6 =
1036     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1037   Polyline_6->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1038   Polyline_6->AddPoint( 0, gp_XY( -155.15, 199.47 ) );
1039   Polyline_6->AddPoint( 0, gp_XY( -71.19, 289.12 ) );
1040   Polyline_6->AddPoint( 0, gp_XY( 22.01, 211.57 ) );
1041   Polyline_6->AddPoint( 0, gp_XY( -84.00, 134.73 ) );
1042   Polyline_6->Update();
1043
1044   Handle(HYDROData_PolylineXY) Polyline_7 =
1045     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1046   Polyline_7->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1047   Polyline_7->AddPoint( 0, gp_XY( -50.56, 232.20 ) );
1048   Polyline_7->AddPoint( 0, gp_XY( 40.51, 286.98 ) );
1049   Polyline_7->AddPoint( 0, gp_XY( 118.77, 256.39 ) );
1050   Polyline_7->AddPoint( 0, gp_XY( 72.52, 114.10 ) );
1051   Polyline_7->Update();
1052
1053   Handle(HYDROData_PolylineXY) Polyline_8 =
1054     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1055   Polyline_8->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1056   Polyline_8->AddPoint( 0, gp_XY( -44.16, 190.93 ) );
1057   Polyline_8->AddPoint( 0, gp_XY( 9.91, 226.51 ) );
1058   Polyline_8->AddPoint( 0, gp_XY( 35.53, 175.99 ) );
1059   Polyline_8->AddPoint( 0, gp_XY( -9.30, 157.50 ) );
1060   Polyline_8->Update();
1061
1062   Handle(HYDROData_PolylineXY) Polyline_9 =
1063     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1064   Polyline_9->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
1065   Polyline_9->AddPoint( 0, gp_XY( -103.92, 288.40 ) );
1066   Polyline_9->AddPoint( 0, gp_XY( -100.09, 285.22 ) );
1067   Polyline_9->AddPoint( 0, gp_XY( -96.10, 281.90 ) );
1068   Polyline_9->AddPoint( 0, gp_XY( -90.43, 277.19 ) );
1069   Polyline_9->AddPoint( 0, gp_XY( -53.41, 246.43 ) );
1070   Polyline_9->AddPoint( 0, gp_XY( 10.62, 245.01 ) );
1071
1072
1073   Polyline_9->Update();
1074
1075
1076   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1077   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_1, "" ) );
1078   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_6, "" ) );
1079   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_7, "" ) );
1080
1081   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_9 ) );
1082
1083   //Handle(HYDROGUI_LandCoverMapPrs) aPrs1 = new HYDROGUI_LandCoverMapPrs( LCM );
1084   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2a" );
1085   CPPUNIT_ASSERT_IMAGES
1086
1087   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_8 ) );
1088
1089   // Handle(HYDROGUI_LandCoverMapPrs) aPrs2 = new HYDROGUI_LandCoverMapPrs( LCM );
1090   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2b" );
1091   CPPUNIT_ASSERT_IMAGES
1092
1093   aDoc->Close();
1094 }
1095
1096 void test_HYDROData_LandCoverMap::test_export_telemac()
1097 {
1098   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
1099
1100   Handle(HYDROData_StricklerTable) aTable =
1101     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1102   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1103
1104   Handle(HYDROData_LandCoverMap) aMap =
1105     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1106
1107   QStringList types = aTable->GetTypes();
1108   //foreach( QString type, types )
1109   //  std::cout << type.toStdString() << std::endl;
1110
1111   QString type7 = types[7];
1112   QString type8 = types[8];
1113   QString type9 = types[9];
1114
1115   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
1116   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, type7 ) );
1117
1118   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
1119                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
1120                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
1121                                               31 << 114 );
1122   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, type8 ) );
1123
1124   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
1125                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
1126   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, type9 ) );
1127
1128   QString aTmpFileName = "test.telemac";
1129   QString aTmpPath = TMP_DIR + "/" + aTmpFileName;
1130   QString messStat;
1131   CPPUNIT_ASSERT_EQUAL( true, aMap->ExportTelemac( aTmpPath, 1E-4, aTable, messStat ) );
1132   CPPUNIT_ASSERT_SCRIPTS_EQUAL( aTmpFileName, true, true, 0 );
1133
1134   aDoc->Close();
1135 }
1136
1137 void test_HYDROData_LandCoverMap::test_copy()
1138 {
1139   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
1140
1141   Handle(HYDROData_LandCoverMap) aMap =
1142     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1143   aMap->SetName( "map_1" );
1144
1145   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 30 << 10 << 20 << 20 );
1146   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Forêts de conifères")) );
1147
1148   TopoDS_Face aLC2 = Face2d( QList<double>() << 110 << 10 << 130 << 10 << 120 << 20 );
1149   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Forêts de feuillus")) );
1150
1151   Handle(HYDROData_LandCoverMap) aMap2 =
1152     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1153   aMap->CopyTo( aMap2, true );
1154
1155   CPPUNIT_ASSERT_EQUAL( QString( "map_2" ), aMap2->GetName() );
1156   HYDROData_LandCoverMap::Explorer anIt( aMap2 );
1157   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1158   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de feuillus"), anIt.StricklerType() );
1159   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC1.TShape() );
1160   anIt.Next();
1161   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1162   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de conifères"), anIt.StricklerType() );
1163   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC2.TShape() );
1164   anIt.Next();
1165   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
1166
1167   TopoDS_Shape aShape1 = aMap->GetShape();
1168   TopoDS_Shape aShape2 = aMap2->GetShape();
1169   gp_Trsf aTr;
1170   aTr.SetTranslation( gp_Vec( 0, 50, 0 ) );
1171   aShape2.Move( TopLoc_Location( aTr ) );
1172   TestViewer::show( aShape1, AIS_Shaded, /*0,*/ true, "LCM_copied" );
1173   TestViewer::show( aShape2, AIS_Shaded, /*0,*/ true, "" );
1174   CPPUNIT_ASSERT_IMAGES
1175
1176   aDoc->Close();
1177 }
1178
1179 void test_HYDROData_LandCoverMap::test_shp_clc_classification_perf()
1180 {
1181   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
1182   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1183   HYDROData_ShapeFile anImporter;
1184   QStringList PolygonList;
1185   TopTools_SequenceOfShape PolygonFaces;
1186   int Type = -1;
1187   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces, Type);
1188   CPPUNIT_ASSERT(aStat == 1);
1189   CPPUNIT_ASSERT_EQUAL(5, Type);
1190   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
1191
1192   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1193   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1194
1195 #ifdef NDEBUG
1196   int SI = 100;
1197   int EI = 110;
1198 #else
1199   int SI = 100;
1200   int EI = 110;
1201 #endif
1202
1203   for ( int i = SI; i <= EI; i++ )
1204   {
1205     TopoDS_Shape aShape = PolygonFaces(i);
1206     if ( aShape.IsNull() )
1207       continue;
1208     aMapFace2ST.Add( TopoDS::Face( aShape ), "ST_" + QString::number(i) );
1209   }
1210
1211   LCM->StoreLandCovers(aMapFace2ST);
1212
1213   std::vector<gp_XY> pnts;
1214 #ifdef NDEBUG
1215   int N = 1000; //1000*1000 points; uniform distribution for release mode
1216 #else
1217   int N = 100;
1218 #endif
1219
1220   pnts.reserve(N);
1221   double x0 = 448646.91897505691;
1222   double x1 = 487420.3990381231;
1223   double y0 = 6373566.5122489957;
1224   double y1 = 6392203.4117361344;
1225   for (size_t i=0; i < N; i++)
1226   {
1227     for (size_t j=0; j < N; j++)
1228     {
1229       double px = x0 + (x1-x0)*((double)i/(double)N);
1230       double py = y0 + (y1-y0)*((double)j/(double)N);
1231       pnts.push_back(gp_XY(px,py));
1232     }
1233   }
1234   OSD_Timer aTimer;
1235   std::vector<std::set <QString> > TRes;
1236   aTimer.Start();
1237   LCM->ClassifyPoints(pnts, TRes);
1238   aTimer.Stop();
1239 #ifdef NDEBUG
1240   std::cout << "Time: " << aTimer.ElapsedTime() << std::endl;
1241   CPPUNIT_ASSERT( aTimer.ElapsedTime() < 6.0);
1242   aTimer.Show();
1243 #endif
1244 }
1245
1246 void test_HYDROData_LandCoverMap::test_shp_clc_classification_check()
1247 {
1248   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
1249   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1250   HYDROData_ShapeFile anImporter;
1251   QStringList PolygonList;
1252   TopTools_SequenceOfShape PolygonFaces;
1253   int Type = -1;
1254   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces, Type);
1255   CPPUNIT_ASSERT(aStat == 1);
1256   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1257   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1258
1259   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(172) ), "Tissu urbain continu" );
1260   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(179) ), "Aéroports" );
1261   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(185) ), "Rizières" );
1262   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(187) ), "Vignobles" );
1263   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(190) ), "Oliveraies" );
1264   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(196) ), "Estuaires" );
1265
1266   LCM->StoreLandCovers(aMapFace2ST);
1267
1268   TopoDS_Shape Sh = LCM->GetShape();
1269
1270   std::vector<gp_XY> pnts;
1271   pnts.push_back(gp_XY(0,0));
1272
1273   pnts.push_back(gp_XY(468380, 6382300));
1274   pnts.push_back(gp_XY(468380, 6382900));
1275   pnts.push_back(gp_XY(468380, 6383200));
1276   pnts.push_back(gp_XY(468250, 6384700));
1277   pnts.push_back(gp_XY(470350, 6384700));
1278   pnts.push_back(gp_XY(469279.642874048, 6385132.45048612 ));
1279
1280   std::vector<std::set <QString> > TRes;
1281   LCM->ClassifyPoints(pnts, TRes);
1282
1283   CPPUNIT_ASSERT (TRes[0].empty());
1284   CPPUNIT_ASSERT (TRes[1].empty());
1285   CPPUNIT_ASSERT (TRes[2].empty());
1286   CPPUNIT_ASSERT_EQUAL (*TRes[3].begin(), QString("Estuaires"));
1287   CPPUNIT_ASSERT_EQUAL (*TRes[4].begin(), QString("Oliveraies"));
1288   CPPUNIT_ASSERT_EQUAL (*TRes[5].begin(), QString("Vignobles"));
1289
1290   //std::less comparator; so compare first and second elem safely
1291   CPPUNIT_ASSERT_EQUAL (*TRes[6].begin(), QString("Estuaires"));
1292   CPPUNIT_ASSERT_EQUAL (*(++TRes[6].begin()), QString("Tissu urbain continu"));
1293
1294   ///
1295   Handle(HYDROData_StricklerTable) aTable = Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1296   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1297   std::vector<double> coeffs;
1298   LCM->ClassifyPoints(pnts, aTable, coeffs, 0.0, true);
1299
1300   CPPUNIT_ASSERT_EQUAL (coeffs[0], 0.0);
1301   CPPUNIT_ASSERT_EQUAL (coeffs[1], 0.0);
1302   CPPUNIT_ASSERT_EQUAL (coeffs[2], 0.0);
1303   CPPUNIT_ASSERT_EQUAL (coeffs[3], 98.0);
1304   CPPUNIT_ASSERT_EQUAL (coeffs[4], 26.0);
1305   CPPUNIT_ASSERT_EQUAL (coeffs[5], 24.0);
1306   CPPUNIT_ASSERT_EQUAL (coeffs[6], 98.0);
1307
1308 }
1309
1310 void test_HYDROData_LandCoverMap::test_lcm_classification()
1311 {
1312   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document(1);
1313
1314   Handle(HYDROData_StricklerTable) aTable =
1315     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1316   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1317
1318   Handle(HYDROData_PolylineXY) ContourP = Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1319   ContourP->SetName( "Contour" );
1320   ContourP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1321   ContourP->AddPoint( 0, gp_XY( 89.57, 81.63 ) );
1322   ContourP->AddPoint( 0, gp_XY( 479.59, 81.63 ) );
1323   ContourP->AddPoint( 0, gp_XY( 472.79, 671.20 ) );
1324   ContourP->AddPoint( 0, gp_XY( 69.16, 696.15 ) );
1325   ContourP->Update();
1326
1327   Handle(HYDROData_PolylineXY) Poly_Sens_TrigoP =
1328     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1329   Poly_Sens_TrigoP->SetName( "Poly_Sens_Trigo" );
1330   Poly_Sens_TrigoP->SetZLevel( 3 );
1331   Poly_Sens_TrigoP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1332   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 130.46, 223.57 ) );
1333   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 252.16, 239.58 ) );
1334   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 240.95, 498.99 ) );
1335   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 119.26, 510.20 ) );
1336   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 141.67, 378.89 ) );
1337   Poly_Sens_TrigoP->Update();
1338
1339   Handle(HYDROData_PolylineXY) Polyline_Sens_HoraireP =
1340     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1341   Polyline_Sens_HoraireP->SetName( "Polyline_Sens_Horaire" );
1342   Polyline_Sens_HoraireP->SetZLevel( 4 );
1343   Polyline_Sens_HoraireP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1344   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 470.16 ) );
1345   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 627.09 ) );
1346   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 426.70, 633.49 ) );
1347   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 442.71, 398.11 ) );
1348   Polyline_Sens_HoraireP->Update();
1349
1350
1351   Handle(HYDROData_LandCoverMap) Land_cover_map_1 =
1352     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1353   Land_cover_map_1->SetName( "Land cover map_1" );
1354   Land_cover_map_1->SetZLevel( 2 );
1355   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( ContourP, "Vignobles" ) );
1356   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Poly_Sens_TrigoP, "Oliveraies" ) );
1357   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Polyline_Sens_HoraireP, "Estuaires" ) );
1358
1359   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( Land_cover_map_1 );
1360   TopoDS_Shape aSh = Land_cover_map_1->GetShape();
1361   TestViewer::show( aPrs, AIS_Shaded, 0, true, "Land_cover_map_1" );
1362
1363   std::vector<gp_XY> pnts;
1364   pnts.push_back(gp_XY(90, 90));
1365   pnts.push_back(gp_XY(300, 90));
1366   pnts.push_back(gp_XY(200, 350));
1367   pnts.push_back(gp_XY(400, 500));
1368   std::vector<double> theCoeffs;
1369   Land_cover_map_1->ClassifyPoints(pnts, aTable, theCoeffs, -1, true );
1370   CPPUNIT_ASSERT_EQUAL((int)theCoeffs.size(), 4);
1371   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[0], 24, 0.0001);
1372   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[1], 24, 0.0001);
1373   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[2], 26, 0.0001);
1374   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[3], 98, 0.0001);
1375
1376   aDoc->Close();
1377 }
1378