src/HYDRO_tests/test_HYDROData_LandCoverMap.cxx

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