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