| TerraLib 4.1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Examples

TePDISegmentation_test.cpp

Shows how to use this class.

    #define TEAGN_ENABLE_STDOUT_LOG

    #include <TePDIExamplesBase.hpp>

    #include <TeAgnostic.h>
    #include <TePDIUtils.hpp>
    #include <TePDIRegGrowSeg.hpp>
    #include <TePDIBaatz.hpp>
    #include <TeInitRasterDecoders.h>
    #include <TeProgress.h>
    #include <TeStdIOProgress.h>

    #include <shapefil.h> // Needed by exportPS2SHP

    #include <time.h>

    bool exportPS2SHP( const TePolygonSet& ps,
        const std::string& base_file_name  )
    {
        // creating files names
        std::string dbfFilename = base_file_name + ".dbf";
        std::string shpFilename = base_file_name + ".shp";

        // creating polygons attribute list ( max attribute size == 12 )
        TeAttributeList attList;

        TeAttribute at;
        at.rep_.type_ = TeSTRING;               //the id of the cell
        at.rep_.numChar_ = 10;
        at.rep_.name_ = "object_id_";
        at.rep_.isPrimaryKey_ = true;

        attList.push_back(at);

        /* DBF output file handle creation */

        DBFHandle hDBF = DBFCreate( dbfFilename.c_str() );
        TEAGN_TRUE_OR_RETURN( ( hDBF != 0 ), "DBF file creation error" );

        /* Writing attributes */

        TeAttributeList::iterator it=attList.begin();
        while ( it != attList.end() )
        {
          TeAttribute at = (*it);
          string atName = at.rep_.name_;

          // *OBS****atributos podem ter no maximo 12 caracteres
          // max attribute size == 12
          if (at.rep_.type_ == TeSTRING )
          {
            TEAGN_TRUE_OR_THROW(
              ( DBFAddField( hDBF, atName.c_str(), FTString, at.rep_.numChar_, 0 )
               != -1 ), "Error writing TeSTRING attribute" );
          }
          else if (at.rep_.type_ == TeINT)
          {
            TEAGN_TRUE_OR_THROW(
              ( DBFAddField( hDBF, atName.c_str(), FTInteger, 10, 0 ) != -1 ),
              "Error writing TeINT attribute" );
          }
          else if (at.rep_.type_ == TeREAL)
          {
            TEAGN_TRUE_OR_THROW(
              ( DBFAddField( hDBF, atName.c_str(), FTDouble, 10, 5 ) != -1 ),
              "Error writing TeREAL attribute" );

          }
          else if (at.rep_.type_ == TeDATETIME)
          {
            TEAGN_TRUE_OR_THROW(
              ( DBFAddField( hDBF, atName.c_str(), FTDate, 8, 0 ) != -1 ),
              "Error writing TeDATETIME attribute" );
          }

          ++it;
        }

        /* SHP output file handle creation */

        SHPHandle hSHP = SHPCreate( shpFilename.c_str(), SHPT_POLYGON );
        if( hSHP == 0 ) {
          TEAGN_LOGERR( "DBF file creation error" );
          DBFClose( hDBF );
          return false;
        }

        /* Writing polygons */

        int iRecord = 0;
        int totpoints = 0;
        double  *padfX, *padfY;
        SHPObject       *psObject;
        int posXY, npoints, nelem;
        int nVertices;
        int* panParts;

        TePolygonSet::iterator itps;
        TePolygon poly;

        for (itps = ps.begin() ; itps != ps.end() ; itps++ ) {
          poly=(*itps);
          totpoints = 0;
          nVertices = poly.size();
          for (unsigned int n=0; n<poly.size();n++) {
            totpoints += poly[n].size();
          }

          panParts = (int *) malloc(sizeof(int) * nVertices);
          padfX = (double *) malloc(sizeof(double) * totpoints);
          padfY = (double *) malloc(sizeof(double) * totpoints);
          posXY = 0;
          nelem = 0;

          for (unsigned int l=0; l<poly.size(); ++l) {
            if (l==0) {
              if (TeOrientation(poly[l]) == TeCOUNTERCLOCKWISE) {
                TeReverseLine(poly[l]);
              }
            } else {
              if (TeOrientation(poly[l]) == TeCLOCKWISE) {
                TeReverseLine(poly[l]);
              }
            }

            npoints = poly[l].size();
            panParts[nelem]=posXY;

            for (int m=0; m<npoints; m++ ) {
              padfX[posXY] = poly[l][m].x_;
              padfY[posXY] = poly[l][m].y_;
              posXY++;
            }

            nelem++;
          }

          psObject = SHPCreateObject( SHPT_POLYGON, -1, nelem, panParts, NULL,
            posXY, padfX, padfY, NULL, NULL );

          int shpRes = SHPWriteObject( hSHP, -1, psObject );
          TEAGN_TRUE_OR_THROW( ( shpRes != -1 ),
            "Unable to create a shape write object" )

          SHPDestroyObject( psObject );
          free( panParts );
          free( padfX );
          free( padfY );

          // writing attributes - same creation order
          for (unsigned int j=0; j<attList.size();j++) {
            if ( attList[j].rep_.type_ == TeSTRING ) {
              DBFWriteStringAttribute(hDBF, iRecord, j, poly.objectId().c_str() );
            } /*else if ( attList[j].rep_.type_ == TeINT) {
              DBFWriteIntegerAttribute(hDBF, iRecord, j,  VALOR INT );
            } else if ( attList[j].rep_.type_ == TeREAL) {
              DBFWriteDoubleAttribute(hDBF, iRecord, j,  VALOR DOUBLE);
            } else if ( attList[j].rep_.type_ == TeDATETIME) {
              TeTime time =  VALOR DATA;
              char dd[8];
              sprintf(dd,"%04d%02d%02d",time.year(),time.month(),time.day());
              DBFWriteDateAttribute(hDBF, iRecord, j, dd );
            }*/
          }

          iRecord++;
        }

        DBFClose( hDBF );
        SHPClose( hSHP );

        return true;
    }

    bool checkNumberCells(TePDITypes::TePDIRasterPtrType outRaster, long nbCell)
    {
            double val;
            long max=0;
            for (int i=0 ; i<outRaster->params().nlines_ ; i++)
                    for (int j=0 ; j<outRaster->params().ncols_ ; j++){
                            outRaster->getElement(j,i,val,0);
                            if (val>max)
                                    max=(long)val;
                    }
            if (max!=nbCell)
                    return false;

            return true;
    }

    void TePDIRegGrowSeg_test()
    {
      TePDIParameters params;

      TePDITypes::TePDIRasterPtrType inRaster( new TeRaster(
        std::string( TEPDIEXAMPLESRESPATH "cbers_b2_crop.tif" ), 'r' ) );
      TEAGN_TRUE_OR_THROW( inRaster->init(), "Unable to init inRaster" );
      params.SetParameter( "input_image", inRaster );

      TePDITypes::TePDIRasterPtrType outRaster;
      TEAGN_TRUE_OR_THROW( TePDIUtils::TeAllocRAMRaster( outRaster,
        1, 1, 1, true, TeUNSIGNEDLONG, 0 ), "RAM Raster Alloc error" );
      params.SetParameter( "output_image", outRaster );

      TePDITypes::TePDIRasterPtrType dummy_ptr;
      params.SetParameter( "exclusion_image", dummy_ptr );
      params.SetParameter( "euc_treshold", (double)20 );
      params.SetParameter( "area_min", (int)15 );

      TePDITypes::TePDIPolSetMapPtrType output_polsets(
        new TePDITypes::TePDIPolSetMapType );
      params.SetParameter( "output_polsets", output_polsets );

      TePDIRegGrowSeg segmenter;

      TEAGN_TRUE_OR_THROW( segmenter.Reset(params), "Reset failed" );

      double initTime = ((double)clock()) / ((double)CLOCKS_PER_SEC) ;

      TEAGN_TRUE_OR_THROW( segmenter.Apply(), "Apply error" );

      double endTime = ((double)clock()) / ((double)CLOCKS_PER_SEC) ;

      TEAGN_WATCH( endTime - initTime );

      TEAGN_TRUE_OR_THROW( TePDIUtils::TeRaster2Geotiff( outRaster,
        TEPDIEXAMPLESBINPATH "Segmentation_RegionGrowing_test.tif", TeUNSIGNEDCHAR ),
        "GeoTIF generation error" );

      TePDITypes::TePDIPolSetMapType::iterator it = output_polsets->begin();
      TePDITypes::TePDIPolSetMapType::iterator it_end = output_polsets->end();

      unsigned int pols_number = 0;

      while( it != it_end ) {
        TEAGN_TRUE_OR_THROW( exportPS2SHP( it->second,
          TEPDIEXAMPLESBINPATH "Segmentation_RegionGrowingPols_ps" +
          Te2String( (int)it->first ) ),  "Polygonset export error" )

        pols_number += it->second.size();

        ++it;
      }

      TEAGN_CHECK_EPS( output_polsets->size(), 23, 0.0,
        "Invalid generated polygon set size" );
      TEAGN_CHECK_EPS( pols_number, 23, 0.0,
        "Invalid generated polygon set size" );

      //with an euclidian treshold of 20 and an area min of 15
      //you are suppose to find 23 cells
      //(you can use the spring software to check that number with
      // others images and/or paramaters)
      TEAGN_TRUE_OR_THROW( checkNumberCells(outRaster, 23),
        "Check number of cell Error" );
    }

    void TePDIBaatz_test()
    {
      TePDIParameters params;

      TePDITypes::TePDIRasterPtrType inRaster( new TeRaster(
        std::string( TEPDIEXAMPLESRESPATH "cbers_rgb342_crop1.tif" ), 'r' ) );
      TEAGN_TRUE_OR_THROW( inRaster->init(), "Unable to init inRaster" );
      params.SetParameter( "input_image", inRaster );

      std::vector<unsigned> input_channels;
      input_channels.push_back( 0 );
      input_channels.push_back( 1 );
      input_channels.push_back( 2 );
      params.SetParameter( "input_channels", input_channels );

      TePDITypes::TePDIRasterPtrType outRaster;
      TEAGN_TRUE_OR_THROW( TePDIUtils::TeAllocRAMRaster( outRaster,
      1, 1, 1, true, TeUNSIGNEDLONG, 0 ), "RAM Raster Alloc error" );
      params.SetParameter( "output_image", outRaster );
      params.SetParameter( "scale", (float) 30 );
      params.SetParameter( "compactness", (float) 0.4 );
      params.SetParameter( "color", (float) 0.5 );

      vector<float> input_weights;
      input_weights.push_back( (float) 0.7 );
      input_weights.push_back( (float) 0.2 );
      input_weights.push_back( (float) 0.1 );
      params.SetParameter( "input_weights", input_weights );

      TePDITypes::TePDIPolSetMapPtrType output_polsets(
      new TePDITypes::TePDIPolSetMapType );
      params.SetParameter( "output_polsets", output_polsets );

      TePDIBaatz segmenter;

      TEAGN_TRUE_OR_THROW( segmenter.Reset(params), "Reset failed" );

      double initTime = ((double)clock()) / ((double)CLOCKS_PER_SEC) ;

      TEAGN_TRUE_OR_THROW( segmenter.Apply(), "Apply error" );

      double endTime = ((double)clock()) / ((double)CLOCKS_PER_SEC) ;

      TEAGN_WATCH( endTime - initTime );

      TEAGN_TRUE_OR_THROW( TePDIUtils::TeRaster2Geotiff( outRaster,
        TEPDIEXAMPLESBINPATH "Segmentation_Baatz_test.tif", TeUNSIGNEDCHAR ),
        "GeoTIF generation error" );

      TePDITypes::TePDIPolSetMapType::iterator it = output_polsets->begin();
      TePDITypes::TePDIPolSetMapType::iterator it_end = output_polsets->end();
      TePolygonSet pols;
      while( it != it_end )
      {
        pols.copyElements(it->second);
        ++it;
      }
      exportPS2SHP( pols, TEPDIEXAMPLESBINPATH "Segmentation_BaatzPols_ps");
    }

    int main()
    {
      TEAGN_LOGMSG( "Test started." );

      try{
        TeStdIOProgress pi;
        TeProgress::setProgressInterf( dynamic_cast< TeProgressBase* >( &pi ) );

        TeInitRasterDecoders();

        TePDIBaatz_test();
        TePDIRegGrowSeg_test();
      }
      catch( const TeException& e ){
        TEAGN_LOGERR( "Test Failed - " + e.message() );
        return EXIT_FAILURE;
      }

      TEAGN_LOGMSG( "Test OK." );
      return EXIT_SUCCESS;
    }

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines