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
 426 void test_HYDROData_LandCoverMap::test_merge_faces_circles()
 427 {
 428   TopoDS_Shape ff1, ff2, ff3;
 429   BRep_Builder BB;
 430   BRepTools::Read(ff1, (REF_DATA_PATH + "/ff1.brep").toStdString().c_str(), BB);
 431   BRepTools::Read(ff2, (REF_DATA_PATH + "/ff2.brep").toStdString().c_str(), BB);
 432   BRepTools::Read(ff3, (REF_DATA_PATH + "/ff3.brep").toStdString().c_str(), BB);
 433
 434   CPPUNIT_ASSERT(!ff1.IsNull());
 435   CPPUNIT_ASSERT(!ff2.IsNull());
 436   CPPUNIT_ASSERT(!ff3.IsNull());
 437
 438   //Test mergeFaces() func // circles // USD == true
 439   {
 440     TopTools_ListOfShape Faces;
 441     Faces.Append(ff1);
 442     Faces.Append(ff2);
 443     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 444     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_11" );
 445     CPPUNIT_ASSERT_IMAGES
 446     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_FACE);
 447     BRepCheck_Analyzer aBCA(aMergedFace);
 448     CPPUNIT_ASSERT(aBCA.IsValid());
 449   }
 450   {
 451     TopTools_ListOfShape Faces;
 452     Faces.Append(ff1);
 453     Faces.Append(ff3);
 454     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 455     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_12" );
 456     CPPUNIT_ASSERT_IMAGES
 457     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 458     BRepCheck_Analyzer aBCA(aMergedFace);
 459     CPPUNIT_ASSERT(aBCA.IsValid());
 460   }
 461   {
 462     TopTools_ListOfShape Faces;
 463     Faces.Append(ff1);
 464     Faces.Append(ff2);
 465     Faces.Append(ff3);
 466     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 467     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_13" );
 468     CPPUNIT_ASSERT_IMAGES
 469     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 470     BRepCheck_Analyzer aBCA(aMergedFace);
 471     CPPUNIT_ASSERT(aBCA.IsValid());
 472   }
 473   {
 474     TopTools_ListOfShape Faces;
 475     Faces.Append(ff1);
 476     Faces.Append(ff3);
 477     Faces.Append(ff2);
 478     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, true );
 479     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_14" );
 480     CPPUNIT_ASSERT_IMAGES
 481     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 482     BRepCheck_Analyzer aBCA(aMergedFace);
 483     CPPUNIT_ASSERT(aBCA.IsValid());
 484   }
 485   //
 486
 487   //Test mergeFaces() func // circles // USD == false
 488   {
 489     TopTools_ListOfShape Faces;
 490     Faces.Append(ff1);
 491     Faces.Append(ff2);
 492     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 493     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_21" );
 494     CPPUNIT_ASSERT_IMAGES
 495     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_SHELL);
 496     BRepCheck_Analyzer aBCA(aMergedFace);
 497     CPPUNIT_ASSERT(aBCA.IsValid());
 498   }
 499   {
 500     TopTools_ListOfShape Faces;
 501     Faces.Append(ff1);
 502     Faces.Append(ff3);
 503     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 504     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_22" );
 505     CPPUNIT_ASSERT_IMAGES
 506     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 507     BRepCheck_Analyzer aBCA(aMergedFace);
 508     CPPUNIT_ASSERT(aBCA.IsValid());
 509   }
 510   {
 511     TopTools_ListOfShape Faces;
 512     Faces.Append(ff1);
 513     Faces.Append(ff2);
 514     Faces.Append(ff3);
 515     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 516     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_23" );
 517     CPPUNIT_ASSERT_IMAGES
 518     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 519     BRepCheck_Analyzer aBCA(aMergedFace);
 520     CPPUNIT_ASSERT(aBCA.IsValid());
 521   }
 522   {
 523     TopTools_ListOfShape Faces;
 524     Faces.Append(ff1);
 525     Faces.Append(ff3);
 526     Faces.Append(ff2);
 527     TopoDS_Shape aMergedFace = HYDROData_LandCoverMap::MergeFaces( Faces, false );
 528     TestViewer::show( aMergedFace, AIS_Shaded, true, "merge_faces_circles_24" );
 529     CPPUNIT_ASSERT_IMAGES
 530     CPPUNIT_ASSERT(aMergedFace.ShapeType() == TopAbs_COMPOUND);
 531     BRepCheck_Analyzer aBCA(aMergedFace);
 532     CPPUNIT_ASSERT(aBCA.IsValid());
 533   }
 534 }
 535
 536 void test_HYDROData_LandCoverMap::test_import_dbf()
 537 {
 538   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 539
 540   Handle(HYDROData_LandCoverMap) aMap =
 541     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 542
 543   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 544   QString aFileName = REF_DATA_PATH + "/t1.dbf";
 545   QStringList aDBFV;
 546   QStringList aST;
 547   aDBFV.append("100");
 548   aDBFV.append("200");
 549   aDBFV.append("300");
 550   aST.append("water");
 551   aST.append("forest");
 552   aST.append("road");
 553   // aST.size() == aDBFV.size()!!
 554   Handle(HYDROData_PolylineXY) aPolyline =
 555     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 556   TopoDS_Wire aWire = Wire2d( QList<double>() << 10 << 40 << 30 << 10 << 40 << 10 << 60 << 10 );
 557   aPolyline->SetShape( aWire );
 558   for (int i = 0; i < 3; i++)
 559     aMap->Add(aPolyline, "");
 560   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 50 << 20 << 30 << 50 << 15 << 30 );
 561   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 562
 563   CPPUNIT_ASSERT_EQUAL( true, aMap->Split( aPolyline ) );
 564   QList<int> Inds = QList<int>() << 1 << 2 << 3;
 565   aMap->ImportDBF(aFileName, "TESTFIELD1", aDBFV, aST, Inds);
 566   HYDROData_LandCoverMap::Explorer anIt( aMap );
 567   CPPUNIT_ASSERT_EQUAL( QString( "forest" ), anIt.StricklerType() );
 568   anIt.Next();
 569   CPPUNIT_ASSERT_EQUAL( QString( "road" ), anIt.StricklerType() );
 570
 571   aDoc->Close();
 572 }
 573
 574 #include <QTest>
 575
 576 void test_HYDROData_LandCoverMap::test_land_cover_prs_by_types()
 577 {
 578   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 579
 580   Handle(HYDROData_StricklerTable) aTable =
 581     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 582   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 583
 584   Handle(HYDROData_LandCoverMap) aMap =
 585     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 586
 587   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 588   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Zones de champs cultivé à végétation basse")) );
 589
 590   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 591                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 592                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 593                                               31 << 114 );
 594   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Zones de champs cultivé à végétation haute")) );
 595
 596   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 597                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 598   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, QString::fromUtf8("Zones de champs, prairies, sans cultures")) );
 599
 600   // build presentation object
 601   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 602   aPrs->SetTable( aTable );
 603   // show presentation in viewer
 604   TestViewer::show( aPrs, AIS_Shaded, 4, true, "LandCoverMap_PrsByTypes" );
 605   // select one of faces (first)
 606   TestViewer::select( 40, 20 );
 607   QTest::qWait(1000);
 608    TestViewer::select( 40, 60 );
 609   QTest::qWait(1000);
 610    TestViewer::select( 80, 60 );
 611   QTest::qWait(1000);
 612    TestViewer::select( 80, 100 );
 613   QTest::qWait(1000);
 614    TestViewer::select( 130, 40 );
 615   QTest::qWait(1000);
 616    TestViewer::select( 130, 60 );
 617   QTest::qWait(1000);
 618    TestViewer::select( 80, 20 );
 619   QTest::qWait(1000);
 620    TestViewer::select( 40, 80 );
 621   QTest::qWait(1000);
 622
 623   CPPUNIT_ASSERT_IMAGES
 624   aDoc->Close();
 625 }
 626
 627 void test_HYDROData_LandCoverMap::test_land_cover_prs_by_coeff()
 628 {
 629   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 630
 631   Handle(HYDROData_StricklerTable) aTable =
 632     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 633   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 634
 635   Handle(HYDROData_LandCoverMap) aMap =
 636     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 637
 638   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 639   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Zones de champs cultivé à végétation basse")) );
 640
 641   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 642                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 643                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 644                                               31 << 114 );
 645   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Zones de champs cultivé à végétation haute")) );
 646
 647   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 648                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 649   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, QString::fromUtf8("Zones de champs, prairies, sans cultures")) );
 650
 651   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 652   aPrs->SetTable( aTable );
 653   TestViewer::showColorScale( true );
 654   aPrs->SetColorScale( TestViewer::colorScale() );
 655   TestViewer::show( aPrs, AIS_Shaded, 4, true, "LandCoverMap_PrsByCoeff" );
 656
 657   CPPUNIT_ASSERT_IMAGES
 658
 659   TestViewer::showColorScale( false );
 660   aDoc->Close();
 661 }
 662
 663 void test_HYDROData_LandCoverMap::test_dump_python()
 664 {
 665   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 666
 667   Handle(HYDROData_StricklerTable) aTable =
 668     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 669   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 670   aTable->SetName( "DefStr" );
 671
 672   Handle(HYDROData_LandCoverMap) aMap =
 673     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 674   aMap->SetName( "test_LCM" );
 675
 676   CPPUNIT_ASSERT_EQUAL( KIND_LAND_COVER_MAP, aMap->GetKind() );
 677
 678   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
 679
 680   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, "test1" ) );
 681
 682   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
 683                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
 684                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
 685                                               31 << 114 );
 686   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, "test2" ) );
 687
 688   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
 689                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
 690   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, "test3" ) );
 691
 692   QString aBaseName = "lc_dump.py";
 693   QString aBaseShp = "lc_dump.shp";
 694   QString aBaseDbf = "lc_dump.dbf";
 695   QString aTmpPath = TMP_DIR + "/" + aBaseName;
 696   CPPUNIT_ASSERT_EQUAL( true, aDoc->DumpToPython( aTmpPath, false ) );
 697
 698   //TODO: CPPUNIT_ASSERT_SCRIPTS_EQUAL( aBaseName, true, false, 20 );
 699   //TODO: CPPUNIT_ASSERT_FILES_EQUAL( aBaseShp );
 700   //TODO: CPPUNIT_ASSERT_FILES_EQUAL( aBaseDbf );
 701
 702   aDoc->Close();
 703 }
 704
 705 void test_HYDROData_LandCoverMap::test_transparent_prs()
 706 {
 707   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 708
 709   Handle(HYDROData_StricklerTable) aTable =
 710     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
 711   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
 712
 713   Handle(HYDROData_PolylineXY) aPoly =
 714     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 715   aPoly->AddSection( "", HYDROData_PolylineXY::SECTION_SPLINE, true );
 716   aPoly->AddPoint( 0, gp_XY( 0, 0 ) );
 717   aPoly->AddPoint( 0, gp_XY( 20, 0 ) );
 718   aPoly->AddPoint( 0, gp_XY( 10, 10 ) );
 719   aPoly->Update();
 720
 721   Handle(HYDROData_ImmersibleZone) aZone =
 722     Handle(HYDROData_ImmersibleZone)::DownCast( aDoc->CreateObject( KIND_IMMERSIBLE_ZONE ) );
 723   aZone->SetPolyline( aPoly );
 724   aZone->Update();
 725
 726   Handle(HYDROData_LandCoverMap) aMap =
 727     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 728   aMap->LocalPartition( Face2d( QList<double>() << 1 << 1 << 10 << 10 << 10 << 20 ), QString::fromUtf8("Zones de champs cultivé à végétation haute"));
 729   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"));
 730   aMap->SetName( "test_LCM" );
 731
 732   TestViewer::show( aZone->GetTopShape(), AIS_Shaded, true, "LandCoverMap_TransparentPrs" );
 733
 734   aMap->SetTransparency( 0.5 );
 735   CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.5, aMap->GetTransparency(), 1E-6 );
 736
 737   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 738   aPrs->SetTable( aTable );
 739   TestViewer::show( aPrs, AIS_Shaded, 0, true, "" );
 740
 741   CPPUNIT_ASSERT_IMAGES
 742
 743   aDoc->Close();
 744 }
 745
 746 void test_HYDROData_LandCoverMap::test_add_triangles()
 747 {
 748   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 749
 750   Handle(HYDROData_PolylineXY) Polyline_1 =
 751     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 752
 753   Polyline_1->SetName( "Polyline_1" );
 754   Polyline_1->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 755   Polyline_1->AddPoint( 0, gp_XY( -264.84, 323.44 ) );
 756   Polyline_1->AddPoint( 0, gp_XY( 254.45, 301.19 ) );
 757   Polyline_1->AddPoint( 0, gp_XY( -291.54, -47.48 ) );
 758   Polyline_1->Update();
 759
 760   Handle(HYDROData_PolylineXY) Polyline_2 =
 761     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 762   Polyline_2->SetName( "Polyline_2" );
 763   Polyline_2->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
 764   Polyline_2->AddPoint( 0, gp_XY( -42.28, -351.63 ) );
 765   Polyline_2->AddPoint( 0, gp_XY( 218.84, -146.88 ) );
 766   Polyline_2->AddPoint( 0, gp_XY( 413.20, -235.91 ) );
 767   Polyline_2->AddPoint( 0, gp_XY( 466.62, -388.72 ) );
 768   Polyline_2->Update();
 769
 770   Handle(HYDROData_PolylineXY) Polyline_3 =
 771     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 772   Polyline_3->SetName( "Polyline_3" );
 773   Polyline_3->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 774   Polyline_3->AddPoint( 0, gp_XY( -108.31, 213.65 ) );
 775   Polyline_3->AddPoint( 0, gp_XY( 127.60, 382.79 ) );
 776   Polyline_3->AddPoint( 0, gp_XY( 192.88, -91.99 ) );
 777   Polyline_3->Update();
 778
 779   Handle(HYDROData_PolylineXY) Polyline_4 =
 780     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 781   Polyline_4->SetName( "Polyline_4" );
 782   Polyline_4->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
 783   Polyline_4->AddPoint( 0, gp_XY( 215.52, 344.61 ) );
 784   Polyline_4->AddPoint( 0, gp_XY( 68.25, 258.52 ) );
 785   Polyline_4->AddPoint( 0, gp_XY( 200.58, 154.65 ) );
 786   Polyline_4->Update();
 787
 788   Handle(HYDROData_PolylineXY) Polyline_5 =
 789     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
 790   Polyline_5->SetName( "Polyline_5" );
 791   Polyline_5->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
 792   Polyline_5->AddPoint( 0, gp_XY( 16.15, -58.08 ) );
 793   Polyline_5->AddPoint( 0, gp_XY( 116.47, 84.21 ) );
 794   Polyline_5->AddPoint( 0, gp_XY( 266.59, 29.43 ) );
 795   Polyline_5->Update();
 796
 797   Handle(HYDROData_LandCoverMap) aMap =
 798     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 799
 800   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_1, "" ) );
 801   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_3, "" ) );
 802   CPPUNIT_ASSERT_EQUAL( true, aMap->Add( Polyline_4, "" ) );
 803
 804   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( aMap );
 805   TopoDS_Shape aSh = aMap->GetShape();
 806   TestViewer::show( aPrs, AIS_Shaded, 0, true, "LandCover_Triangles" );
 807   CPPUNIT_ASSERT_IMAGES
 808
 809   CPPUNIT_ASSERT_EQUAL( true, aMap->Split( Polyline_5 ) );
 810   Handle(HYDROGUI_LandCoverMapPrs) aPrs2 = new HYDROGUI_LandCoverMapPrs( aMap );
 811   TestViewer::show( aPrs2, AIS_Shaded, 0, true, "LandCover_Triangles_Split" );
 812   CPPUNIT_ASSERT_IMAGES
 813
 814   aDoc->Close();
 815 }
 816
 817 void test_HYDROData_LandCoverMap::test_assign_to_calc_case()
 818 {
 819   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 820
 821   Handle(HYDROData_LandCoverMap) aMap =
 822     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 823   Handle(HYDROData_CalculationCase) aCalcCase =
 824     Handle(HYDROData_CalculationCase)::DownCast( aDoc->CreateObject( KIND_CALCULATION ) );
 825
 826   aCalcCase->SetLandCoverMap( aMap );
 827   CPPUNIT_ASSERT_EQUAL( aMap->myLab, aCalcCase->GetLandCoverMap()->myLab );
 828
 829   aDoc->Close();
 830 }
 831
 832 void test_HYDROData_LandCoverMap::test_shp_import_cyp()
 833 {
 834   //TestViewer::eraseAll(true);
 835
 836   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 837   QString aFileName = REF_DATA_PATH + "/cyprus_natural.shp";
 838   HYDROData_ShapeFile anImporter;
 839   QStringList PolygonList;
 840   TopTools_SequenceOfShape PolygonFaces;
 841
 842   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 843   int Type = anImporter.GetShapeType();
 844   CPPUNIT_ASSERT(aStat == 1);
 845   CPPUNIT_ASSERT_EQUAL(5, Type);
 846   CPPUNIT_ASSERT_EQUAL(268, PolygonFaces.Length());
 847
 848   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 849   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 850
 851   for ( int i = 1; i <= 20; i++ )
 852   {
 853     TopoDS_Shape aShape = PolygonFaces(i);
 854     if ( aShape.IsNull() )
 855       continue;
 856     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 857   }
 858
 859   LCM->StoreLandCovers(aMapFace2ST);
 860   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "cyprus_natural_all" );
 861   CPPUNIT_ASSERT_IMAGES
 862
 863   aDoc->Close();
 864 }
 865
 866 void test_HYDROData_LandCoverMap::test_shp_import_clc_dec()
 867 {
 868   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 869   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
 870   HYDROData_ShapeFile anImporter;
 871   QStringList PolygonList;
 872   TopTools_SequenceOfShape PolygonFaces;
 873   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 874     int Type = anImporter.GetShapeType();
 875
 876   CPPUNIT_ASSERT(aStat == 1);
 877   CPPUNIT_ASSERT_EQUAL(5, Type);
 878   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
 879
 880   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 881   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 882
 883   for ( int i = 150; i <= 160; i++ )
 884   {
 885     TopoDS_Shape aShape = PolygonFaces(i);
 886     if ( aShape.IsNull() )
 887       continue;
 888     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 889   }
 890
 891   LCM->StoreLandCovers(aMapFace2ST);
 892   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "clc_dec_150_350" );
 893   CPPUNIT_ASSERT_IMAGES
 894
 895   aDoc->Close();
 896 }
 897
 898 void test_HYDROData_LandCoverMap::test_shp_import_nld_areas()
 899 {
 900   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 901   QString aFileName = REF_DATA_PATH + "/NLD_water_areas_dcw.shp";
 902   HYDROData_ShapeFile anImporter;
 903   QStringList PolygonList;
 904   TopTools_SequenceOfShape PolygonFaces;
 905   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
 906   int Type = anImporter.GetShapeType();
 907   CPPUNIT_ASSERT(aStat == 1);
 908   CPPUNIT_ASSERT_EQUAL(5, Type);
 909   CPPUNIT_ASSERT_EQUAL(127, PolygonFaces.Length());
 910
 911   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 912   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 913
 914   for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 915   {
 916     TopoDS_Shape aShape = PolygonFaces(i);
 917     if ( aShape.IsNull() )
 918       continue;
 919     aMapFace2ST.Add( TopoDS::Face( aShape ), "" );
 920   }
 921
 922   LCM->StoreLandCovers(aMapFace2ST);
 923   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "NLD_water_areas_dcw" );
 924   CPPUNIT_ASSERT_IMAGES
 925
 926   aDoc->Close();
 927 }
 928
 929 void test_HYDROData_LandCoverMap::test_shp_loop_back()
 930 {
 931   QString aFFileName = REF_DATA_PATH + "/CLC06-cut_1.shp";
 932   QString aSFileName = REF_DATA_PATH + "/CLC06-cut_1_res.shp";
 933
 934   //This test verify only some geom data (shp+shx) without any dbf reading/writing
 935   {
 936     //DEBTRACE("aFFileName: " << aFFileName.toStdString());
 937     //DEBTRACE("aSFileName: " << aSFileName.toStdString());
 938     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 939     HYDROData_ShapeFile anImporter;
 940     QStringList PolygonList;
 941     TopTools_SequenceOfShape PolygonFaces;
 942
 943     //import LCM from file (#2-4; #12-14 polygons)
 944     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aFFileName, PolygonList, PolygonFaces));
 945     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 946     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 947
 948     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(2) ), "" );
 949     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(3) ), "" );
 950     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(4) ), "" );
 951     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(12) ), "" );
 952     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(13) ), "" );
 953     aMapFace2ST.Add( TopoDS::Face( PolygonFaces(14) ), "" );
 954
 955     LCM->StoreLandCovers(aMapFace2ST);
 956     LCM->SetName("lcm_1");
 957
 958     TopoDS_Shape aSh = LCM->GetShape();
 959     BRepCheck_Analyzer aBCA(aSh);
 960     CPPUNIT_ASSERT(aBCA.IsValid());
 961
 962     //export lcm
 963     HYDROData_ShapeFile anExporter;
 964     QStringList aNonExpList;
 965     anExporter.Export(aDoc, aSFileName, LCM, aNonExpList);
 966     CPPUNIT_ASSERT (aNonExpList.empty());
 967
 968     aDoc->Close();
 969   }
 970   {
 971     Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
 972     HYDROData_ShapeFile anImporter;
 973     QStringList PolygonList;
 974     TopTools_SequenceOfShape PolygonFaces;
 975     //import all
 976     CPPUNIT_ASSERT( anImporter.ImportPolygons(aDoc, aSFileName, PolygonList, PolygonFaces));
 977     Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
 978     HYDROData_MapOfFaceToStricklerType aMapFace2ST;
 979     CPPUNIT_ASSERT_EQUAL(PolygonFaces.Length(), 6);
 980     for ( int i = 1; i <= PolygonFaces.Length(); i++ )
 981       aMapFace2ST.Add( TopoDS::Face( PolygonFaces(i) ), "" );
 982
 983     LCM->StoreLandCovers(aMapFace2ST);
 984     LCM->SetName("lcm_2");
 985
 986     TopoDS_Shape OutSh = LCM->GetShape();
 987     BRepCheck_Analyzer aBCA(OutSh);
 988     CPPUNIT_ASSERT(aBCA.IsValid());
 989
 990     TestViewer::show( OutSh, AIS_Shaded, true, "CLC06-cut_1_res" );
 991     CPPUNIT_ASSERT_IMAGES
 992
 993     aDoc->Close();
 994   }
 995   CPPUNIT_ASSERT_EQUAL(0, remove(aSFileName.toStdString().c_str()));
 996   TestViewer::eraseAll(true, true);
 997
 998 }
 999
