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();
  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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 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();
 834   QString aFileName = REF_DATA_PATH + "/cyprus_natural.shp";
 835   HYDROData_ShapeFile anImporter;
 836   QStringList PolygonList;
 837   TopTools_SequenceOfShape PolygonFaces;
 838
 839   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 840   int Type = anImporter.GetShapeType();
 841   CPPUNIT_ASSERT(aStat == 1);
 842   CPPUNIT_ASSERT_EQUAL(5, Type);
 843   CPPUNIT_ASSERT_EQUAL(268, PolygonFaces.Length());
 844
 845   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 846   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 847
 848   for ( int i = 1; i <= 20; i++ )
 849   {
 850     TopoDS_Shape aShape = PolygonFaces(i);
 851     if ( aShape.IsNull() )
 852       continue;
 853     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 854   }
 855
 856   LCM->StoreLandCovers(aMapFace2ST);
 857   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "cyprus_natural_all" );
 858   CPPUNIT_ASSERT_IMAGES
 859   aDoc->Close();
 860 }
 861
 862 void test_HYDROData_LandCoverMap::test_shp_import_clc_dec()
 863 {
 864   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 865   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
 866   HYDROData_ShapeFile anImporter;
 867   QStringList PolygonList;
 868   TopTools_SequenceOfShape PolygonFaces;
 869   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 870     int Type = anImporter.GetShapeType();
 871
 872   CPPUNIT_ASSERT(aStat == 1);
 873   CPPUNIT_ASSERT_EQUAL(5, Type);
 874   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
 875
 876   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 877   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 878
 879   for ( int i = 150; i <= 160; i++ )
 880   {
 881     TopoDS_Shape aShape = PolygonFaces(i);
 882     if ( aShape.IsNull() )
 883       continue;
 884     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 885   }
 886
 887   LCM->StoreLandCovers(aMapFace2ST);
 888   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "clc_dec_150_350" );
 889   CPPUNIT_ASSERT_IMAGES
 890   aDoc->Close();
 891 }
 892
 893 void test_HYDROData_LandCoverMap::test_shp_import_nld_areas()
 894 {
 895   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 896   QString aFileName = REF_DATA_PATH + "/NLD_water_areas_dcw.shp";
 897   HYDROData_ShapeFile anImporter;
 898   QStringList PolygonList;
 899   TopTools_SequenceOfShape PolygonFaces;
 900   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 901   int Type = anImporter.GetShapeType();
 902   CPPUNIT_ASSERT(aStat == 1);
 903   CPPUNIT_ASSERT_EQUAL(5, Type);
 904   CPPUNIT_ASSERT_EQUAL(127, PolygonFaces.Length());
 905
 906   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 907   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 908
 909   for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 910   {
 911     TopoDS_Shape aShape = PolygonFaces(i);
 912     if ( aShape.IsNull() )
 913       continue;
 914     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 915   }
 916
 917   LCM->StoreLandCovers(aMapFace2ST);
 918   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "NLD_water_areas_dcw" );
 919   CPPUNIT_ASSERT_IMAGES
 920   aDoc->Close();
 921 }
 922
 923 void test_HYDROData_LandCoverMap::test_shp_loop_back()
 924 {
 925   QString aFFileName = REF_DATA_PATH + "/CLC06-cut_1.shp";
 926   QString aSFileName = REF_DATA_PATH + "/CLC06-cut_1_res.shp";
 927
 928   //This test verify only some geom data (shp+shx) without any dbf reading/writing
 929   {
 930     //DEBTRACE("aFFileName: " << aFFileName.toStdString());
 931     //DEBTRACE("aSFileName: " << aSFileName.toStdString());
 932     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 933     HYDROData_ShapeFile anImporter;
 934     QStringList PolygonList;
 935     TopTools_SequenceOfShape PolygonFaces;
 936
 937     //import LCM from file (#2-4; #12-14 polygons)
 938     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aFFileName, PolygonList, PolygonFaces));
 939     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 940     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 941
 942     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(2) ), "" );
 943     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(3) ), "" );
 944     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(4) ), "" );
 945     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(12) ), "" );
 946     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(13) ), "" );
 947     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(14) ), "" );
 948
 949     LCM->StoreLandCovers(aMapFace2ST);
 950     LCM->SetName("lcm_1");
 951
 952     TopoDS_Shape aSh = LCM->GetShape();
 953     BRepCheck_Analyzer aBCA(aSh);
 954     CPPUNIT_ASSERT(aBCA.IsValid());
 955
 956     //export lcm
 957     HYDROData_ShapeFile anExporter;
 958     QStringList aNonExpList;
 959     anExporter.Export(aDoc, aSFileName, LCM, aNonExpList);
 960     CPPUNIT_ASSERT (aNonExpList.empty());
 961
 962     aDoc->Close();
 963   }
 964   {
 965     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 966     HYDROData_ShapeFile anImporter;
 967     QStringList PolygonList;
 968     TopTools_SequenceOfShape PolygonFaces;
 969     //import all
 970     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aSFileName, PolygonList, PolygonFaces));
 971     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 972     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 973     CPPUNIT_ASSERT_EQUAL(PolygonFaces.Length(), 6);
 974     for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 975       aMapFace2ST.Add( TopoDS::Face( PolygonFaces(i) ), "" );
 976
 977     LCM->StoreLandCovers(aMapFace2ST);
 978     LCM->SetName("lcm_2");
 979
 980     TopoDS_Shape OutSh = LCM->GetShape();
 981     BRepCheck_Analyzer aBCA(OutSh);
 982     CPPUNIT_ASSERT(aBCA.IsValid());
 983
 984     TestViewer::show( OutSh, AIS_Shaded, true, "CLC06-cut_1_res" );
 985     CPPUNIT_ASSERT_IMAGES
 986
 987     aDoc->Close();
 988   }
 989   CPPUNIT_ASSERT_EQUAL(0, remove(aSFileName.toStdString().c_str()));
 990 }
 991
 992 void test_HYDROData_LandCoverMap::test_add_2_section_poly()
 993 {
 994   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 995
 996   Handle(HYDROData_PolylineXY) Polyline_12 =
 997     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 998   Polyline_12->SetName( "Polyline_12" );
 999
1000   Polyline_12->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1001   Polyline_12->AddPoint( 0, gp_XY( -148.70, 145.68 ) );
1002   Polyline_12->AddPoint( 0, gp_XY( -81.71, 210.97 ) );
1003   Polyline_12->AddPoint( 0, gp_XY( -21.09, 122.79 ) );
1004   Polyline_12->AddPoint( 0, gp_XY( -106.30, 102.44 ) );
1005   Polyline_12->AddSection( "Section_2", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1006   Polyline_12->AddPoint( 1, gp_XY( -7.09, 227.08 ) );
1007   Polyline_12->AddPoint( 1, gp_XY( 46.32, 228.78 ) );
1008   Polyline_12->AddPoint( 1, gp_XY( 69.64, 165.61 ) );
1009   Polyline_12->AddPoint( 1, gp_XY( 13.68, 156.28 ) );
1010
1011   Polyline_12->Update();
1012
1013   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1014   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_12, "" ) );
1015
1016   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "lcm_poly_2_sections" );
1017   CPPUNIT_ASSERT_IMAGES
1018
1019   aDoc->Close();
1020 }
1021
1022 void test_HYDROData_LandCoverMap::test_split_2()
1023 {
1024   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1025
1026   Handle(HYDROData_PolylineXY) Polyline_1 =
1027     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1028   Polyline_1->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1029   Polyline_1->AddPoint( 0, gp_XY( -264.84, 323.44 ) );
1030   Polyline_1->AddPoint( 0, gp_XY( 254.45, 301.19 ) );
1031   Polyline_1->AddPoint( 0, gp_XY( -291.54, -47.48 ) );
1032   Polyline_1->Update();
1033
1034   Handle(HYDROData_PolylineXY) Polyline_6 =
1035     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1036   Polyline_6->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1037   Polyline_6->AddPoint( 0, gp_XY( -155.15, 199.47 ) );
1038   Polyline_6->AddPoint( 0, gp_XY( -71.19, 289.12 ) );
1039   Polyline_6->AddPoint( 0, gp_XY( 22.01, 211.57 ) );
1040   Polyline_6->AddPoint( 0, gp_XY( -84.00, 134.73 ) );
1041   Polyline_6->Update();
1042
1043   Handle(HYDROData_PolylineXY) Polyline_7 =
1044     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1045   Polyline_7->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1046   Polyline_7->AddPoint( 0, gp_XY( -50.56, 232.20 ) );
1047   Polyline_7->AddPoint( 0, gp_XY( 40.51, 286.98 ) );
1048   Polyline_7->AddPoint( 0, gp_XY( 118.77, 256.39 ) );
1049   Polyline_7->AddPoint( 0, gp_XY( 72.52, 114.10 ) );
1050   Polyline_7->Update();
1051
1052   Handle(HYDROData_PolylineXY) Polyline_8 =
1053     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1054   Polyline_8->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1055   Polyline_8->AddPoint( 0, gp_XY( -44.16, 190.93 ) );
1056   Polyline_8->AddPoint( 0, gp_XY( 9.91, 226.51 ) );
1057   Polyline_8->AddPoint( 0, gp_XY( 35.53, 175.99 ) );
1058   Polyline_8->AddPoint( 0, gp_XY( -9.30, 157.50 ) );
1059   Polyline_8->Update();
1060
1061   Handle(HYDROData_PolylineXY) Polyline_9 =
1062     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1063   Polyline_9->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
1064   Polyline_9->AddPoint( 0, gp_XY( -103.92, 288.40 ) );
1065   Polyline_9->AddPoint( 0, gp_XY( -100.09, 285.22 ) );
1066   Polyline_9->AddPoint( 0, gp_XY( -96.10, 281.90 ) );
1067   Polyline_9->AddPoint( 0, gp_XY( -90.43, 277.19 ) );
1068   Polyline_9->AddPoint( 0, gp_XY( -53.41, 246.43 ) );
1069   Polyline_9->AddPoint( 0, gp_XY( 10.62, 245.01 ) );
1070
1071
1072   Polyline_9->Update();
1073
1074
1075   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1076   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_1, "" ) );
1077   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_6, "" ) );
1078   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_7, "" ) );
1079
1080   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_9 ) );
1081
1082   //Handle(HYDROGUI_LandCoverMapPrs) aPrs1 = new HYDROGUI_LandCoverMapPrs( LCM );
1083   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2a" );
1084   CPPUNIT_ASSERT_IMAGES
1085
1086   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_8 ) );
1087
1088   // Handle(HYDROGUI_LandCoverMapPrs) aPrs2 = new HYDROGUI_LandCoverMapPrs( LCM );
1089   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2b" );
1090   CPPUNIT_ASSERT_IMAGES
1091
1092   aDoc->Close();
1093 }
1094
1095 void test_HYDROData_LandCoverMap::test_export_telemac()
1096 {
1097   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1098
1099   Handle(HYDROData_StricklerTable) aTable =
1100     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1101   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1102
1103   Handle(HYDROData_LandCoverMap) aMap =
1104     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1105
1106   QStringList types = aTable->GetTypes();
1107   //foreach( QString type, types )
1108   //  std::cout << type.toStdString() << std::endl;
1109
1110   QString type7 = types[7];
1111   QString type8 = types[8];
1112   QString type9 = types[9];
1113
1114   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
1115   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, type7 ) );
1116
1117   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
1118                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
1119                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
1120                                               31 << 114 );
1121   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, type8 ) );
1122
1123   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
1124                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
1125   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, type9 ) );
1126
1127   QString aTmpFileName = "test.telemac";
1128   QString aTmpPath = TMP_DIR + "/" + aTmpFileName;
1129   QString messStat;
1130   CPPUNIT_ASSERT_EQUAL( true, aMap->ExportTelemac( aTmpPath, 1E-4, aTable, messStat ) );
1131   CPPUNIT_ASSERT_SCRIPTS_EQUAL( aTmpFileName, true, true, 0 );
1132
1133   aDoc->Close();
1134 }
1135
1136 void test_HYDROData_LandCoverMap::test_copy()
1137 {
1138   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1139
1140   Handle(HYDROData_LandCoverMap) aMap =
1141     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1142   aMap->SetName( "map_1" );
1143
1144   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 30 << 10 << 20 << 20 );
1145   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Forêts de conifères")) );
1146
1147   TopoDS_Face aLC2 = Face2d( QList<double>() << 110 << 10 << 130 << 10 << 120 << 20 );
1148   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Forêts de feuillus")) );
1149
1150   Handle(HYDROData_LandCoverMap) aMap2 =
1151     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1152   aMap->CopyTo( aMap2, true );
1153
1154   CPPUNIT_ASSERT_EQUAL( QString( "map_2" ), aMap2->GetName() );
1155   HYDROData_LandCoverMap::Explorer anIt( aMap2 );
1156   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1157   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de feuillus"), anIt.StricklerType() );
1158   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC1.TShape() );
1159   anIt.Next();
1160   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1161   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de conifères"), anIt.StricklerType() );
1162   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC2.TShape() );
1163   anIt.Next();
1164   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
1165
1166   TopoDS_Shape aShape1 = aMap->GetShape();
1167   TopoDS_Shape aShape2 = aMap2->GetShape();
1168   gp_Trsf aTr;
1169   aTr.SetTranslation( gp_Vec( 0, 50, 0 ) );
1170   aShape2.Move( TopLoc_Location( aTr ) );
1171   TestViewer::show( aShape1, AIS_Shaded, /*0,*/ true, "LCM_copied" );
1172   TestViewer::show( aShape2, AIS_Shaded, /*0,*/ true, "" );
1173   CPPUNIT_ASSERT_IMAGES
1174
1175   aDoc->Close();
1176 }
1177
1178 void test_HYDROData_LandCoverMap::test_shp_clc_classification_perf()
1179 {
1180   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1181   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1182   HYDROData_ShapeFile anImporter;
1183   QStringList PolygonList;
1184   TopTools_SequenceOfShape PolygonFaces;
1185   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
1186   int Type = anImporter.GetShapeType();
1187   CPPUNIT_ASSERT(aStat == 1);
1188   CPPUNIT_ASSERT_EQUAL(5, Type);
1189   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
1190
1191   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1192   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1193
1194 #ifdef NDEBUG
1195   int SI = 100;
1196   int EI = 110;
1197 #else
1198   int SI = 100;
1199   int EI = 110;
1200 #endif
1201
1202   for ( int i = SI; i <= EI; i++ )
1203   {
1204     TopoDS_Shape aShape = PolygonFaces(i);
1205     if ( aShape.IsNull() )
1206       continue;
1207     aMapFace2ST.Add( TopoDS::Face( aShape ), "ST_" + QString::number(i) );
1208   }
1209
1210   LCM->StoreLandCovers(aMapFace2ST);
1211
1212   std::vector<gp_XY> pnts;
1213 #ifdef NDEBUG
1214   int N = 1000; //1000*1000 points; uniform distribution for release mode
1215 #else
1216   int N = 100;
1217 #endif
1218
1219   pnts.reserve(N);
1220   double x0 = 448646.91897505691;
1221   double x1 = 487420.3990381231;
1222   double y0 = 6373566.5122489957;
1223   double y1 = 6392203.4117361344;
1224   for (size_t i=0; i < N; i++)
1225   {
1226     for (size_t j=0; j < N; j++)
1227     {
1228       double px = x0 + (x1-x0)*((double)i/(double)N);
1229       double py = y0 + (y1-y0)*((double)j/(double)N);
1230       pnts.push_back(gp_XY(px,py));
1231     }
1232   }
1233   OSD_Timer aTimer;
1234   std::vector<std::set <QString> > TRes;
1235   aTimer.Start();
1236   LCM->ClassifyPoints(pnts, TRes);
1237   aTimer.Stop();
1238 #ifdef NDEBUG
1239   std::cout << "Time: " << aTimer.ElapsedTime() << std::endl;
1240   CPPUNIT_ASSERT( aTimer.ElapsedTime() < 6.0);
1241   aTimer.Show();
1242 #endif
1243 }
1244
1245 void test_HYDROData_LandCoverMap::test_shp_clc_classification_check()
1246 {
1247   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1248   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1249   HYDROData_ShapeFile anImporter;
1250   QStringList PolygonList;
1251   TopTools_SequenceOfShape PolygonFaces;
1252   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
1253   CPPUNIT_ASSERT(aStat == 1);
1254   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1255   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1256
1257   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(172) ), "Tissu urbain continu" );
1258   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(179) ), "Aéroports" );
1259   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(185) ), "Rizières" );
1260   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(187) ), "Vignobles" );
1261   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(190) ), "Oliveraies" );
1262   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(196) ), "Estuaires" );
1263
1264   LCM->StoreLandCovers(aMapFace2ST);
1265
1266   TopoDS_Shape Sh = LCM->GetShape();
1267
1268   std::vector<gp_XY> pnts;
1269   pnts.push_back(gp_XY(0,0));
1270
1271   pnts.push_back(gp_XY(468380, 6382300));
1272   pnts.push_back(gp_XY(468380, 6382900));
1273   pnts.push_back(gp_XY(468380, 6383200));
1274   pnts.push_back(gp_XY(468250, 6384700));
1275   pnts.push_back(gp_XY(470350, 6384700));
1276   pnts.push_back(gp_XY(469279.642874048, 6385132.45048612 ));
1277
1278   std::vector<std::set <QString> > TRes;
1279   LCM->ClassifyPoints(pnts, TRes);
1280
1281   CPPUNIT_ASSERT (TRes[0].empty());
1282   CPPUNIT_ASSERT (TRes[1].empty());
1283   CPPUNIT_ASSERT (TRes[2].empty());
1284   CPPUNIT_ASSERT_EQUAL (*TRes[3].begin(), QString("Estuaires"));
1285   CPPUNIT_ASSERT_EQUAL (*TRes[4].begin(), QString("Oliveraies"));
1286   CPPUNIT_ASSERT_EQUAL (*TRes[5].begin(), QString("Vignobles"));
1287
1288   //std::less comparator; so compare first and second elem safely
1289   CPPUNIT_ASSERT_EQUAL (*TRes[6].begin(), QString("Estuaires"));
1290   CPPUNIT_ASSERT_EQUAL (*(++TRes[6].begin()), QString("Tissu urbain continu"));
1291
1292   ///
1293   Handle(HYDROData_StricklerTable) aTable = Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1294   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1295   std::vector<double> coeffs;
1296   LCM->ClassifyPoints(pnts, aTable, coeffs, 0.0, true);
1297
1298   CPPUNIT_ASSERT_EQUAL (coeffs[0], 0.0);
1299   CPPUNIT_ASSERT_EQUAL (coeffs[1], 0.0);
1300   CPPUNIT_ASSERT_EQUAL (coeffs[2], 0.0);
1301   CPPUNIT_ASSERT_EQUAL (coeffs[3], 98.0);
1302   CPPUNIT_ASSERT_EQUAL (coeffs[4], 26.0);
1303   CPPUNIT_ASSERT_EQUAL (coeffs[5], 24.0);
1304   CPPUNIT_ASSERT_EQUAL (coeffs[6], 98.0);
1305
1306 }
1307
1308 void test_HYDROData_LandCoverMap::test_lcm_classification()
1309 {
1310   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1311
1312   Handle(HYDROData_StricklerTable) aTable =
1313     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1314   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1315
1316   Handle(HYDROData_PolylineXY) ContourP = Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1317   ContourP->SetName( "Contour" );
1318   ContourP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1319   ContourP->AddPoint( 0, gp_XY( 89.57, 81.63 ) );
1320   ContourP->AddPoint( 0, gp_XY( 479.59, 81.63 ) );
1321   ContourP->AddPoint( 0, gp_XY( 472.79, 671.20 ) );
1322   ContourP->AddPoint( 0, gp_XY( 69.16, 696.15 ) );
1323   ContourP->Update();
1324
1325   Handle(HYDROData_PolylineXY) Poly_Sens_TrigoP =
1326     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1327   Poly_Sens_TrigoP->SetName( "Poly_Sens_Trigo" );
1328   Poly_Sens_TrigoP->SetZLevel( 3 );
1329   Poly_Sens_TrigoP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1330   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 130.46, 223.57 ) );
1331   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 252.16, 239.58 ) );
1332   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 240.95, 498.99 ) );
1333   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 119.26, 510.20 ) );
1334   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 141.67, 378.89 ) );
1335   Poly_Sens_TrigoP->Update();
1336
1337   Handle(HYDROData_PolylineXY) Polyline_Sens_HoraireP =
1338     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1339   Polyline_Sens_HoraireP->SetName( "Polyline_Sens_Horaire" );
1340   Polyline_Sens_HoraireP->SetZLevel( 4 );
1341   Polyline_Sens_HoraireP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1342   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 470.16 ) );
1343   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 627.09 ) );
1344   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 426.70, 633.49 ) );
1345   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 442.71, 398.11 ) );
1346   Polyline_Sens_HoraireP->Update();
1347
1348
1349   Handle(HYDROData_LandCoverMap) Land_cover_map_1 =
1350     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1351   Land_cover_map_1->SetName( "Land cover map_1" );
1352   Land_cover_map_1->SetZLevel( 2 );
1353   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( ContourP, "Vignobles" ) );
1354   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Poly_Sens_TrigoP, "Oliveraies" ) );
1355   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Polyline_Sens_HoraireP, "Estuaires" ) );
1356
1357   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( Land_cover_map_1 );
1358   TopoDS_Shape aSh = Land_cover_map_1->GetShape();
1359   TestViewer::show( aPrs, AIS_Shaded, 0, true, "Land_cover_map_1" );
1360
1361   std::vector<gp_XY> pnts;
1362   pnts.push_back(gp_XY(90, 90));
1363   pnts.push_back(gp_XY(300, 90));
1364   pnts.push_back(gp_XY(200, 350));
1365   pnts.push_back(gp_XY(400, 500));
1366   std::vector<double> theCoeffs;
1367   Land_cover_map_1->ClassifyPoints(pnts, aTable, theCoeffs, -1, true );
1368   CPPUNIT_ASSERT_EQUAL((int)theCoeffs.size(), 4);
1369   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[0], 24, 0.0001);
1370   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[1], 24, 0.0001);
1371   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[2], 26, 0.0001);
1372   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[3], 98, 0.0001);
1373
1374   aDoc->Close();
1375 }
1376