CPLErr TerragenDataset::SetProjection( const char * pszNewProjection )
{
// Terragen files aren't really georeferenced, but
// we should get the projection's linear units so
// that we can scale elevations correctly.
//m_dSCAL = 30.0; // default
OGRSpatialReference oSRS( pszNewProjection );
/* -------------------------------------------------------------------- */
/* Linear units. */
/* -------------------------------------------------------------------- */
m_bIsGeo = (oSRS.IsGeographic() != FALSE);
if(m_bIsGeo)
{
// The caller is using degrees. We need to convert
// to meters, otherwise we can't derive a SCAL
// value to scale elevations with.
m_bIsGeo = true;
}
else
{
double dfLinear = oSRS.GetLinearUnits();
if( approx_equal(dfLinear, 0.3048))
m_dMetersPerGroundUnit = 0.3048;
else if( approx_equal(dfLinear, atof(SRS_UL_US_FOOT_CONV)) )
m_dMetersPerGroundUnit = atof(SRS_UL_US_FOOT_CONV);
else
m_dMetersPerGroundUnit = 1.0;
}
return CE_None;
}
int OGRCARTODBDataSource::FetchSRSId( OGRSpatialReference * poSRS )
{
const char* pszAuthorityName;
if( poSRS == NULL )
return 0;
OGRSpatialReference oSRS(*poSRS);
poSRS = NULL;
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if( pszAuthorityName == NULL || strlen(pszAuthorityName) == 0 )
{
/* -------------------------------------------------------------------- */
/* Try to identify an EPSG code */
/* -------------------------------------------------------------------- */
oSRS.AutoIdentifyEPSG();
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if (pszAuthorityName != NULL && EQUAL(pszAuthorityName, "EPSG"))
{
const char* pszAuthorityCode = oSRS.GetAuthorityCode(NULL);
if ( pszAuthorityCode != NULL && strlen(pszAuthorityCode) > 0 )
{
/* Import 'clean' SRS */
oSRS.importFromEPSG( atoi(pszAuthorityCode) );
pszAuthorityName = oSRS.GetAuthorityName(NULL);
}
}
}
/* -------------------------------------------------------------------- */
/* Check whether the EPSG authority code is already mapped to a */
/* SRS ID. */
/* -------------------------------------------------------------------- */
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
int nAuthorityCode;
/* For the root authority name 'EPSG', the authority code
* should always be integral
*/
nAuthorityCode = atoi( oSRS.GetAuthorityCode(NULL) );
return nAuthorityCode;
}
return 0;
}
int OGRAmigoCloudDataSource::FetchSRSId( OGRSpatialReference * poSRS )
{
if( poSRS == nullptr )
return 0;
OGRSpatialReference oSRS(*poSRS);
// cppcheck-suppress uselessAssignmentPtrArg
poSRS = nullptr;
const char* pszAuthorityName = oSRS.GetAuthorityName(nullptr);
if( pszAuthorityName == nullptr || strlen(pszAuthorityName) == 0 )
{
/* -------------------------------------------------------------------- */
/* Try to identify an EPSG code */
/* -------------------------------------------------------------------- */
oSRS.AutoIdentifyEPSG();
pszAuthorityName = oSRS.GetAuthorityName(nullptr);
if (pszAuthorityName != nullptr && EQUAL(pszAuthorityName, "EPSG"))
{
const char* pszAuthorityCode = oSRS.GetAuthorityCode(nullptr);
if ( pszAuthorityCode != nullptr && strlen(pszAuthorityCode) > 0 )
{
/* Import 'clean' SRS */
oSRS.importFromEPSG( atoi(pszAuthorityCode) );
pszAuthorityName = oSRS.GetAuthorityName(nullptr);
}
}
}
/* -------------------------------------------------------------------- */
/* Check whether the EPSG authority code is already mapped to a */
/* SRS ID. */
/* -------------------------------------------------------------------- */
if( pszAuthorityName != nullptr && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* For the root authority name 'EPSG', the authority code
* should always be integral
*/
const int nAuthorityCode = atoi( oSRS.GetAuthorityCode(nullptr) );
return nAuthorityCode;
}
return 0;
}
CPLErr SAGADataset::SetProjection( const char *pszSRS )
{
/* -------------------------------------------------------------------- */
/* Reset coordinate system on the dataset. */
/* -------------------------------------------------------------------- */
CPLFree( pszProjection );
pszProjection = CPLStrdup( pszSRS );
if( strlen(pszSRS) == 0 )
return CE_None;
/* -------------------------------------------------------------------- */
/* Convert to ESRI WKT. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS( pszSRS );
char *pszESRI_SRS = NULL;
oSRS.morphToESRI();
oSRS.exportToWkt( &pszESRI_SRS );
/* -------------------------------------------------------------------- */
/* Write to .prj file. */
/* -------------------------------------------------------------------- */
CPLString osPrjFilename = CPLResetExtension( GetDescription(), "prj" );
VSILFILE *fp;
fp = VSIFOpenL( osPrjFilename.c_str(), "wt" );
if( fp != NULL )
{
VSIFWriteL( pszESRI_SRS, 1, strlen(pszESRI_SRS), fp );
VSIFWriteL( (void *) "\n", 1, 1, fp );
VSIFCloseL( fp );
}
CPLFree( pszESRI_SRS );
return CE_None;
}
int OGRMSSQLSpatialDataSource::FetchSRSId( OGRSpatialReference * poSRS)
{
char *pszWKT = NULL;
int nSRSId = 0;
const char* pszAuthorityName;
if( poSRS == NULL )
return 0;
OGRSpatialReference oSRS(*poSRS);
poSRS = NULL;
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if( pszAuthorityName == NULL || strlen(pszAuthorityName) == 0 )
{
/* -------------------------------------------------------------------- */
/* Try to identify an EPSG code */
/* -------------------------------------------------------------------- */
oSRS.AutoIdentifyEPSG();
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if (pszAuthorityName != NULL && EQUAL(pszAuthorityName, "EPSG"))
{
const char* pszAuthorityCode = oSRS.GetAuthorityCode(NULL);
if ( pszAuthorityCode != NULL && strlen(pszAuthorityCode) > 0 )
{
/* Import 'clean' SRS */
oSRS.importFromEPSG( atoi(pszAuthorityCode) );
pszAuthorityName = oSRS.GetAuthorityName(NULL);
}
}
}
/* -------------------------------------------------------------------- */
/* Check whether the EPSG authority code is already mapped to a */
/* SRS ID. */
/* -------------------------------------------------------------------- */
int nAuthorityCode = 0;
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* For the root authority name 'EPSG', the authority code
* should always be integral
*/
nAuthorityCode = atoi( oSRS.GetAuthorityCode(NULL) );
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf("SELECT srid FROM spatial_ref_sys WHERE "
"auth_name = '%s' AND auth_srid = %d",
pszAuthorityName,
nAuthorityCode );
if( oStmt.ExecuteSQL() && oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
return nSRSId;
}
}
/* -------------------------------------------------------------------- */
/* Translate SRS to WKT. */
/* -------------------------------------------------------------------- */
if( oSRS.exportToWkt( &pszWKT ) != OGRERR_NONE )
{
CPLFree(pszWKT);
return 0;
}
/* -------------------------------------------------------------------- */
/* Try to find in the existing table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT srid FROM spatial_ref_sys WHERE srtext = ");
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
/* -------------------------------------------------------------------- */
/* We got it! Return it. */
/* -------------------------------------------------------------------- */
if( oStmt.ExecuteSQL() )
{
if ( oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
CPLFree(pszWKT);
return nSRSId;
}
}
else
{
/* probably the table is missing at all */
if( InitializeMetadataTables() != OGRERR_NONE )
{
CPLFree(pszWKT);
return 0;
}
}
/* -------------------------------------------------------------------- */
/* Try adding the SRS to the SRS table. */
/* -------------------------------------------------------------------- */
char *pszProj4 = NULL;
if( oSRS.exportToProj4( &pszProj4 ) != OGRERR_NONE )
{
CPLFree( pszProj4 );
CPLFree(pszWKT);
return 0;
}
/* -------------------------------------------------------------------- */
/* Check whether the auth_code can be used as srid. */
/* -------------------------------------------------------------------- */
nSRSId = nAuthorityCode;
oStmt.Clear();
oSession.BeginTransaction();
if (nAuthorityCode > 0)
{
oStmt.Appendf("SELECT srid FROM spatial_ref_sys where srid = %d", nAuthorityCode);
if ( oStmt.ExecuteSQL() && oStmt.Fetch())
{
nSRSId = 0;
}
}
/* -------------------------------------------------------------------- */
/* Get the current maximum srid in the srs table. */
/* -------------------------------------------------------------------- */
if (nSRSId == 0)
{
oStmt.Clear();
oStmt.Append("SELECT COALESCE(MAX(srid) + 1, 32768) FROM spatial_ref_sys where srid between 32768 and 65536");
if ( oStmt.ExecuteSQL() && oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
}
}
if (nSRSId == 0)
{
/* unable to allocate srid */
oSession.RollbackTransaction();
CPLFree( pszProj4 );
CPLFree(pszWKT);
return 0;
}
oStmt.Clear();
if( nAuthorityCode > 0 )
{
oStmt.Appendf(
"INSERT INTO spatial_ref_sys (srid, auth_srid, auth_name, srtext, proj4text) "
"VALUES (%d, %d, ", nSRSId, nAuthorityCode );
OGRMSSQLAppendEscaped(&oStmt, pszAuthorityName);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszProj4);
oStmt.Append(")");
}
else
{
oStmt.Appendf(
"INSERT INTO spatial_ref_sys (srid,srtext,proj4text) VALUES (%d, ", nSRSId);
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszProj4);
oStmt.Append(")");
}
/* Free everything that was allocated. */
CPLFree( pszProj4 );
CPLFree( pszWKT);
if ( oStmt.ExecuteSQL() )
oSession.CommitTransaction();
else
oSession.RollbackTransaction();
return nSRSId;
}
CPLErr BTDataset::SetProjection( const char *pszNewProjection )
{
CPLErr eErr = CE_None;
CPLFree( pszProjection );
pszProjection = CPLStrdup( pszNewProjection );
bHeaderModified = TRUE;
/* -------------------------------------------------------------------- */
/* Parse projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS( pszProjection );
GInt16 nShortTemp = 0;
/* -------------------------------------------------------------------- */
/* Linear units. */
/* -------------------------------------------------------------------- */
if( oSRS.IsGeographic() )
{
// nShortTemp = 0;
}
else
{
const double dfLinear = oSRS.GetLinearUnits();
if( std::abs(dfLinear - 0.3048) < 0.0000001 )
nShortTemp = 2;
else if( std::abs(dfLinear - CPLAtof(SRS_UL_US_FOOT_CONV))
< 0.00000001 )
nShortTemp = 3;
else
nShortTemp = 1;
}
nShortTemp = CPL_LSBWORD16( 1 );
memcpy( abyHeader + 22, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* UTM Zone */
/* -------------------------------------------------------------------- */
int bNorth = FALSE;
nShortTemp = (GInt16) oSRS.GetUTMZone( &bNorth );
if( bNorth )
nShortTemp = -nShortTemp;
nShortTemp = CPL_LSBWORD16( nShortTemp );
memcpy( abyHeader + 24, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* Datum */
/* -------------------------------------------------------------------- */
if( oSRS.GetAuthorityName( "GEOGCS|DATUM" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "GEOGCS|DATUM" ),"EPSG") )
nShortTemp = static_cast<GInt16>(
atoi(oSRS.GetAuthorityCode( "GEOGCS|DATUM" )) + 2000);
else
nShortTemp = -2;
nShortTemp = CPL_LSBWORD16( nShortTemp ); /* datum unknown */
memcpy( abyHeader + 26, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* Write out the projection to a .prj file. */
/* -------------------------------------------------------------------- */
const char *pszPrjFile = CPLResetExtension( GetDescription(), "prj" );
VSILFILE * fp = VSIFOpenL( pszPrjFile, "wt" );
if( fp != NULL )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "%s\n", pszProjection ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
abyHeader[60] = 1;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to write out .prj file." );
eErr = CE_Failure;
}
return eErr;
}
CPLErr LANDataset::SetProjection( const char * pszWKT )
{
unsigned char abyHeader[128] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFReadL( abyHeader, 128, 1, fpImage ));
OGRSpatialReference oSRS( pszWKT );
GUInt16 nProjCode = 0;
if( oSRS.IsGeographic() )
{
nProjCode = 0;
}
else if( oSRS.GetUTMZone() != 0 )
{
nProjCode = 1;
}
// Too bad we have no way of recognising state plane projections.
else
{
const char *l_pszProjection = oSRS.GetAttrValue("PROJECTION");
if( l_pszProjection == NULL )
;
else if( EQUAL(l_pszProjection,
SRS_PT_ALBERS_CONIC_EQUAL_AREA) )
nProjCode = 3;
else if( EQUAL(l_pszProjection,
SRS_PT_LAMBERT_CONFORMAL_CONIC_1SP) )
nProjCode = 4;
else if( EQUAL(l_pszProjection,
SRS_PT_MERCATOR_1SP) )
nProjCode = 5;
else if( EQUAL(l_pszProjection,
SRS_PT_POLAR_STEREOGRAPHIC) )
nProjCode = 6;
else if( EQUAL(l_pszProjection,
SRS_PT_POLYCONIC) )
nProjCode = 7;
else if( EQUAL(l_pszProjection,
SRS_PT_EQUIDISTANT_CONIC) )
nProjCode = 8;
else if( EQUAL(l_pszProjection,
SRS_PT_TRANSVERSE_MERCATOR) )
nProjCode = 9;
else if( EQUAL(l_pszProjection,
SRS_PT_STEREOGRAPHIC) )
nProjCode = 10;
else if( EQUAL(l_pszProjection,
SRS_PT_LAMBERT_AZIMUTHAL_EQUAL_AREA) )
nProjCode = 11;
else if( EQUAL(l_pszProjection,
SRS_PT_AZIMUTHAL_EQUIDISTANT) )
nProjCode = 12;
else if( EQUAL(l_pszProjection,
SRS_PT_GNOMONIC) )
nProjCode = 13;
else if( EQUAL(l_pszProjection,
SRS_PT_ORTHOGRAPHIC) )
nProjCode = 14;
// We do not have GVNP.
else if( EQUAL(l_pszProjection,
SRS_PT_SINUSOIDAL) )
nProjCode = 16;
else if( EQUAL(l_pszProjection,
SRS_PT_EQUIRECTANGULAR) )
nProjCode = 17;
else if( EQUAL(l_pszProjection,
SRS_PT_MILLER_CYLINDRICAL) )
nProjCode = 18;
else if( EQUAL(l_pszProjection,
SRS_PT_VANDERGRINTEN) )
nProjCode = 19;
else if( EQUAL(l_pszProjection,
SRS_PT_HOTINE_OBLIQUE_MERCATOR) )
nProjCode = 20;
}
memcpy( abyHeader + 88, &nProjCode, 2 );
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFWriteL( abyHeader, 128, 1, fpImage ));
return GDALPamDataset::SetProjection( pszWKT );
}
CPLErr ERSDataset::SetProjection( const char *pszSRS )
{
if( pszProjection && EQUAL(pszSRS,pszProjection) )
return CE_None;
if( pszSRS == NULL )
pszSRS = "";
CPLFree( pszProjection );
pszProjection = CPLStrdup(pszSRS);
OGRSpatialReference oSRS( pszSRS );
char szERSProj[32], szERSDatum[32], szERSUnits[32];
oSRS.exportToERM( szERSProj, szERSDatum, szERSUnits );
bHDRDirty = TRUE;
poHeader->Set( "CoordinateSpace.Datum",
CPLString().Printf( "\"%s\"", szERSDatum ) );
poHeader->Set( "CoordinateSpace.Projection",
CPLString().Printf( "\"%s\"", szERSProj ) );
poHeader->Set( "CoordinateSpace.CoordinateType",
CPLString().Printf( "EN" ) );
poHeader->Set( "CoordinateSpace.Units",
CPLString().Printf( "\"%s\"", szERSUnits ) );
poHeader->Set( "CoordinateSpace.Rotation",
"0:0:0.0" );
/* -------------------------------------------------------------------- */
/* It seems that CoordinateSpace needs to come before */
/* RasterInfo. Try moving it up manually. */
/* -------------------------------------------------------------------- */
int iRasterInfo = -1;
int iCoordSpace = -1;
int i;
for( i = 0; i < poHeader->nItemCount; i++ )
{
if( EQUAL(poHeader->papszItemName[i],"RasterInfo") )
iRasterInfo = i;
if( EQUAL(poHeader->papszItemName[i],"CoordinateSpace") )
{
iCoordSpace = i;
break;
}
}
if( iCoordSpace > iRasterInfo && iRasterInfo != -1 )
{
for( i = iCoordSpace; i > 0 && i != iRasterInfo; i-- )
{
char *pszTemp;
ERSHdrNode *poTemp = poHeader->papoItemChild[i];
poHeader->papoItemChild[i] = poHeader->papoItemChild[i-1];
poHeader->papoItemChild[i-1] = poTemp;
pszTemp = poHeader->papszItemName[i];
poHeader->papszItemName[i] = poHeader->papszItemName[i-1];
poHeader->papszItemName[i-1] = pszTemp;
pszTemp = poHeader->papszItemValue[i];
poHeader->papszItemValue[i] = poHeader->papszItemValue[i-1];
poHeader->papszItemValue[i-1] = pszTemp;
}
}
return CE_None;
}
CPLErr ERSDataset::SetGCPs( int nGCPCountIn, const GDAL_GCP *pasGCPListIn,
const char *pszGCPProjectionIn )
{
/* -------------------------------------------------------------------- */
/* Clean old gcps. */
/* -------------------------------------------------------------------- */
CPLFree( pszGCPProjection );
pszGCPProjection = NULL;
if( nGCPCount > 0 )
{
GDALDeinitGCPs( nGCPCount, pasGCPList );
CPLFree( pasGCPList );
pasGCPList = NULL;
nGCPCount = 0;
}
/* -------------------------------------------------------------------- */
/* Copy new ones. */
/* -------------------------------------------------------------------- */
nGCPCount = nGCPCountIn;
pasGCPList = GDALDuplicateGCPs( nGCPCount, pasGCPListIn );
pszGCPProjection = CPLStrdup( pszGCPProjectionIn );
/* -------------------------------------------------------------------- */
/* Setup the header contents corresponding to these GCPs. */
/* -------------------------------------------------------------------- */
bHDRDirty = TRUE;
poHeader->Set( "RasterInfo.WarpControl.WarpType", "Polynomial" );
if( nGCPCount > 6 )
poHeader->Set( "RasterInfo.WarpControl.WarpOrder", "2" );
else
poHeader->Set( "RasterInfo.WarpControl.WarpOrder", "1" );
poHeader->Set( "RasterInfo.WarpControl.WarpSampling", "Nearest" );
/* -------------------------------------------------------------------- */
/* Translate the projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS( pszGCPProjection );
char szERSProj[32], szERSDatum[32], szERSUnits[32];
oSRS.exportToERM( szERSProj, szERSDatum, szERSUnits );
poHeader->Set( "RasterInfo.WarpControl.CoordinateSpace.Datum",
CPLString().Printf( "\"%s\"", szERSDatum ) );
poHeader->Set( "RasterInfo.WarpControl.CoordinateSpace.Projection",
CPLString().Printf( "\"%s\"", szERSProj ) );
poHeader->Set( "RasterInfo.WarpControl.CoordinateSpace.CoordinateType",
CPLString().Printf( "EN" ) );
poHeader->Set( "RasterInfo.WarpControl.CoordinateSpace.Units",
CPLString().Printf( "\"%s\"", szERSUnits ) );
poHeader->Set( "RasterInfo.WarpControl.CoordinateSpace.Rotation",
"0:0:0.0" );
/* -------------------------------------------------------------------- */
/* Translate the GCPs. */
/* -------------------------------------------------------------------- */
CPLString osControlPoints = "{\n";
int iGCP;
for( iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
CPLString osLine;
CPLString osId = pasGCPList[iGCP].pszId;
if( strlen(osId) == 0 )
osId.Printf( "%d", iGCP + 1 );
osLine.Printf( "\t\t\t\t\"%s\"\tYes\tYes\t%.6f\t%.6f\t%.15g\t%.15g\t%.15g\n",
osId.c_str(),
pasGCPList[iGCP].dfGCPPixel,
pasGCPList[iGCP].dfGCPLine,
pasGCPList[iGCP].dfGCPX,
pasGCPList[iGCP].dfGCPY,
pasGCPList[iGCP].dfGCPZ );
osControlPoints += osLine;
}
osControlPoints += "\t\t}";
poHeader->Set( "RasterInfo.WarpControl.ControlPoints", osControlPoints );
return CE_None;
}
void otb::Wrapper::Aggregate::DoExecute()
{
// Récupération de la labelmap
LabelImageType::Pointer labelIn = GetParameterUInt32Image("inseg");
labelIn->SetRequestedRegionToLargestPossibleRegion();
labelIn->Update();
// Filtre statistique pour récupérer le nombre de label dans la labelmap
StatisticsImageFilterType::Pointer stats = StatisticsImageFilterType::New();
stats->SetInput(labelIn);
stats->Update();
unsigned int regionCount=stats->GetMaximum();
otbAppLogINFO(<<"Number of objects: "<<regionCount);
//Récupération de la classification et statistique pour connaître le nombre de classes
ImageType::Pointer imageIn = GetParameterUInt32Image("in");
stats->SetInput(imageIn);
stats->Update();
unsigned int nbclass=stats->GetMaximum()-stats->GetMinimum()+1;
otbAppLogINFO(<<"Number of classes: "<<nbclass);
unsigned int minimum =stats->GetMinimum();
otbAppLogINFO(<<"Minimum: "<<minimum);
// Filtre LabelImage vers LabelMap(StatisticsLabelObject)
ConverterStatisticsType::Pointer converterStats = ConverterStatisticsType::New();
converterStats->SetInput(labelIn);
converterStats->SetBackgroundValue(0);
converterStats->Update();
// Calcul des statistiques par objet de la LabelMap
StatisticsFilterType::Pointer statistics = StatisticsFilterType::New();
statistics->SetInput(converterStats->GetOutput());
statistics->SetFeatureImage(imageIn);
statistics->SetNumberOfBins(nbclass);
statistics->Update();
// Définition du filtre ChangeLabel
m_ChangeLabelFilter = ChangeLabelImageFilterType::New();
m_ChangeLabelFilter->SetInput(labelIn);
// Iteration sur les objets, récupération de l'histogramme, extraction de la valeur mojoritaire
// Changement de la valeur du label par la valeur majoritaire dans la label map => obtention d'une classification corrigée
for(unsigned int i=0; i<regionCount+1; i++)
{
if(statistics->GetOutput()->HasLabel(i))
{
const StatisticsLabelObjectType *labelObjectStats = statistics->GetOutput()->GetLabelObject(i);
const HistogramType *histogram = labelObjectStats->GetHistogram();
unsigned int var = 0;
unsigned int classe = minimum;
for(unsigned int j=0; j< nbclass; j++)
{
if(histogram->GetFrequency(j)>var)
{
var = histogram->GetFrequency(j);
classe = j+minimum;
}
}
m_ChangeLabelFilter->SetChange(i,classe);
}
}
SetParameterOutputImage("outim", m_ChangeLabelFilter->GetOutput());
//Vectorisation
otbAppLogINFO(<<"Vectorization...");
//Définition du shapefile
const std::string shapefile = GetParameterString("out");
otb::ogr::DataSource::Pointer ogrDS;
otb::ogr::Layer layer(NULL, false);
std::string projRef = imageIn->GetProjectionRef();
OGRSpatialReference oSRS(projRef.c_str());
otbAppLogINFO(<< projRef);
std::vector<std::string> options;
ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Overwrite);
std::string layername = itksys::SystemTools::GetFilenameName(shapefile.c_str());
std::string const extension = itksys::SystemTools::GetFilenameLastExtension(shapefile.c_str());
layername = layername.substr(0,layername.size()-(extension.size()));
layer = ogrDS->CreateLayer(layername, &oSRS, wkbMultiPolygon, options);
OGRFieldDefn labelField("label", OFTInteger);
layer.CreateField(labelField, true);
OGRFieldDefn MajorityField("Majority", OFTInteger);
layer.CreateField(MajorityField, true);
// Write label image
/*
WriterType::Pointer writer = WriterType::New();
writer->SetInput(m_ChangeLabelFilter->GetOutput());
writer->SetFileName("label_image.tif");
writer->Update();
*/
// Filtre LabelImage vers OGRDataSource
LabelImageToOGRDataSourceFilterType::Pointer labelToOGR = LabelImageToOGRDataSourceFilterType::New();
labelToOGR->SetInput(m_ChangeLabelFilter->GetOutput());
labelToOGR->SetInputMask(m_ChangeLabelFilter->GetOutput()); // La classe 0 est considérée comme du background et n'est pas vectorisée
labelToOGR->SetFieldName("Majority");
labelToOGR->Update();
otb::ogr::DataSource::ConstPointer ogrDSTmp = labelToOGR->GetOutput();
otb::ogr::Layer layerTmp = ogrDSTmp->GetLayerChecked(0);
otb::ogr::Layer::const_iterator featIt = layerTmp.begin();
int nveau_label = 1;
for(; featIt!=layerTmp.end(); ++featIt)
{
otb::ogr::Feature dstFeature(layer.GetLayerDefn());
dstFeature.SetFrom( *featIt, TRUE );
layer.CreateFeature( dstFeature );
dstFeature.ogr().SetField("label",nveau_label);
layer.SetFeature(dstFeature);
nveau_label +=1;
}
otbAppLogINFO(<<"Processing complete.");
}
int OGRMySQLDataSource::FetchSRSId( OGRSpatialReference * poSRS )
{
if( poSRS == nullptr )
return GetUnknownSRID();
OGRSpatialReference oSRS(*poSRS);
// cppcheck-suppress uselessAssignmentPtrArg
poSRS = nullptr;
const char* pszAuthorityName = oSRS.GetAuthorityName(nullptr);
if( pszAuthorityName == nullptr || strlen(pszAuthorityName) == 0 )
{
/* -------------------------------------------------------------------- */
/* Try to identify an EPSG code */
/* -------------------------------------------------------------------- */
oSRS.AutoIdentifyEPSG();
pszAuthorityName = oSRS.GetAuthorityName(nullptr);
if (pszAuthorityName != nullptr && EQUAL(pszAuthorityName, "EPSG"))
{
const char* pszAuthorityCode = oSRS.GetAuthorityCode(nullptr);
if ( pszAuthorityCode != nullptr && strlen(pszAuthorityCode) > 0 )
{
/* Import 'clean' SRS */
oSRS.importFromEPSG( atoi(pszAuthorityCode) );
pszAuthorityName = oSRS.GetAuthorityName(nullptr);
}
}
}
/* -------------------------------------------------------------------- */
/* Check whether the authority name/code is already mapped to a */
/* SRS ID. */
/* -------------------------------------------------------------------- */
CPLString osCommand;
int nAuthorityCode = 0;
if( pszAuthorityName != nullptr )
{
/* Check that the authority code is integral */
nAuthorityCode = atoi( oSRS.GetAuthorityCode(nullptr) );
if( nAuthorityCode > 0 )
{
if( GetMajorVersion() < 8 || IsMariaDB() )
{
osCommand.Printf(
"SELECT srid FROM spatial_ref_sys WHERE "
"auth_name = '%s' AND auth_srid = %d",
pszAuthorityName,
nAuthorityCode );
}
else
{
osCommand.Printf(
"SELECT SRS_ID FROM INFORMATION_SCHEMA.ST_SPATIAL_REFERENCE_SYSTEMS "
"WHERE ORGANIZATION = '%s' AND ORGANIZATION_COORDSYS_ID = %d",
pszAuthorityName,
nAuthorityCode );
}
MYSQL_RES *hResult = nullptr;
if( !mysql_query( GetConn(), osCommand ) )
hResult = mysql_store_result( GetConn() );
if ( hResult != nullptr && !mysql_num_rows(hResult))
{
CPLDebug("MYSQL", "No rows exist currently exist in spatial_ref_sys");
mysql_free_result( hResult );
hResult = nullptr;
}
char **papszRow = nullptr;
if( hResult != nullptr )
papszRow = mysql_fetch_row( hResult );
if( papszRow != nullptr && papszRow[0] != nullptr )
{
const int nSRSId = atoi(papszRow[0]);
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
return nSRSId;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
}
}
/* -------------------------------------------------------------------- */
/* Translate SRS to WKT. */
/* -------------------------------------------------------------------- */
char *pszWKT = nullptr;
if( oSRS.exportToWkt( &pszWKT ) != OGRERR_NONE )
return GetUnknownSRID();
/* -------------------------------------------------------------------- */
/* Try to find in the existing record. */
/* -------------------------------------------------------------------- */
if( GetMajorVersion() < 8 || IsMariaDB() )
{
osCommand.Printf(
"SELECT srid FROM spatial_ref_sys WHERE srtext = '%s'",
pszWKT );
}
else
{
osCommand.Printf(
"SELECT SRS_ID FROM INFORMATION_SCHEMA.ST_SPATIAL_REFERENCE_SYSTEMS WHERE DEFINITION = '%s'",
pszWKT );
}
MYSQL_RES *hResult = nullptr;
if( !mysql_query( GetConn(), osCommand ) )
hResult = mysql_store_result( GetConn() );
if ( hResult != nullptr && !mysql_num_rows(hResult))
{
CPLDebug("MYSQL", "No rows exist currently exist in spatial_ref_sys");
mysql_free_result( hResult );
hResult = nullptr;
}
char **papszRow = nullptr;
if( hResult != nullptr )
papszRow = mysql_fetch_row( hResult );
if( papszRow != nullptr && papszRow[0] != nullptr )
{
const int nSRSId = atoi(papszRow[0]);
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
CPLFree(pszWKT);
return nSRSId;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
// TODO: try to insert in INFORMATION_SCHEMA.ST_SPATIAL_REFERENCE_SYSTEMS
if( GetMajorVersion() >= 8 && !IsMariaDB() )
{
CPLFree(pszWKT);
return GetUnknownSRID();
}
/* -------------------------------------------------------------------- */
/* Get the current maximum srid in the srs table. */
/* -------------------------------------------------------------------- */
osCommand = "SELECT MAX(srid) FROM spatial_ref_sys";
if( !mysql_query( GetConn(), osCommand ) )
{
hResult = mysql_store_result( GetConn() );
papszRow = mysql_fetch_row( hResult );
}
const int nSRSId = papszRow != nullptr && papszRow[0] != nullptr
? atoi(papszRow[0]) + 1
: 1;
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
/* -------------------------------------------------------------------- */
/* Try adding the SRS to the SRS table. */
/* -------------------------------------------------------------------- */
osCommand.Printf(
"INSERT INTO spatial_ref_sys (srid,srtext) VALUES (%d,'%s')",
nSRSId, pszWKT );
if( !mysql_query( GetConn(), osCommand ) )
/*hResult = */ mysql_store_result( GetConn() ); /* FIXME ? */
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
CPLFree(pszWKT);
return nSRSId;
}