1000 void test_HYDROData_LandCoverMap::test_add_2_section_poly()
1001 {
1002   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1003
1004   Handle(HYDROData_PolylineXY) Polyline_12 =
1005     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1006   Polyline_12->SetName( "Polyline_12" );
1007
1008   Polyline_12->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1009   Polyline_12->AddPoint( 0, gp_XY( -148.70, 145.68 ) );
1010   Polyline_12->AddPoint( 0, gp_XY( -81.71, 210.97 ) );
1011   Polyline_12->AddPoint( 0, gp_XY( -21.09, 122.79 ) );
1012   Polyline_12->AddPoint( 0, gp_XY( -106.30, 102.44 ) );
1013   Polyline_12->AddSection( "Section_2", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1014   Polyline_12->AddPoint( 1, gp_XY( -7.09, 227.08 ) );
1015   Polyline_12->AddPoint( 1, gp_XY( 46.32, 228.78 ) );
1016   Polyline_12->AddPoint( 1, gp_XY( 69.64, 165.61 ) );
1017   Polyline_12->AddPoint( 1, gp_XY( 13.68, 156.28 ) );
1018
1019   Polyline_12->Update();
1020
1021   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1022   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_12, "" ) );
1023
1024   TestViewer::show( LCM->GetShape(), AIS_Shaded, true, "lcm_poly_2_sections" );
1025   CPPUNIT_ASSERT_IMAGES
1026
1027   aDoc->Close();
1028 }
1029
1030 void test_HYDROData_LandCoverMap::test_split_2()
1031 {
1032   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1033
1034   Handle(HYDROData_PolylineXY) Polyline_1 =
1035     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1036   Polyline_1->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1037   Polyline_1->AddPoint( 0, gp_XY( -264.84, 323.44 ) );
1038   Polyline_1->AddPoint( 0, gp_XY( 254.45, 301.19 ) );
1039   Polyline_1->AddPoint( 0, gp_XY( -291.54, -47.48 ) );
1040   Polyline_1->Update();
1041
1042   Handle(HYDROData_PolylineXY) Polyline_6 =
1043     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1044   Polyline_6->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1045   Polyline_6->AddPoint( 0, gp_XY( -155.15, 199.47 ) );
1046   Polyline_6->AddPoint( 0, gp_XY( -71.19, 289.12 ) );
1047   Polyline_6->AddPoint( 0, gp_XY( 22.01, 211.57 ) );
1048   Polyline_6->AddPoint( 0, gp_XY( -84.00, 134.73 ) );
1049   Polyline_6->Update();
1050
1051   Handle(HYDROData_PolylineXY) Polyline_7 =
1052     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1053   Polyline_7->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1054   Polyline_7->AddPoint( 0, gp_XY( -50.56, 232.20 ) );
1055   Polyline_7->AddPoint( 0, gp_XY( 40.51, 286.98 ) );
1056   Polyline_7->AddPoint( 0, gp_XY( 118.77, 256.39 ) );
1057   Polyline_7->AddPoint( 0, gp_XY( 72.52, 114.10 ) );
1058   Polyline_7->Update();
1059
1060   Handle(HYDROData_PolylineXY) Polyline_8 =
1061     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1062   Polyline_8->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1063   Polyline_8->AddPoint( 0, gp_XY( -44.16, 190.93 ) );
1064   Polyline_8->AddPoint( 0, gp_XY( 9.91, 226.51 ) );
1065   Polyline_8->AddPoint( 0, gp_XY( 35.53, 175.99 ) );
1066   Polyline_8->AddPoint( 0, gp_XY( -9.30, 157.50 ) );
1067   Polyline_8->Update();
1068
1069   Handle(HYDROData_PolylineXY) Polyline_9 =
1070     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1071   Polyline_9->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, false );
1072   Polyline_9->AddPoint( 0, gp_XY( -103.92, 288.40 ) );
1073   Polyline_9->AddPoint( 0, gp_XY( -100.09, 285.22 ) );
1074   Polyline_9->AddPoint( 0, gp_XY( -96.10, 281.90 ) );
1075   Polyline_9->AddPoint( 0, gp_XY( -90.43, 277.19 ) );
1076   Polyline_9->AddPoint( 0, gp_XY( -53.41, 246.43 ) );
1077   Polyline_9->AddPoint( 0, gp_XY( 10.62, 245.01 ) );
1078
1079
1080   Polyline_9->Update();
1081
1082
1083   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1084   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_1, "" ) );
1085   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_6, "" ) );
1086   CPPUNIT_ASSERT_EQUAL( true, LCM->Add( Polyline_7, "" ) );
1087
1088   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_9 ) );
1089
1090   //Handle(HYDROGUI_LandCoverMapPrs) aPrs1 = new HYDROGUI_LandCoverMapPrs( LCM );
1091   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2a" );
1092   CPPUNIT_ASSERT_IMAGES
1093
1094   CPPUNIT_ASSERT_EQUAL( true, LCM->Split( Polyline_8 ) );
1095
1096   // Handle(HYDROGUI_LandCoverMapPrs) aPrs2 = new HYDROGUI_LandCoverMapPrs( LCM );
1097   TestViewer::show( LCM->GetShape(), AIS_Shaded, /*0,*/ true, "LCM_split_2b" );
1098   CPPUNIT_ASSERT_IMAGES
1099
1100   aDoc->Close();
1101 }
1102
1103 void test_HYDROData_LandCoverMap::test_export_telemac()
1104 {
1105   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1106
1107   Handle(HYDROData_StricklerTable) aTable =
1108     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1109   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1110
1111   Handle(HYDROData_LandCoverMap) aMap =
1112     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1113
1114   QStringList types = aTable->GetTypes();
1115   //foreach( QString type, types )
1116   //  std::cout << type.toStdString() << std::endl;
1117
1118   QString type7 = types[7];
1119   QString type8 = types[8];
1120   QString type9 = types[9];
1121
1122   TopoDS_Face aLC1 = Face2d( QList<double>() << 12 << 19 << 82 << 9 << 126 << 53 << 107 << 80 << 29 << 75 );
1123   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, type7 ) );
1124
1125   TopoDS_Face aLC2 = Face2d( QList<double>() << 21 << 34 << 24 << 25 << 37   << 37 << 40  << 61 <<
1126                                               44 << 95 << 85 << 100 << 104 << 66 << 107 << 33 <<
1127                                              128 << 18 << 140 << 50 << 131 << 89 << 104 << 111 <<
1128                                               31 << 114 );
1129   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, type8 ) );
1130
1131   TopoDS_Face aLC3 = Face2d( QList<double>() << 4 << 54 << 1   << 47 << 51  << 45 <<
1132                                             127 << 42 << 145 << 43 << 148 << 60 << 90 << 65 );
1133   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC3, type9 ) );
1134
1135   QString aTmpFileName = "test.telemac";
1136   QString aTmpPath = TMP_DIR + "/" + aTmpFileName;
1137   QString messStat;
1138   CPPUNIT_ASSERT_EQUAL( true, aMap->ExportTelemac( aTmpPath, 1E-4, aTable, messStat ) );
1139   CPPUNIT_ASSERT_SCRIPTS_EQUAL( aTmpFileName, true, true, 0 );
1140
1141   aDoc->Close();
1142 }
1143
1144 void test_HYDROData_LandCoverMap::test_copy()
1145 {
1146   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1147
1148   Handle(HYDROData_LandCoverMap) aMap =
1149     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1150   aMap->SetName( "map_1" );
1151
1152   TopoDS_Face aLC1 = Face2d( QList<double>() << 10 << 10 << 30 << 10 << 20 << 20 );
1153   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC1, QString::fromUtf8("Forêts de conifères")) );
1154
1155   TopoDS_Face aLC2 = Face2d( QList<double>() << 110 << 10 << 130 << 10 << 120 << 20 );
1156   CPPUNIT_ASSERT_EQUAL( true, aMap->LocalPartition( aLC2, QString::fromUtf8("Forêts de feuillus")) );
1157
1158   Handle(HYDROData_LandCoverMap) aMap2 =
1159     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1160   aMap->CopyTo( aMap2, true );
1161
1162   CPPUNIT_ASSERT_EQUAL( QString( "map_2" ), aMap2->GetName() );
1163   HYDROData_LandCoverMap::Explorer anIt( aMap2 );
1164   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1165   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de feuillus"), anIt.StricklerType() );
1166   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC1.TShape() );
1167   anIt.Next();
1168   CPPUNIT_ASSERT_EQUAL( true, anIt.More() );
1169   CPPUNIT_ASSERT_EQUAL( QString::fromUtf8("Forêts de conifères"), anIt.StricklerType() );
1170   CPPUNIT_ASSERT( anIt.Face().TShape()!=aLC2.TShape() );
1171   anIt.Next();
1172   CPPUNIT_ASSERT_EQUAL( false, anIt.More() );
1173
1174   TopoDS_Shape aShape1 = aMap->GetShape();
1175   TopoDS_Shape aShape2 = aMap2->GetShape();
1176   gp_Trsf aTr;
1177   aTr.SetTranslation( gp_Vec( 0, 50, 0 ) );
1178   aShape2.Move( TopLoc_Location( aTr ) );
1179   TestViewer::show( aShape1, AIS_Shaded, /*0,*/ true, "LCM_copied" );
1180   TestViewer::show( aShape2, AIS_Shaded, /*0,*/ true, "" );
1181   CPPUNIT_ASSERT_IMAGES
1182
1183   aDoc->Close();
1184 }
1185
1186 void test_HYDROData_LandCoverMap::test_shp_clc_classification_perf()
1187 {
1188   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1189   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1190   HYDROData_ShapeFile anImporter;
1191   QStringList PolygonList;
1192   TopTools_SequenceOfShape PolygonFaces;
1193   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
1194   int Type = anImporter.GetShapeType();
1195   CPPUNIT_ASSERT(aStat == 1);
1196   CPPUNIT_ASSERT_EQUAL(5, Type);
1197   CPPUNIT_ASSERT_EQUAL(625, PolygonFaces.Length());
1198
1199   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1200   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1201
1202 #ifdef NDEBUG
1203   int SI = 100;
1204   int EI = 110;
1205 #else
1206   int SI = 100;
1207   int EI = 110;
1208 #endif
1209
1210   for ( int i = SI; i <= EI; i++ )
1211   {
1212     TopoDS_Shape aShape = PolygonFaces(i);
1213     if ( aShape.IsNull() )
1214       continue;
1215     aMapFace2ST.Add( TopoDS::Face( aShape ), "ST_" + QString::number(i) );
1216   }
1217
1218   LCM->StoreLandCovers(aMapFace2ST);
1219
1220   std::vector<gp_XY> pnts;
1221 #ifdef NDEBUG
1222   int N = 1000; //1000*1000 points; uniform distribution for release mode
1223 #else
1224   int N = 100;
1225 #endif
1226
1227   pnts.reserve(N);
1228   double x0 = 448646.91897505691;
1229   double x1 = 487420.3990381231;
1230   double y0 = 6373566.5122489957;
1231   double y1 = 6392203.4117361344;
1232   for (size_t i=0; i < N; i++)
1233   {
1234     for (size_t j=0; j < N; j++)
1235     {
1236       double px = x0 + (x1-x0)*((double)i/(double)N);
1237       double py = y0 + (y1-y0)*((double)j/(double)N);
1238       pnts.push_back(gp_XY(px,py));
1239     }
1240   }
1241   OSD_Timer aTimer;
1242   std::vector<std::set <QString> > TRes;
1243   aTimer.Start();
1244   LCM->ClassifyPoints(pnts, TRes);
1245   aTimer.Stop();
1246 #ifdef NDEBUG
1247   std::cout << "Time: " << aTimer.ElapsedTime() << std::endl;
1248   CPPUNIT_ASSERT( aTimer.ElapsedTime() < 6.0);
1249   aTimer.Show();
1250 #endif
1251 }
1252
1253 void test_HYDROData_LandCoverMap::test_shp_clc_classification_check()
1254 {
1255   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1256   QString aFileName = REF_DATA_PATH + "/CLC_decoupe.shp";
1257   HYDROData_ShapeFile anImporter;
1258   QStringList PolygonList;
1259   TopTools_SequenceOfShape PolygonFaces;
1260   int aStat = anImporter.ImportPolygons(aDoc, aFileName, PolygonList, PolygonFaces);
1261   CPPUNIT_ASSERT(aStat == 1);
1262   Handle(HYDROData_LandCoverMap) LCM = Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1263   HYDROData_MapOfFaceToStricklerType aMapFace2ST;
1264
1265   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(172) ), "Tissu urbain continu" );
1266   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(179) ), "Aéroports" );
1267   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(185) ), "Rizières" );
1268   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(187) ), "Vignobles" );
1269   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(190) ), "Oliveraies" );
1270   aMapFace2ST.Add( TopoDS::Face( PolygonFaces(196) ), "Estuaires" );
1271
1272   LCM->StoreLandCovers(aMapFace2ST);
1273
1274   TopoDS_Shape Sh = LCM->GetShape();
1275
1276   std::vector<gp_XY> pnts;
1277   pnts.push_back(gp_XY(0,0));
1278
1279   pnts.push_back(gp_XY(468380, 6382300));
1280   pnts.push_back(gp_XY(468380, 6382900));
1281   pnts.push_back(gp_XY(468380, 6383200));
1282   pnts.push_back(gp_XY(468250, 6384700));
1283   pnts.push_back(gp_XY(470350, 6384700));
1284   pnts.push_back(gp_XY(469279.642874048, 6385132.45048612 ));
1285
1286   std::vector<std::set <QString> > TRes;
1287   LCM->ClassifyPoints(pnts, TRes);
1288
1289   CPPUNIT_ASSERT (TRes[0].empty());
1290   CPPUNIT_ASSERT (TRes[1].empty());
1291   CPPUNIT_ASSERT (TRes[2].empty());
1292   CPPUNIT_ASSERT_EQUAL (*TRes[3].begin(), QString("Estuaires"));
1293   CPPUNIT_ASSERT_EQUAL (*TRes[4].begin(), QString("Oliveraies"));
1294   CPPUNIT_ASSERT_EQUAL (*TRes[5].begin(), QString("Vignobles"));
1295
1296   //std::less comparator; so compare first and second elem safely
1297   CPPUNIT_ASSERT_EQUAL (*TRes[6].begin(), QString("Estuaires"));
1298   CPPUNIT_ASSERT_EQUAL (*(++TRes[6].begin()), QString("Tissu urbain continu"));
1299
1300   ///
1301   Handle(HYDROData_StricklerTable) aTable = Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1302   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1303   std::vector<double> coeffs;
1304   LCM->ClassifyPoints(pnts, aTable, coeffs, 0.0, true);
1305
1306   CPPUNIT_ASSERT_EQUAL (coeffs[0], 0.0);
1307   CPPUNIT_ASSERT_EQUAL (coeffs[1], 0.0);
1308   CPPUNIT_ASSERT_EQUAL (coeffs[2], 0.0);
1309   CPPUNIT_ASSERT_EQUAL (coeffs[3], 98.0);
1310   CPPUNIT_ASSERT_EQUAL (coeffs[4], 26.0);
1311   CPPUNIT_ASSERT_EQUAL (coeffs[5], 24.0);
1312   CPPUNIT_ASSERT_EQUAL (coeffs[6], 98.0);
1313
1314 }
1315
1316 void test_HYDROData_LandCoverMap::test_lcm_classification()
1317 {
1318   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document();
1319
1320   Handle(HYDROData_StricklerTable) aTable =
1321     Handle(HYDROData_StricklerTable)::DownCast( aDoc->CreateObject( KIND_STRICKLER_TABLE ) );
1322   CPPUNIT_ASSERT_EQUAL( true, aTable->Import( DEF_STR_PATH ) );
1323
1324   Handle(HYDROData_PolylineXY) ContourP = Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1325   ContourP->SetName( "Contour" );
1326   ContourP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, true );
1327   ContourP->AddPoint( 0, gp_XY( 89.57, 81.63 ) );
1328   ContourP->AddPoint( 0, gp_XY( 479.59, 81.63 ) );
1329   ContourP->AddPoint( 0, gp_XY( 472.79, 671.20 ) );
1330   ContourP->AddPoint( 0, gp_XY( 69.16, 696.15 ) );
1331   ContourP->Update();
1332
1333   Handle(HYDROData_PolylineXY) Poly_Sens_TrigoP =
1334     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1335   Poly_Sens_TrigoP->SetName( "Poly_Sens_Trigo" );
1336   Poly_Sens_TrigoP->SetZLevel( 3 );
1337   Poly_Sens_TrigoP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1338   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 130.46, 223.57 ) );
1339   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 252.16, 239.58 ) );
1340   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 240.95, 498.99 ) );
1341   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 119.26, 510.20 ) );
1342   Poly_Sens_TrigoP->AddPoint( 0, gp_XY( 141.67, 378.89 ) );
1343   Poly_Sens_TrigoP->Update();
1344
1345   Handle(HYDROData_PolylineXY) Polyline_Sens_HoraireP =
1346     Handle(HYDROData_PolylineXY)::DownCast( aDoc->CreateObject( KIND_POLYLINEXY ) );
1347   Polyline_Sens_HoraireP->SetName( "Polyline_Sens_Horaire" );
1348   Polyline_Sens_HoraireP->SetZLevel( 4 );
1349   Polyline_Sens_HoraireP->AddSection( "Section_1", HYDROData_PolylineXY::SECTION_POLYLINE, 1 );
1350   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 470.16 ) );
1351   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 313.01, 627.09 ) );
1352   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 426.70, 633.49 ) );
1353   Polyline_Sens_HoraireP->AddPoint( 0, gp_XY( 442.71, 398.11 ) );
1354   Polyline_Sens_HoraireP->Update();
1355
1356
1357   Handle(HYDROData_LandCoverMap) Land_cover_map_1 =
1358     Handle(HYDROData_LandCoverMap)::DownCast( aDoc->CreateObject( KIND_LAND_COVER_MAP ) );
1359   Land_cover_map_1->SetName( "Land cover map_1" );
1360   Land_cover_map_1->SetZLevel( 2 );
1361   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( ContourP, "Vignobles" ) );
1362   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Poly_Sens_TrigoP, "Oliveraies" ) );
1363   CPPUNIT_ASSERT_EQUAL( true, Land_cover_map_1->Add( Polyline_Sens_HoraireP, "Estuaires" ) );
1364
1365   Handle(HYDROGUI_LandCoverMapPrs) aPrs = new HYDROGUI_LandCoverMapPrs( Land_cover_map_1 );
1366   TopoDS_Shape aSh = Land_cover_map_1->GetShape();
1367   TestViewer::show( aPrs, AIS_Shaded, 0, true, "Land_cover_map_1" );
1368
1369   std::vector<gp_XY> pnts;
1370   pnts.push_back(gp_XY(90, 90));
1371   pnts.push_back(gp_XY(300, 90));
1372   pnts.push_back(gp_XY(200, 350));
1373   pnts.push_back(gp_XY(400, 500));
1374   std::vector<double> theCoeffs;
1375   Land_cover_map_1->ClassifyPoints(pnts, aTable, theCoeffs, -1, true );
1376   CPPUNIT_ASSERT_EQUAL((int)theCoeffs.size(), 4);
1377   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[0], 24, 0.0001);
1378   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[1], 24, 0.0001);
1379   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[2], 26, 0.0001);
1380   CPPUNIT_ASSERT_DOUBLES_EQUAL(theCoeffs[3], 98, 0.0001);
1381
1382   aDoc->Close();
1383 }
1384