/* Function that parses multiple options in the a list. It also supports
min/maxscaledenom checks. ie. "CONTOUR_INTERVAL=0,3842942:10" */
static char* msContourGetOption(layerObj *layer, const char *name)
{
int c, i, found = MS_FALSE;
char **values, **tmp, **options;
double maxscaledenom, minscaledenom;
char *value = NULL;
options = CSLFetchNameValueMultiple(layer->processing, name);
c = CSLCount(options);
for (i=0; i<c && found == MS_FALSE; ++i) {
values = CSLTokenizeStringComplex(options[i], ":", FALSE, FALSE);
if (CSLCount(values) == 2) {
tmp = CSLTokenizeStringComplex(values[0], ",", FALSE, FALSE);
if (CSLCount(tmp) == 2) {
minscaledenom = atof(tmp[0]);
maxscaledenom = atof(tmp[1]);
if (layer->map->scaledenom <= 0 ||
(((maxscaledenom <= 0) || (layer->map->scaledenom <= maxscaledenom)) &&
((minscaledenom <= 0) || (layer->map->scaledenom > minscaledenom)))) {
value = msStrdup(values[1]);
found = MS_TRUE;
}
}
CSLDestroy(tmp);
}
CSLDestroy(values);
}
CSLDestroy(options);
return value;
}
OGRLayer *GNMGenericNetwork::GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
GNMGraphAlgorithmType eAlgorithm, char **papszOptions)
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return NULL;
}
GDALDriver* poMEMDrv =
OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("Memory");
if (poMEMDrv == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load 'Memory' driver");
return NULL;
}
GDALDataset* poMEMDS =
poMEMDrv->Create("dummy_name", 0, 0, 0, GDT_Unknown, NULL);
OGRSpatialReference oDstSpaRef(GetProjectionRef());
OGRLayer* poMEMLayer = poMEMDS->CreateLayer(GetAlgorithmName(eAlgorithm,
true), &oDstSpaRef, wkbGeometryCollection, NULL);
OGRGNMWrappedResultLayer* poResLayer =
new OGRGNMWrappedResultLayer(poMEMDS, poMEMLayer);
const bool bReturnEdges = CPLFetchBool(papszOptions, GNM_MD_FETCHEDGES, true);
const bool bReturnVertices = CPLFetchBool(papszOptions, GNM_MD_FETCHVERTEX, true);
switch (eAlgorithm)
{
case GATDijkstraShortestPath:
{
GNMPATH path = m_oGraph.DijkstraShortestPath(nStartFID, nEndFID);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
case GATKShortestPath:
{
int nK = atoi(CSLFetchNameValueDef(papszOptions, GNM_MD_NUM_PATHS,
"1"));
CPLDebug("GNM", "Search %d path(s)", nK);
std::vector<GNMPATH> paths = m_oGraph.KShortestPaths(nStartFID,
nEndFID, nK);
// fill features in result layer
for(size_t i = 0; i < paths.size(); ++i)
{
FillResultLayer(poResLayer, paths[i], static_cast<int>(i + 1), bReturnVertices,
bReturnEdges);
}
}
break;
case GATConnectedComponents:
{
GNMVECTOR anEmitters;
if(NULL != papszOptions)
{
char** papszEmitter = CSLFetchNameValueMultiple(papszOptions, GNM_MD_EMITTER);
for(int i = 0; papszEmitter[i] != NULL; ++i)
{
GNMGFID nEmitter = atol(papszEmitter[i]);
anEmitters.push_back(nEmitter);
}
CSLDestroy(papszEmitter);
}
if(nStartFID != -1)
{
anEmitters.push_back(nStartFID);
}
if(nStartFID != -1)
{
anEmitters.push_back(nEndFID);
}
GNMPATH path = m_oGraph.ConnectedComponents(anEmitters);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
}
return poResLayer;
}
static void
GDALSimpleWarpRemapping( int nBandCount, GByte **papabySrcData,
int nSrcXSize, int nSrcYSize,
char **papszWarpOptions )
{
/* ==================================================================== */
/* Process any and all single value REMAP commands. */
/* ==================================================================== */
char **papszRemaps = CSLFetchNameValueMultiple( papszWarpOptions,
"REMAP" );
for( int iRemap = 0; iRemap < CSLCount(papszRemaps); iRemap++ )
{
/* -------------------------------------------------------------------- */
/* What are the pixel values to map from and to? */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( papszRemaps[iRemap] );
if( CSLCount(papszTokens) != 2 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Ill formed REMAP `%s' ignored in GDALSimpleWarpRemapping()",
papszRemaps[iRemap] );
CSLDestroy( papszTokens );
continue;
}
const int nFromValue = atoi(papszTokens[0]);
const int nToValue = atoi(papszTokens[1]);
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Pass over each band searching for matches. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
GByte *pabyData = papabySrcData[iBand];
int nPixelCount = nSrcXSize * nSrcYSize;
while( nPixelCount != 0 )
{
if( *pabyData == nFromValue )
*pabyData = static_cast<GByte>( nToValue );
pabyData++;
nPixelCount--;
}
}
}
CSLDestroy( papszRemaps );
/* ==================================================================== */
/* Process any and all REMAP_MULTI commands. */
/* ==================================================================== */
papszRemaps = CSLFetchNameValueMultiple( papszWarpOptions,
"REMAP_MULTI" );
for( int iRemap = 0; iRemap < CSLCount(papszRemaps); iRemap++ )
{
/* -------------------------------------------------------------------- */
/* What are the pixel values to map from and to? */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( papszRemaps[iRemap] );
if( CSLCount(papszTokens) % 2 == 1
|| CSLCount(papszTokens) == 0
|| CSLCount(papszTokens) > nBandCount * 2 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Ill formed REMAP_MULTI `%s' ignored in GDALSimpleWarpRemapping()",
papszRemaps[iRemap] );
CSLDestroy( papszTokens );
continue;
}
const int nMapBandCount = CSLCount(papszTokens) / 2;
int *panFromValue = static_cast<int *>(
CPLMalloc(sizeof(int) * nMapBandCount ) );
int *panToValue = static_cast<int *>(
CPLMalloc(sizeof(int) * nMapBandCount ) );
for( int iBand = 0; iBand < nMapBandCount; iBand++ )
{
panFromValue[iBand] = atoi(papszTokens[iBand]);
panToValue[iBand] = atoi(papszTokens[iBand+nMapBandCount]);
}
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Search for matching values to replace. */
/* -------------------------------------------------------------------- */
const int nPixelCount = nSrcXSize * nSrcYSize;
for( int iPixel = 0; iPixel < nPixelCount; iPixel++ )
{
if( papabySrcData[0][iPixel] != panFromValue[0] )
continue;
bool bMatch = true;
for( int iBand = 1; iBand < nMapBandCount; iBand++ )
{
if( papabySrcData[iBand][iPixel] != panFromValue[iBand] )
bMatch = false;
}
if( !bMatch )
continue;
for( int iBand = 0; iBand < nMapBandCount; iBand++ )
papabySrcData[iBand][iPixel] =
static_cast<GByte>( panToValue[iBand] );
}
CPLFree( panFromValue );
CPLFree( panToValue );
}
CSLDestroy( papszRemaps );
}
