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