OGRFeature *OGRDWGLayer::TranslateDIMENSION( OdDbEntityPtr poEntity )
{
OdDbDimensionPtr poDim = OdDbDimension::cast( poEntity );
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
double dfHeight = CPLAtof(poDS->GetVariable("$DIMTXT", "2.5"));
OdGePoint3d oTextPos, oTarget1, oTarget2, oArrow1;
CPLString osText;
TranslateGenericProperties( poFeature, poEntity );
/* -------------------------------------------------------------------- */
/* Generic Dimension stuff. */
/* -------------------------------------------------------------------- */
osText = (const char *) poDim->dimensionText();
oTextPos = poDim->textPosition();
/* -------------------------------------------------------------------- */
/* Specific based on the subtype. */
/* -------------------------------------------------------------------- */
OdRxClass *poClass = poEntity->isA();
const OdString osName = poClass->name();
const char *pszEntityClassName = (const char *) osName;
if( EQUAL(pszEntityClassName,"AcDbRotatedDimension") )
{
OdDbRotatedDimensionPtr poRDim = OdDbDimension::cast( poEntity );
oTarget2 = poRDim->xLine1Point();
oTarget1 = poRDim->xLine2Point();
oArrow1 = poRDim->dimLinePoint();
}
else if( EQUAL(pszEntityClassName,"AcDbAlignedDimension") )
{
OdDbAlignedDimensionPtr poADim = OdDbDimension::cast( poEntity );
oTarget2 = poADim->xLine1Point();
oTarget1 = poADim->xLine2Point();
oArrow1 = poADim->dimLinePoint();
}
/*************************************************************************
DIMENSION geometry layout
(11,21)(text center point)
| DimText |
(10,20) X<--------------------------------->X (Arrow2 - computed)
(Arrow1)| |
| |
| X (13,23) (Target2)
|
X (14,24) (Target1)
Given:
Locations Arrow1, Target1, and Target2 we need to compute Arrow2.
Steps:
1) Compute direction vector from Target1 to Arrow1 (Vec1).
2) Compute direction vector for arrow as perpendicular to Vec1 (call Vec2).
3) Compute Arrow2 location as intersection between line defined by
Vec2 and Arrow1 and line defined by Target2 and direction Vec1 (call Arrow2)
Then we can draw lines for the various components.
Note that Vec1 and Vec2 may be horizontal, vertical or on an angle but
the approach is as above in all these cases.
*************************************************************************/
/* -------------------------------------------------------------------- */
/* Step 1, compute direction vector between Target1 and Arrow1. */
/* -------------------------------------------------------------------- */
double dfVec1X, dfVec1Y;
dfVec1X = (oArrow1.x - oTarget1.x);
dfVec1Y = (oArrow1.y - oTarget1.y);
/* -------------------------------------------------------------------- */
/* Step 2, compute the direction vector from Arrow1 to Arrow2 */
/* as a perpendicular to Vec1. */
/* -------------------------------------------------------------------- */
double dfVec2X, dfVec2Y;
dfVec2X = dfVec1Y;
dfVec2Y = -dfVec1X;
/* -------------------------------------------------------------------- */
/* Step 3, compute intersection of line from target2 along */
/* direction vector 1, with the line through Arrow1 and */
/* direction vector 2. */
/* -------------------------------------------------------------------- */
double dfL1M, dfL1B, dfL2M, dfL2B;
double dfArrowX2, dfArrowY2;
// special case if vec1 is vertical.
if( dfVec1X == 0.0 )
{
dfArrowX2 = oTarget2.x;
dfArrowY2 = oArrow1.y;
}
// special case if vec2 is horizontal.
else if( dfVec1Y == 0.0 )
{
dfArrowX2 = oArrow1.x;
dfArrowY2 = oTarget2.y;
}
else // General case for diagonal vectors.
{
// first convert vec1 + target2 into y = mx + b format: call this L1
dfL1M = dfVec1Y / dfVec1X;
dfL1B = oTarget2.y - dfL1M * oTarget2.x;
// convert vec2 + Arrow1 into y = mx + b format, call this L2
dfL2M = dfVec2Y / dfVec2X;
dfL2B = oArrow1.y - dfL2M * oArrow1.x;
// Compute intersection x = (b2-b1) / (m1-m2)
dfArrowX2 = (dfL2B - dfL1B) / (dfL1M-dfL2M);
dfArrowY2 = dfL2M * dfArrowX2 + dfL2B;
}
/* -------------------------------------------------------------------- */
/* Compute the text angle. */
/* -------------------------------------------------------------------- */
double dfAngle = atan2(dfVec2Y,dfVec2X) * 180.0 / M_PI;
/* -------------------------------------------------------------------- */
/* Rescale the direction vectors so we can use them in */
/* constructing arrowheads. We want them to be about 3% of the */
/* length of line on which the arrows will be drawn. */
/* -------------------------------------------------------------------- */
#define VECTOR_LEN(x,y) sqrt( (x)*(x) + (y)*(y) )
#define POINT_DIST(x1,y1,x2,y2) VECTOR_LEN((x2-x1),(y2-y1))
double dfBaselineLength = POINT_DIST(oArrow1.x,oArrow1.y,
dfArrowX2,dfArrowY2);
double dfTargetLength = dfBaselineLength * 0.03;
double dfScaleFactor;
// recompute vector 2 to ensure the direction is regular
dfVec2X = (dfArrowX2 - oArrow1.x);
dfVec2Y = (dfArrowY2 - oArrow1.y);
// vector 1
dfScaleFactor = dfTargetLength / VECTOR_LEN(dfVec1X,dfVec1Y);
dfVec1X *= dfScaleFactor;
dfVec1Y *= dfScaleFactor;
// vector 2
dfScaleFactor = dfTargetLength / VECTOR_LEN(dfVec2X,dfVec2Y);
dfVec2X *= dfScaleFactor;
dfVec2Y *= dfScaleFactor;
/* -------------------------------------------------------------------- */
/* Create geometries for the different components of the */
/* dimension object. */
/* -------------------------------------------------------------------- */
OGRMultiLineString *poMLS = new OGRMultiLineString();
OGRLineString oLine;
// main arrow line between Arrow1 and Arrow2
oLine.setPoint( 0, oArrow1.x, oArrow1.y );
oLine.setPoint( 1, dfArrowX2, dfArrowY2 );
poMLS->addGeometry( &oLine );
// dimension line from Target1 to Arrow1 with a small extension.
oLine.setPoint( 0, oTarget1.x, oTarget1.y );
oLine.setPoint( 1, oArrow1.x + dfVec1X, oArrow1.y + dfVec1Y );
poMLS->addGeometry( &oLine );
// dimension line from Target2 to Arrow2 with a small extension.
oLine.setPoint( 0, oTarget2.x, oTarget2.y );
oLine.setPoint( 1, dfArrowX2 + dfVec1X, dfArrowY2 + dfVec1Y );
poMLS->addGeometry( &oLine );
// add arrow1 arrow head.
oLine.setPoint( 0, oArrow1.x, oArrow1.y );
oLine.setPoint( 1,
oArrow1.x + dfVec2X*3 + dfVec1X,
oArrow1.y + dfVec2Y*3 + dfVec1Y );
poMLS->addGeometry( &oLine );
oLine.setPoint( 0, oArrow1.x, oArrow1.y );
oLine.setPoint( 1,
oArrow1.x + dfVec2X*3 - dfVec1X,
oArrow1.y + dfVec2Y*3 - dfVec1Y );
poMLS->addGeometry( &oLine );
// add arrow2 arrow head.
oLine.setPoint( 0, dfArrowX2, dfArrowY2 );
oLine.setPoint( 1,
dfArrowX2 - dfVec2X*3 + dfVec1X,
dfArrowY2 - dfVec2Y*3 + dfVec1Y );
poMLS->addGeometry( &oLine );
oLine.setPoint( 0, dfArrowX2, dfArrowY2 );
oLine.setPoint( 1,
dfArrowX2 - dfVec2X*3 - dfVec1X,
dfArrowY2 - dfVec2Y*3 - dfVec1Y );
poMLS->addGeometry( &oLine );
poFeature->SetGeometryDirectly( poMLS );
PrepareLineStyle( poFeature );
/* -------------------------------------------------------------------- */
/* Is the layer disabled/hidden/frozen/off? */
/* -------------------------------------------------------------------- */
CPLString osLayer = poFeature->GetFieldAsString("Layer");
int bHidden =
EQUAL(poDS->LookupLayerProperty( osLayer, "Hidden" ), "1");
/* -------------------------------------------------------------------- */
/* Work out the color for this feature. */
/* -------------------------------------------------------------------- */
int nColor = 256;
if( oStyleProperties.count("Color") > 0 )
nColor = atoi(oStyleProperties["Color"]);
// Use layer color?
if( nColor < 1 || nColor > 255 )
{
const char *pszValue = poDS->LookupLayerProperty( osLayer, "Color" );
if( pszValue != NULL )
nColor = atoi(pszValue);
}
if( nColor < 1 || nColor > 255 )
nColor = 8;
/* -------------------------------------------------------------------- */
/* Prepare a new feature to serve as the dimension text label */
/* feature. We will push it onto the layer as a pending */
/* feature for the next feature read. */
/* -------------------------------------------------------------------- */
// a single space suppresses labeling.
if( osText == " " )
return poFeature;
OGRFeature *poLabelFeature = poFeature->Clone();
poLabelFeature->SetGeometryDirectly( new OGRPoint( oTextPos.x, oTextPos.y ) );
// Do we need to compute the dimension value?
if( osText.empty() )
{
FormatDimension( osText, POINT_DIST( oArrow1.x, oArrow1.y,
dfArrowX2, dfArrowY2 ) );
}
CPLString osStyle;
char szBuffer[64];
char* pszComma = NULL;
osStyle.Printf("LABEL(f:\"Arial\",t:\"%s\",p:5",osText.c_str());
if( dfAngle != 0.0 )
{
CPLsnprintf(szBuffer, sizeof(szBuffer), "%.3g", dfAngle);
pszComma = strchr(szBuffer, ',');
if (pszComma)
*pszComma = '.';
osStyle += CPLString().Printf(",a:%s", szBuffer);
}
if( dfHeight != 0.0 )
{
CPLsnprintf(szBuffer, sizeof(szBuffer), "%.3g", dfHeight);
pszComma = strchr(szBuffer, ',');
if (pszComma)
*pszComma = '.';
osStyle += CPLString().Printf(",s:%sg", szBuffer);
}
const unsigned char *pabyDWGColors = ACGetColorTable();
snprintf( szBuffer, sizeof(szBuffer), ",c:#%02x%02x%02x",
pabyDWGColors[nColor*3+0],
pabyDWGColors[nColor*3+1],
pabyDWGColors[nColor*3+2] );
osStyle += szBuffer;
if( bHidden )
osStyle += "00";
osStyle += ")";
poLabelFeature->SetStyleString( osStyle );
apoPendingFeatures.push( poLabelFeature );
return poFeature;
}
bool VSIOSSHandleHelper::GetConfiguration(CSLConstList papszOptions,
CPLString& osSecretAccessKey,
CPLString& osAccessKeyId)
{
osSecretAccessKey = CSLFetchNameValueDef(papszOptions,
"OSS_SECRET_ACCESS_KEY",
CPLGetConfigOption("OSS_SECRET_ACCESS_KEY", ""));
if( !osSecretAccessKey.empty() )
{
osAccessKeyId = CSLFetchNameValueDef(papszOptions,
"OSS_ACCESS_KEY_ID",
CPLGetConfigOption("OSS_ACCESS_KEY_ID", ""));
if( osAccessKeyId.empty() )
{
VSIError(VSIE_AWSInvalidCredentials,
"OSS_ACCESS_KEY_ID configuration option not defined");
return false;
}
return true;
}
VSIError(VSIE_AWSInvalidCredentials,
"OSS_SECRET_ACCESS_KEY configuration option not defined");
return false;
}
OGRFeature *OGRIDBTableLayer::GetFeature( GIntBig nFeatureId )
{
if( pszFIDColumn == NULL )
return OGRIDBLayer::GetFeature( nFeatureId );
ClearQuery();
iNextShapeId = nFeatureId;
poCurr = new ITCursor( *poDS->GetConnection() );
// Create list of fields
CPLString osFields;
if ( poFeatureDefn->GetFieldIndex( pszFIDColumn ) == -1 )
osFields += pszFIDColumn;
if ( pszGeomColumn )
{
if ( ! osFields.empty() )
osFields += ",";
osFields += "st_asbinary(";
osFields += pszGeomColumn;
osFields += ") as ";
osFields += pszGeomColumn;
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if ( ! osFields.empty() )
osFields += ",";
osFields += poFeatureDefn->GetFieldDefn(i)->GetNameRef();
}
CPLString sql;
sql.Printf( "SELECT %s FROM %s WHERE %s = %d",
osFields.c_str(), poFeatureDefn->GetName(),
pszFIDColumn, nFeatureId );
CPLDebug( "OGR_IDB", "ExecuteSQL(%s)", sql.c_str() );
if( !poCurr->Prepare( sql.c_str() ) ||
!poCurr->Open(ITCursor::ReadOnly) )
{
delete poCurr;
poCurr = NULL;
return NULL;
}
return GetNextRawFeature();
}
const char *ISIS2Dataset::GetProjectionRef()
{
if( !osProjection.empty() )
return osProjection;
return GDALPamDataset::GetProjectionRef();
}
OGRLayer* OGRPLScenesDataV1Dataset::ParseItemType(json_object* poItemType)
{
if( poItemType == nullptr || json_object_get_type(poItemType) != json_type_object )
return nullptr;
json_object* poId = CPL_json_object_object_get(poItemType, "id");
if( poId == nullptr || json_object_get_type(poId) != json_type_string )
return nullptr;
CPLString osDisplayDescription;
json_object* poDisplayDescription = CPL_json_object_object_get(poItemType, "display_description");
if( poDisplayDescription != nullptr && json_object_get_type(poDisplayDescription) == json_type_string )
osDisplayDescription = json_object_get_string(poDisplayDescription);
CPLString osDisplayName;
json_object* poDisplayName = CPL_json_object_object_get(poItemType, "display_name");
if( poDisplayName != nullptr && json_object_get_type(poDisplayName) == json_type_string )
osDisplayName = json_object_get_string(poDisplayName);
const char* pszId = json_object_get_string(poId);
// The layer might already exist if GetLayerByName() is called before
// GetLayer()/GetLayerCount() is
// Prevent GetLayerCount() from calling EstablishLayerList()
bool bLayerListInitializedBackup = m_bLayerListInitialized;
m_bLayerListInitialized = true;
OGRLayer* poExistingLayer = GDALDataset::GetLayerByName(pszId);
m_bLayerListInitialized = bLayerListInitializedBackup;
if( poExistingLayer != nullptr )
return poExistingLayer;
OGRPLScenesDataV1Layer* poPLLayer = new OGRPLScenesDataV1Layer(
this, pszId);
if( !osDisplayName.empty() )
poPLLayer->SetMetadataItem("SHORT_DESCRIPTION", osDisplayName.c_str());
if( !osDisplayDescription.empty() )
poPLLayer->SetMetadataItem("DESCRIPTION", osDisplayDescription.c_str());
m_papoLayers = (OGRPLScenesDataV1Layer**) CPLRealloc(m_papoLayers,
sizeof(OGRPLScenesDataV1Layer*) * (m_nLayers + 1));
m_papoLayers[m_nLayers ++] = poPLLayer;
return poPLLayer;
}
// See:
// https://www.alibabacloud.com/help/doc-detail/31951.htm?spm=a3c0i.o31982en.b99.178.5HUTqV
static struct curl_slist*
CPLGetOSSHeaders( const CPLString& osSecretAccessKey,
const CPLString& osAccessKeyId,
const CPLString& osVerb,
const struct curl_slist* psExistingHeaders,
const CPLString& osCanonicalizedResource )
{
CPLString osDate = CPLGetConfigOption("CPL_OSS_TIMESTAMP", "");
if( osDate.empty() )
{
osDate = IVSIS3LikeHandleHelper::GetRFC822DateTime();
}
std::map<CPLString, CPLString> oSortedMapHeaders;
CPLString osCanonicalizedHeaders(
IVSIS3LikeHandleHelper::BuildCanonicalizedHeaders(
oSortedMapHeaders,
psExistingHeaders,
"x-oss-"));
CPLString osStringToSign;
osStringToSign += osVerb + "\n";
osStringToSign += CPLAWSGetHeaderVal(psExistingHeaders, "Content-MD5") + "\n";
osStringToSign += CPLAWSGetHeaderVal(psExistingHeaders, "Content-Type") + "\n";
osStringToSign += osDate + "\n";
osStringToSign += osCanonicalizedHeaders;
osStringToSign += osCanonicalizedResource;
#ifdef DEBUG_VERBOSE
CPLDebug("OSS", "osStringToSign = %s", osStringToSign.c_str());
#endif
/* -------------------------------------------------------------------- */
/* Build authorization header. */
/* -------------------------------------------------------------------- */
CPLString osAuthorization("OSS ");
osAuthorization += osAccessKeyId;
osAuthorization += ":";
osAuthorization += GetSignature(osStringToSign, osSecretAccessKey);
#ifdef DEBUG_VERBOSE
CPLDebug("OSS", "osAuthorization='%s'", osAuthorization.c_str());
#endif
struct curl_slist *headers=nullptr;
headers = curl_slist_append(
headers, CPLSPrintf("Date: %s", osDate.c_str()));
headers = curl_slist_append(
headers, CPLSPrintf("Authorization: %s", osAuthorization.c_str()));
return headers;
}
static bool IsValidXPath(const CPLString& osXPath )
{
// Check that the XPath syntax belongs to the subset we
// understand
bool bOK = !osXPath.empty();
for(size_t i = 0; i < osXPath.size(); ++i )
{
const char chCur = osXPath[i];
if( chCur == '/' )
{
// OK
}
else if( chCur == '@' &&
(i == 0 || osXPath[i-1] == '/') &&
i < osXPath.size()-1 &&
isalpha( static_cast<int>(osXPath[i+1]) ) )
{
// OK
}
else if( chCur == '_' ||
isalpha( static_cast<int>(chCur) ) )
{
// OK
}
else if( isdigit( static_cast<int>(chCur) ) &&
i > 0 &&
(isalnum( static_cast<int>(osXPath[i-1]) ) ||
osXPath[i-1] == '_') )
{
// OK
}
else if( chCur == ':' &&
i > 0 &&
(isalnum( static_cast<int>(osXPath[i-1]) ) ||
osXPath[i-1] == '_') &&
i < osXPath.size()-1 &&
isalpha( static_cast<int>(osXPath[i+1]) ) )
{
// OK
}
else
{
bOK = false;
break;
}
}
return bOK;
}
OGRErr OGRAmigoCloudDataSource::DeleteLayer(int iLayer)
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if( iLayer < 0 || iLayer >= nLayers )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %d not in legal range of 0 to %d.",
iLayer, nLayers-1 );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Blow away our OGR structures related to the layer. This is */
/* pretty dangerous if anything has a reference to this layer! */
/* -------------------------------------------------------------------- */
CPLString osDatasetId = papoLayers[iLayer]->GetDatasetId();
CPLDebug( "AMIGOCLOUD", "DeleteLayer(%s)", osDatasetId.c_str() );
int bDeferredCreation = papoLayers[iLayer]->GetDeferredCreation();
papoLayers[iLayer]->CancelDeferredCreation();
delete papoLayers[iLayer];
memmove( papoLayers + iLayer, papoLayers + iLayer + 1,
sizeof(void *) * (nLayers - iLayer - 1) );
nLayers--;
if (osDatasetId.empty())
return OGRERR_NONE;
if( !bDeferredCreation )
{
std::stringstream url;
url << std::string(GetAPIURL()) << "/users/0/projects/" + std::string(GetProjectId()) + "/datasets/"+ osDatasetId.c_str();
if( !RunDELETE(url.str().c_str()) ) {
return OGRERR_FAILURE;
}
}
return OGRERR_NONE;
}
std::vector<CPLString> GetOutputDriversFor(const char* pszDestFilename,
int nFlagRasterVector)
{
std::vector<CPLString> aoDriverList;
CPLString osExt = CPLGetExtension(pszDestFilename);
const int nDriverCount = GDALGetDriverCount();
for( int i = 0; i < nDriverCount; i++ )
{
GDALDriverH hDriver = GDALGetDriver(i);
if( (GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, nullptr ) != nullptr ||
GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, nullptr ) != nullptr ) &&
(((nFlagRasterVector & GDAL_OF_RASTER) &&
GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, nullptr ) != nullptr) ||
((nFlagRasterVector & GDAL_OF_VECTOR) &&
GDALGetMetadataItem( hDriver, GDAL_DCAP_VECTOR, nullptr ) != nullptr)) )
{
if( !osExt.empty() && DoesDriverHandleExtension(hDriver, osExt) )
{
aoDriverList.push_back( GDALGetDriverShortName(hDriver) );
}
else
{
const char* pszPrefix = GDALGetMetadataItem(hDriver,
GDAL_DMD_CONNECTION_PREFIX, nullptr);
if( pszPrefix && STARTS_WITH_CI(pszDestFilename, pszPrefix) )
{
aoDriverList.push_back( GDALGetDriverShortName(hDriver) );
}
}
}
}
// GMT is registered before netCDF for opening reasons, but we want
// netCDF to be used by default for output.
if( EQUAL(osExt, "nc") && aoDriverList.size() == 2 &&
EQUAL(aoDriverList[0], "GMT") && EQUAL(aoDriverList[1], "NETCDF") )
{
aoDriverList.clear();
aoDriverList.push_back("NETCDF");
aoDriverList.push_back("GMT");
}
return aoDriverList;
}
bool GNMRule::CanConnect(const CPLString &soSrcLayerName,
const CPLString &soTgtLayerName,
const CPLString &soConnLayerName)
{
if(IsAcceptAny())
return m_bAllow;
if(m_soSrcLayerName == soSrcLayerName &&
m_soTgtLayerName == soTgtLayerName)
{
if(soConnLayerName.empty())
return m_bAllow;
else
return m_bAllow && m_soConnLayerName == soConnLayerName;
}
return false;
}
OGRErr OGRDataSourceWithTransaction::DeleteLayer(int iIndex)
{
if( !m_poBaseDataSource ) return OGRERR_FAILURE;
OGRLayer* poLayer = GetLayer(iIndex);
CPLString osName;
if( poLayer )
osName = poLayer->GetName();
OGRErr eErr = m_poBaseDataSource->DeleteLayer(iIndex);
if( eErr == OGRERR_NONE && !osName.empty() )
{
std::map<CPLString, OGRLayerWithTransaction*>::iterator oIter = m_oMapLayers.find(osName);
if(oIter != m_oMapLayers.end())
{
delete oIter->second;
m_oSetLayers.erase(oIter->second);
m_oMapLayers.erase(oIter);
}
}
return eErr;
}
VSILFILE *VSIFileFromMemBuffer( const char *pszFilename,
GByte *pabyData,
vsi_l_offset nDataLength,
int bTakeOwnership )
{
if( VSIFileManager::GetHandler("")
== VSIFileManager::GetHandler("/vsimem/") )
VSIInstallMemFileHandler();
VSIMemFilesystemHandler *poHandler =
static_cast<VSIMemFilesystemHandler *>(
VSIFileManager::GetHandler("/vsimem/"));
if( pszFilename == nullptr )
return nullptr;
CPLString osFilename = pszFilename;
VSIMemFilesystemHandler::NormalizePath( osFilename );
if( osFilename.empty() )
return nullptr;
VSIMemFile *poFile = new VSIMemFile;
poFile->osFilename = osFilename;
poFile->bOwnData = CPL_TO_BOOL(bTakeOwnership);
poFile->pabyData = pabyData;
poFile->nLength = nDataLength;
poFile->nAllocLength = nDataLength;
{
CPLMutexHolder oHolder( &poHandler->hMutex );
poHandler->Unlink_unlocked(osFilename);
poHandler->oFileList[poFile->osFilename] = poFile;
CPLAtomicInc(&(poFile->nRefCount));
}
// TODO(schwehr): Fix this so that the using statement is not needed.
// Will just adding the bool for bSetError be okay?
return reinterpret_cast<VSILFILE *>( poHandler->Open( osFilename, "r+" ) );
}
/**
* CPLStrip()
*/
CPLString CPLStrip(const CPLString& sString, const char cChar)
{
if(sString.empty())
return sString;
size_t dCopyFrom = 0;
size_t dCopyCount = sString.size();
if (sString[0] == cChar)
{
dCopyFrom++;
dCopyCount--;
}
if (sString[sString.size() - 1] == cChar)
dCopyCount--;
if(dCopyCount == 0)
return CPLString();
return sString.substr(dCopyFrom, dCopyCount);
}
int ROIPACDataset::Identify( GDALOpenInfo *poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Check if: */
/* * 1. The data file extension is known */
/* -------------------------------------------------------------------- */
const char *pszExtension = CPLGetExtension(poOpenInfo->pszFilename);
if ( strcmp( pszExtension, "raw" ) == 0 )
{
/* Since gdal do not read natively CInt8, more work is needed
* to read raw files */
return false;
}
bool bExtensionIsValid = strcmp( pszExtension, "int" ) == 0
|| strcmp( pszExtension, "slc" ) == 0
|| strcmp( pszExtension, "amp" ) == 0
|| strcmp( pszExtension, "cor" ) == 0
|| strcmp( pszExtension, "hgt" ) == 0
|| strcmp( pszExtension, "unw" ) == 0
|| strcmp( pszExtension, "msk" ) == 0
|| strcmp( pszExtension, "trans" ) == 0
|| strcmp( pszExtension, "dem" ) == 0
|| strcmp( pszExtension, "flg" ) == 0;
if ( !bExtensionIsValid )
{
return false;
}
/* -------------------------------------------------------------------- */
/* * 2. there is a .rsc file */
/* -------------------------------------------------------------------- */
CPLString osRscFilename = getRscFilename( poOpenInfo );
if ( osRscFilename.empty() )
{
return false;
}
return true;
}
CPLString VSIOSSHandleHelper::BuildURL(const CPLString& osEndpoint,
const CPLString& osBucket,
const CPLString& osObjectKey,
bool bUseHTTPS, bool bUseVirtualHosting)
{
const char* pszProtocol = (bUseHTTPS) ? "https" : "http";
if( osBucket.empty() )
{
return CPLSPrintf("%s://%s", pszProtocol,
osEndpoint.c_str());
}
else if( bUseVirtualHosting )
return CPLSPrintf("%s://%s.%s/%s", pszProtocol,
osBucket.c_str(),
osEndpoint.c_str(),
CPLAWSURLEncode(osObjectKey, false).c_str());
else
return CPLSPrintf("%s://%s/%s/%s", pszProtocol,
osEndpoint.c_str(),
osBucket.c_str(),
CPLAWSURLEncode(osObjectKey, false).c_str());
}
void GIFAbstractDataset::CollectXMPMetadata()
{
if (fp == nullptr || bHasReadXMPMetadata)
return;
CPLString osXMP = GIFCollectXMPMetadata(fp);
if (!osXMP.empty() )
{
/* Avoid setting the PAM dirty bit just for that */
int nOldPamFlags = nPamFlags;
char *apszMDList[2];
apszMDList[0] = (char*) osXMP.c_str();
apszMDList[1] = nullptr;
SetMetadata(apszMDList, "xml:XMP");
nPamFlags = nOldPamFlags;
}
bHasReadXMPMetadata = TRUE;
}
void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
CPLString osExt = CPLGetExtension(pszDestFilename);
if( !osExt.empty() )
{
GDALDriverH hThisDrv = GDALGetDriverByName(pszDriverName);
if( hThisDrv != NULL && DoesDriverHandleExtension(hThisDrv, osExt) )
return;
const int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for( int i = 0; i < nDriverCount; i++ )
{
GDALDriverH hDriver = GDALGetDriver(i);
if( hDriver != hThisDrv &&
DoesDriverHandleExtension(hDriver, osExt) )
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
}
if (osConflictingDriverList.size())
{
fprintf(
stderr,
"Warning: The target file has a '%s' extension, "
"which is normally used by the %s driver%s, "
"but the requested output driver is %s. "
"Is it really what you want?\n",
osExt.c_str(),
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
}
int ISCEDataset::Identify( GDALOpenInfo *poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* TODO: This function is unusable now: */
/* * we can't just check for the presence of a XML file */
/* the presence of a XML file */
/* * we cannot parse it to check basic tree (Identify() is */
/* supposed to be faster than this */
/* * we could read only a few bytes and strstr() for */
/* "imageData", but what if a file is padded with comments */
/* and/or whitespaces? it would still be legit, but the */
/* driver would fail... */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* Check if there is a .xml file */
/* -------------------------------------------------------------------- */
CPLString osXMLFilename = getXMLFilename( poOpenInfo );
if ( osXMLFilename.empty() )
{
return false;
}
return true;
}
OGRLayer * OGRCouchDBDataSource::ExecuteSQLStats( const char *pszSQLCommand )
{
swq_select sSelectInfo;
if( sSelectInfo.preparse( pszSQLCommand ) != CE_None )
{
return NULL;
}
if (sSelectInfo.table_count != 1)
{
return NULL;
}
swq_table_def *psTableDef = &sSelectInfo.table_defs[0];
if( psTableDef->data_source != NULL )
{
return NULL;
}
OGRCouchDBLayer* _poSrcLayer =
(OGRCouchDBLayer* )GetLayerByName( psTableDef->table_name );
if (_poSrcLayer == NULL)
{
return NULL;
}
if (_poSrcLayer->GetLayerType() != COUCHDB_TABLE_LAYER)
return NULL;
OGRCouchDBTableLayer* poSrcLayer = (OGRCouchDBTableLayer* ) _poSrcLayer;
int nFieldCount = poSrcLayer->GetLayerDefn()->GetFieldCount();
swq_field_list sFieldList;
memset( &sFieldList, 0, sizeof(sFieldList) );
sFieldList.table_count = sSelectInfo.table_count;
sFieldList.table_defs = sSelectInfo.table_defs;
sFieldList.count = 0;
sFieldList.names = static_cast<char **>(
CPLMalloc( sizeof(char *) * nFieldCount ));
sFieldList.types = static_cast<swq_field_type *>(
CPLMalloc( sizeof(swq_field_type) * nFieldCount ));
sFieldList.table_ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
sFieldList.ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
PointerAutoFree oHolderNames(sFieldList.names);
PointerAutoFree oHolderTypes(sFieldList.types);
PointerAutoFree oHolderTableIds(sFieldList.table_ids);
PointerAutoFree oHolderIds(sFieldList.ids);
for( int iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = 0;
sFieldList.ids[iOutField] = iField;
}
CPLString osLastFieldName;
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_name == NULL)
return NULL;
if (strcmp(psColDef->field_name, "*") != 0)
{
if (osLastFieldName.empty())
osLastFieldName = psColDef->field_name;
else if (strcmp(osLastFieldName, psColDef->field_name) != 0)
return NULL;
if (poSrcLayer->GetLayerDefn()->GetFieldIndex(psColDef->field_name) == -1)
return NULL;
}
if (!(psColDef->col_func == SWQCF_AVG ||
psColDef->col_func == SWQCF_MIN ||
psColDef->col_func == SWQCF_MAX ||
psColDef->col_func == SWQCF_COUNT ||
psColDef->col_func == SWQCF_SUM))
return NULL;
if (psColDef->distinct_flag) /* TODO: could perhaps be relaxed */
return NULL;
}
if (osLastFieldName.empty())
return NULL;
/* Normalize field name */
int nIndex = poSrcLayer->GetLayerDefn()->GetFieldIndex(osLastFieldName);
osLastFieldName = poSrcLayer->GetLayerDefn()->GetFieldDefn(nIndex)->GetNameRef();
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
if( sSelectInfo.parse( &sFieldList, NULL ) != CE_None )
{
return NULL;
}
if (sSelectInfo.join_defs != NULL ||
sSelectInfo.where_expr != NULL ||
sSelectInfo.order_defs != NULL ||
sSelectInfo.query_mode != SWQM_SUMMARY_RECORD)
{
return NULL;
}
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_index == -1)
{
if (psColDef->col_func == SWQCF_COUNT)
continue;
return NULL;
}
if (psColDef->field_type != SWQ_INTEGER &&
psColDef->field_type != SWQ_FLOAT)
{
return NULL;
}
}
const bool bFoundFilter = CPL_TO_BOOL(
poSrcLayer->HasFilterOnFieldOrCreateIfNecessary(osLastFieldName));
if( !bFoundFilter )
return NULL;
CPLString osURI = "/";
osURI += poSrcLayer->GetName();
osURI += "/_design/ogr_filter_";
osURI += osLastFieldName;
osURI += "/_view/filter?reduce=true";
json_object* poAnswerObj = GET(osURI);
json_object* poRows = NULL;
if (!(poAnswerObj != NULL &&
json_object_is_type(poAnswerObj, json_type_object) &&
(poRows = CPL_json_object_object_get(poAnswerObj, "rows")) != NULL &&
json_object_is_type(poRows, json_type_array)))
{
json_object_put(poAnswerObj);
return NULL;
}
int nLength = json_object_array_length(poRows);
if (nLength != 1)
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poRow = json_object_array_get_idx(poRows, 0);
if (!(poRow && json_object_is_type(poRow, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poValue = CPL_json_object_object_get(poRow, "value");
if (!(poValue != NULL && json_object_is_type(poValue, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poSum = CPL_json_object_object_get(poValue, "sum");
json_object* poCount = CPL_json_object_object_get(poValue, "count");
json_object* poMin = CPL_json_object_object_get(poValue, "min");
json_object* poMax = CPL_json_object_object_get(poValue, "max");
if (poSum != NULL && (json_object_is_type(poSum, json_type_int) ||
json_object_is_type(poSum, json_type_double)) &&
poCount != NULL && (json_object_is_type(poCount, json_type_int) ||
json_object_is_type(poCount, json_type_double)) &&
poMin != NULL && (json_object_is_type(poMin, json_type_int) ||
json_object_is_type(poMin, json_type_double)) &&
poMax != NULL && (json_object_is_type(poMax, json_type_int) ||
json_object_is_type(poMax, json_type_double)) )
{
double dfSum = json_object_get_double(poSum);
int nCount = json_object_get_int(poCount);
double dfMin = json_object_get_double(poMin);
double dfMax = json_object_get_double(poMax);
json_object_put(poAnswerObj);
//CPLDebug("CouchDB", "sum=%f, count=%d, min=%f, max=%f",
// dfSum, nCount, dfMin, dfMax);
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(poSrcLayer->GetName());
poFeatureDefn->Reference();
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
OGRFieldDefn oFDefn( "", OFTInteger );
if( psColDef->field_alias != NULL )
{
oFDefn.SetName(psColDef->field_alias);
}
else
{
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) psColDef->col_func );
oFDefn.SetName( CPLSPrintf( "%s_%s",
op->pszName,
psColDef->field_name ) );
}
if( psColDef->col_func == SWQCF_COUNT )
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_INTEGER)
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_FLOAT)
oFDefn.SetType( OFTReal );
poFeatureDefn->AddFieldDefn(&oFDefn);
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
switch(psColDef->col_func)
{
case SWQCF_AVG:
if (nCount)
poFeature->SetField(iField, dfSum / nCount);
break;
case SWQCF_MIN:
poFeature->SetField(iField, dfMin);
break;
case SWQCF_MAX:
poFeature->SetField(iField, dfMax);
break;
case SWQCF_COUNT:
poFeature->SetField(iField, nCount);
break;
case SWQCF_SUM:
poFeature->SetField(iField, dfSum);
break;
default:
break;
}
}
poFeature->SetFID(0);
OGRCouchDBOneLineLayer* poAnswerLayer = new OGRCouchDBOneLineLayer();
poAnswerLayer->poFeatureDefn = poFeatureDefn;
poAnswerLayer->poFeature = poFeature;
return poAnswerLayer;
}
json_object_put(poAnswerObj);
return NULL;
}
OGRFeature *OGRSUALayer::GetNextRawFeature()
{
if( bEOF )
return nullptr;
CPLString osTYPE;
CPLString osCLASS;
CPLString osTITLE;
CPLString osTOPS;
CPLString osBASE;
OGRLinearRing oLR;
double dfLastLat = 0.0;
double dfLastLon = 0.0;
bool bFirst = true;
while( true )
{
const char* pszLine = nullptr;
if( bFirst && bHasLastLine )
{
pszLine = osLastLine.c_str();
bFirst = false;
}
else
{
pszLine = CPLReadLine2L(fpSUA, 1024, nullptr);
if (pszLine == nullptr)
{
bEOF = true;
if (oLR.getNumPoints() == 0)
return nullptr;
break;
}
osLastLine = pszLine;
bHasLastLine = true;
}
if (pszLine[0] == '#' || pszLine[0] == '\0')
continue;
if (STARTS_WITH_CI(pszLine, "TYPE="))
{
if (!osTYPE.empty())
break;
osTYPE = pszLine + 5;
}
else if (STARTS_WITH_CI(pszLine, "CLASS="))
{
if (!osCLASS.empty())
break;
osCLASS = pszLine + 6;
}
else if (STARTS_WITH_CI(pszLine, "TITLE="))
{
if (!osTITLE.empty())
break;
osTITLE = pszLine + 6;
}
else if (STARTS_WITH_CI(pszLine, "TOPS="))
osTOPS = pszLine + 5;
else if (STARTS_WITH_CI(pszLine, "BASE="))
osBASE = pszLine + 5;
else if (STARTS_WITH_CI(pszLine, "POINT="))
{
pszLine += 6;
if (strlen(pszLine) != 16)
continue;
double dfLat = 0.0;
double dfLon = 0.0;
if (!GetLatLon(pszLine, dfLat, dfLon))
continue;
oLR.addPoint(dfLon, dfLat);
dfLastLat = dfLat;
dfLastLon = dfLon;
}
else if (STARTS_WITH_CI(pszLine, "CLOCKWISE") || STARTS_WITH_CI(pszLine, "ANTI-CLOCKWISE"))
{
if (oLR.getNumPoints() == 0)
continue;
int bClockWise = STARTS_WITH_CI(pszLine, "CLOCKWISE");
/*const char* pszRADIUS = strstr(pszLine, "RADIUS=");
if (pszRADIUS == NULL)
continue;
double dfRADIUS = CPLAtof(pszRADIUS + 7) * 1852;*/
const char* pszCENTRE = strstr(pszLine, "CENTRE=");
if (pszCENTRE == nullptr)
continue;
pszCENTRE += 7;
if (strlen(pszCENTRE) < 17 || pszCENTRE[16] != ' ')
continue;
double dfCenterLat = 0.0;
double dfCenterLon = 0.0;
if (!GetLatLon(pszCENTRE, dfCenterLat, dfCenterLon))
continue;
const char* pszTO = strstr(pszLine, "TO=");
if (pszTO == nullptr)
continue;
pszTO += 3;
if (strlen(pszTO) != 16)
continue;
double dfToLat = 0.0;
double dfToLon = 0.0;
if (!GetLatLon(pszTO, dfToLat, dfToLon))
continue;
const double dfStartDistance =
OGR_GreatCircle_Distance(dfCenterLat, dfCenterLon, dfLastLat, dfLastLon);
const double dfEndDistance =
OGR_GreatCircle_Distance(dfCenterLat, dfCenterLon, dfToLat, dfToLon);
const double dfStartAngle =
OGR_GreatCircle_InitialHeading(dfCenterLat, dfCenterLon, dfLastLat, dfLastLon);
double dfEndAngle =
OGR_GreatCircle_InitialHeading(dfCenterLat, dfCenterLon, dfToLat, dfToLon);
if( bClockWise && dfEndAngle < dfStartAngle )
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
int nSign = (bClockWise) ? 1 : -1;
for( double dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign )
{
const double pct = (dfAngle - dfStartAngle) / (dfEndAngle - dfStartAngle);
const double dfDist = dfStartDistance * (1-pct) + dfEndDistance * pct;
double dfLat = 0.0;
double dfLon = 0.0;
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
oLR.addPoint(dfToLon, dfToLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
else if (STARTS_WITH_CI(pszLine, "CIRCLE"))
{
const char* pszRADIUS = strstr(pszLine, "RADIUS=");
if (pszRADIUS == nullptr)
continue;
double dfRADIUS = CPLAtof(pszRADIUS + 7) * 1852;
const char* pszCENTRE = strstr(pszLine, "CENTRE=");
if (pszCENTRE == nullptr)
continue;
pszCENTRE += 7;
if (strlen(pszCENTRE) != 16)
continue;
double dfCenterLat = 0.0;
double dfCenterLon = 0.0;
if (!GetLatLon(pszCENTRE, dfCenterLat, dfCenterLon))
continue;
double dfLat = 0.0;
double dfLon = 0.0;
for( double dfAngle = 0; dfAngle < 360; dfAngle += 1 )
{
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, 0, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
else if (STARTS_WITH_CI(pszLine, "INCLUDE") || STARTS_WITH_CI(pszLine, "END"))
{
}
else
{
CPLDebug("SUA", "Unexpected content : %s", pszLine);
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetField(0, osTYPE.c_str());
poFeature->SetField(1, osCLASS.c_str());
poFeature->SetField(2, osTITLE.c_str());
poFeature->SetField(3, osTOPS.c_str());
poFeature->SetField(4, osBASE.c_str());
OGRPolygon* poPoly = new OGRPolygon();
poPoly->assignSpatialReference(poSRS);
oLR.closeRings();
poPoly->addRing(&oLR);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
OGRLayer *OGRCouchDBDataSource::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszNameIn );
break;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszNameIn );
return NULL;
}
}
}
char* pszEscapedName = CPLEscapeString(pszNameIn, -1, CPLES_URL);
CPLString osEscapedName = pszEscapedName;
CPLFree(pszEscapedName);
/* -------------------------------------------------------------------- */
/* Create "database" */
/* -------------------------------------------------------------------- */
CPLString osURI;
osURI = "/";
osURI += osEscapedName;
json_object* poAnswerObj = PUT(osURI, NULL);
if (poAnswerObj == NULL)
return NULL;
if( !IsOK(poAnswerObj, "Layer creation failed") )
{
json_object_put(poAnswerObj);
return NULL;
}
json_object_put(poAnswerObj);
/* -------------------------------------------------------------------- */
/* Create "spatial index" */
/* -------------------------------------------------------------------- */
int nUpdateSeq = 0;
if (eGType != wkbNone)
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_spatial";
CPLString osContent("{ \"spatial\": { \"spatial\" : \"function(doc) { if (doc.geometry && doc.geometry.coordinates && doc.geometry.coordinates.length != 0) { emit(doc.geometry, null); } } \" } }");
poAnswerObj = PUT(osURI, osContent);
if( IsOK(poAnswerObj, "Spatial index creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
/* -------------------------------------------------------------------- */
/* Create validation function */
/* -------------------------------------------------------------------- */
const char* pszUpdatePermissions = CSLFetchNameValueDef(papszOptions, "UPDATE_PERMISSIONS", "LOGGED_USER");
CPLString osValidation;
if (EQUAL(pszUpdatePermissions, "LOGGED_USER"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { if(!userCtx.name) { throw({forbidden: \\\"Please log in first.\\\"}); } }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ALL"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ADMIN"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) {if (userCtx.roles.indexOf('_admin') === -1) { throw({forbidden: \\\"No changes allowed except by admin.\\\"}); } }\" }";
}
else if (STARTS_WITH(pszUpdatePermissions, "function("))
{
osValidation = "{\"validate_doc_update\": \"";
osValidation += pszUpdatePermissions;
osValidation += "\"}";
}
if (!osValidation.empty() )
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_validation";
poAnswerObj = PUT(osURI, osValidation);
if( IsOK(poAnswerObj, "Validation function creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
const bool bGeoJSONDocument =
CPLTestBool(CSLFetchNameValueDef(papszOptions, "GEOJSON", "TRUE"));
int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));
OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, pszNameIn);
if (nCoordPrecision != -1)
poLayer->SetCoordinatePrecision(nCoordPrecision);
poLayer->SetInfoAfterCreation(eGType, poSpatialRef,
nUpdateSeq, bGeoJSONDocument);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
int main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
CPLErr GDALWMSDataset::Initialize(CPLXMLNode *config) {
CPLErr ret = CE_None;
char* pszXML = CPLSerializeXMLTree( config );
if (pszXML)
{
m_osXML = pszXML;
CPLFree(pszXML);
}
// Initialize the minidriver, which can set parameters for the dataset using member functions
CPLXMLNode *service_node = CPLGetXMLNode(config, "Service");
if (service_node != NULL)
{
const CPLString service_name = CPLGetXMLValue(service_node, "name", "");
if (!service_name.empty())
{
GDALWMSMiniDriverManager *const mdm = GetGDALWMSMiniDriverManager();
GDALWMSMiniDriverFactory *const mdf = mdm->Find(service_name);
if (mdf != NULL)
{
m_mini_driver = mdf->New();
m_mini_driver->m_parent_dataset = this;
if (m_mini_driver->Initialize(service_node) == CE_None)
{
m_mini_driver_caps.m_capabilities_version = -1;
m_mini_driver->GetCapabilities(&m_mini_driver_caps);
if (m_mini_driver_caps.m_capabilities_version == -1)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Internal error, mini-driver capabilities version not set.");
ret = CE_Failure;
}
}
else
{
delete m_mini_driver;
m_mini_driver = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize minidriver.");
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: No mini-driver registered for '%s'.", service_name.c_str());
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
/*
Parameters that could be set by minidriver already, based on server side information.
If the size is set, minidriver has done this already
A "server" side minidriver needs to set at least:
- Blocksize (x and y)
- Clamp flag (defaults to true)
- DataWindow
- Band Count
- Data Type
It should also initialize and register the bands and overviews.
*/
if (m_data_window.m_sx<1)
{
int nOverviews = 0;
if (ret == CE_None)
{
m_block_size_x = atoi(CPLGetXMLValue(config, "BlockSizeX", CPLString().Printf("%d", m_default_block_size_x)));
m_block_size_y = atoi(CPLGetXMLValue(config, "BlockSizeY", CPLString().Printf("%d", m_default_block_size_y)));
if (m_block_size_x <= 0 || m_block_size_y <= 0)
{
CPLError( CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value in BlockSizeX or BlockSizeY" );
ret = CE_Failure;
}
}
if (ret == CE_None)
{
m_clamp_requests = StrToBool(CPLGetXMLValue(config, "ClampRequests", "true"));
if (m_clamp_requests<0)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ClampRequests, true/false expected.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
CPLXMLNode *data_window_node = CPLGetXMLNode(config, "DataWindow");
if (data_window_node == NULL && m_bNeedsDataWindow)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow missing.");
ret = CE_Failure;
}
else
{
CPLString osDefaultX0, osDefaultX1, osDefaultY0, osDefaultY1;
CPLString osDefaultTileCountX, osDefaultTileCountY, osDefaultTileLevel;
CPLString osDefaultOverviewCount;
osDefaultX0.Printf("%.8f", m_default_data_window.m_x0);
osDefaultX1.Printf("%.8f", m_default_data_window.m_x1);
osDefaultY0.Printf("%.8f", m_default_data_window.m_y0);
osDefaultY1.Printf("%.8f", m_default_data_window.m_y1);
osDefaultTileCountX.Printf("%d", m_default_tile_count_x);
osDefaultTileCountY.Printf("%d", m_default_tile_count_y);
if (m_default_data_window.m_tlevel >= 0)
osDefaultTileLevel.Printf("%d", m_default_data_window.m_tlevel);
if (m_default_overview_count >= 0)
osDefaultOverviewCount.Printf("%d", m_default_overview_count);
const char *overview_count = CPLGetXMLValue(config, "OverviewCount", osDefaultOverviewCount);
const char *ulx = CPLGetXMLValue(data_window_node, "UpperLeftX", osDefaultX0);
const char *uly = CPLGetXMLValue(data_window_node, "UpperLeftY", osDefaultY0);
const char *lrx = CPLGetXMLValue(data_window_node, "LowerRightX", osDefaultX1);
const char *lry = CPLGetXMLValue(data_window_node, "LowerRightY", osDefaultY1);
const char *sx = CPLGetXMLValue(data_window_node, "SizeX", "");
const char *sy = CPLGetXMLValue(data_window_node, "SizeY", "");
const char *tx = CPLGetXMLValue(data_window_node, "TileX", "0");
const char *ty = CPLGetXMLValue(data_window_node, "TileY", "0");
const char *tlevel = CPLGetXMLValue(data_window_node, "TileLevel", osDefaultTileLevel);
const char *str_tile_count_x = CPLGetXMLValue(data_window_node, "TileCountX", osDefaultTileCountX);
const char *str_tile_count_y = CPLGetXMLValue(data_window_node, "TileCountY", osDefaultTileCountY);
const char *y_origin = CPLGetXMLValue(data_window_node, "YOrigin", "default");
if (ret == CE_None)
{
if ((ulx[0] != '\0') && (uly[0] != '\0') && (lrx[0] != '\0') && (lry[0] != '\0'))
{
m_data_window.m_x0 = CPLAtof(ulx);
m_data_window.m_y0 = CPLAtof(uly);
m_data_window.m_x1 = CPLAtof(lrx);
m_data_window.m_y1 = CPLAtof(lry);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: UpperLeftX, UpperLeftY, LowerRightX, LowerRightY.");
ret = CE_Failure;
}
}
m_data_window.m_tlevel = atoi(tlevel);
if (ret == CE_None)
{
if ((sx[0] != '\0') && (sy[0] != '\0'))
{
m_data_window.m_sx = atoi(sx);
m_data_window.m_sy = atoi(sy);
}
else if ((tlevel[0] != '\0') && (str_tile_count_x[0] != '\0') && (str_tile_count_y[0] != '\0'))
{
int tile_count_x = atoi(str_tile_count_x);
int tile_count_y = atoi(str_tile_count_y);
m_data_window.m_sx = tile_count_x * m_block_size_x * (1 << m_data_window.m_tlevel);
m_data_window.m_sy = tile_count_y * m_block_size_y * (1 << m_data_window.m_tlevel);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: SizeX, SizeY.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
if ((tx[0] != '\0') && (ty[0] != '\0'))
{
m_data_window.m_tx = atoi(tx);
m_data_window.m_ty = atoi(ty);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: TileX, TileY.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
if (overview_count[0] != '\0')
{
nOverviews = atoi(overview_count);
}
else if (tlevel[0] != '\0')
{
nOverviews = m_data_window.m_tlevel;
}
else
{
const int min_overview_size = MAX(32, MIN(m_block_size_x, m_block_size_y));
double a = log(static_cast<double>(MIN(m_data_window.m_sx, m_data_window.m_sy))) / log(2.0)
- log(static_cast<double>(min_overview_size)) / log(2.0);
nOverviews = MAX(0, MIN(static_cast<int>(ceil(a)), 32));
}
}
if (ret == CE_None)
{
CPLString y_origin_str = y_origin;
if (y_origin_str == "top") {
m_data_window.m_y_origin = GDALWMSDataWindow::TOP;
} else if (y_origin_str == "bottom") {
m_data_window.m_y_origin = GDALWMSDataWindow::BOTTOM;
} else if (y_origin_str == "default") {
m_data_window.m_y_origin = GDALWMSDataWindow::DEFAULT;
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow YOrigin must be set to "
"one of 'default', 'top', or 'bottom', not '%s'.", y_origin_str.c_str());
ret = CE_Failure;
}
}
}
}
if (ret == CE_None)
{
if (nBands<1)
nBands=atoi(CPLGetXMLValue(config,"BandsCount","3"));
if (nBands<1)
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Bad number of bands.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
const char *data_type = CPLGetXMLValue(config, "DataType", "Byte");
m_data_type = GDALGetDataTypeByName( data_type );
if ( m_data_type == GDT_Unknown || m_data_type >= GDT_TypeCount )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALWMS: Invalid value in DataType. Data type \"%s\" is not supported.", data_type );
ret = CE_Failure;
}
}
// Initialize the bands and the overviews. Assumes overviews are powers of two
if (ret == CE_None)
{
nRasterXSize = m_data_window.m_sx;
nRasterYSize = m_data_window.m_sy;
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize) ||
!GDALCheckBandCount(nBands, TRUE))
{
return CE_Failure;
}
GDALColorInterp default_color_interp[4][4] = {
{ GCI_GrayIndex, GCI_Undefined, GCI_Undefined, GCI_Undefined },
{ GCI_GrayIndex, GCI_AlphaBand, GCI_Undefined, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand }
};
for (int i = 0; i < nBands; ++i)
{
GDALColorInterp color_interp = (nBands <= 4 && i <= 3 ? default_color_interp[nBands - 1][i] : GCI_Undefined);
GDALWMSRasterBand *band = new GDALWMSRasterBand(this, i, 1.0);
band->m_color_interp = color_interp;
SetBand(i + 1, band);
double scale = 0.5;
for (int j = 0; j < nOverviews; ++j)
{
band->AddOverview(scale);
band->m_color_interp = color_interp;
scale *= 0.5;
}
}
}
}
// UserPwd
const char *pszUserPwd = CPLGetXMLValue(config, "UserPwd", "");
if (pszUserPwd[0] != '\0')
m_osUserPwd = pszUserPwd;
const char *pszUserAgent = CPLGetXMLValue(config, "UserAgent", "");
if (pszUserAgent[0] != '\0')
m_osUserAgent = pszUserAgent;
const char *pszReferer = CPLGetXMLValue(config, "Referer", "");
if (pszReferer[0] != '\0')
m_osReferer = pszReferer;
if (ret == CE_None) {
const char *pszHttpZeroBlockCodes = CPLGetXMLValue(config, "ZeroBlockHttpCodes", "");
if(pszHttpZeroBlockCodes[0] == '\0') {
m_http_zeroblock_codes.push_back(204);
} else {
char **kv = CSLTokenizeString2(pszHttpZeroBlockCodes,",",CSLT_HONOURSTRINGS);
int nCount = CSLCount(kv);
for(int i=0; i<nCount; i++) {
int code = atoi(kv[i]);
if(code <= 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockHttpCodes \"%s\", comma separated HTTP response codes expected.",
kv[i]);
ret = CE_Failure;
break;
}
m_http_zeroblock_codes.push_back(code);
}
CSLDestroy(kv);
}
}
if (ret == CE_None) {
const char *pszZeroExceptions = CPLGetXMLValue(config, "ZeroBlockOnServerException", "");
if(pszZeroExceptions[0] != '\0') {
m_zeroblock_on_serverexceptions = StrToBool(pszZeroExceptions);
if (m_zeroblock_on_serverexceptions == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockOnServerException \"%s\", true/false expected.",
pszZeroExceptions);
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const char *max_conn = CPLGetXMLValue(config, "MaxConnections", "");
if (max_conn[0] != '\0') {
m_http_max_conn = atoi(max_conn);
} else {
m_http_max_conn = 2;
}
}
if (ret == CE_None) {
const char *timeout = CPLGetXMLValue(config, "Timeout", "");
if (timeout[0] != '\0') {
m_http_timeout = atoi(timeout);
} else {
m_http_timeout = 300;
}
}
if (ret == CE_None) {
const char *offline_mode = CPLGetXMLValue(config, "OfflineMode", "");
if (offline_mode[0] != '\0') {
const int offline_mode_bool = StrToBool(offline_mode);
if (offline_mode_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of OfflineMode, true / false expected.");
ret = CE_Failure;
} else {
m_offline_mode = offline_mode_bool;
}
} else {
m_offline_mode = 0;
}
}
if (ret == CE_None) {
const char *advise_read = CPLGetXMLValue(config, "AdviseRead", "");
if (advise_read[0] != '\0') {
const int advise_read_bool = StrToBool(advise_read);
if (advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of AdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_use_advise_read = advise_read_bool;
}
} else {
m_use_advise_read = 0;
}
}
if (ret == CE_None) {
const char *verify_advise_read = CPLGetXMLValue(config, "VerifyAdviseRead", "");
if (m_use_advise_read) {
if (verify_advise_read[0] != '\0') {
const int verify_advise_read_bool = StrToBool(verify_advise_read);
if (verify_advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of VerifyAdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_verify_advise_read = verify_advise_read_bool;
}
} else {
m_verify_advise_read = 1;
}
}
}
// Let the local configuration override the minidriver supplied projection
if (ret == CE_None) {
const char *proj = CPLGetXMLValue(config, "Projection", "");
if (proj[0] != '\0') {
m_projection = ProjToWKT(proj);
if (m_projection.size() == 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad projection specified.");
ret = CE_Failure;
}
}
}
// Same for Min, Max and NoData, defined per band or per dataset
// If they are set as null strings, they clear the server declared values
if (ret == CE_None) {
// Data values are attributes, they include NoData Min and Max
// TODO: document those options
if (0!=CPLGetXMLNode(config,"DataValues")) {
const char *nodata=CPLGetXMLValue(config,"DataValues.NoData",NULL);
if (nodata!=NULL) WMSSetNoDataValue(nodata);
const char *min=CPLGetXMLValue(config,"DataValues.min",NULL);
if (min!=NULL) WMSSetMinValue(min);
const char *max=CPLGetXMLValue(config,"DataValues.max",NULL);
if (max!=NULL) WMSSetMaxValue(max);
}
}
if (ret == CE_None) {
CPLXMLNode *cache_node = CPLGetXMLNode(config, "Cache");
if (cache_node != NULL) {
m_cache = new GDALWMSCache();
if (m_cache->Initialize(cache_node) != CE_None) {
delete m_cache;
m_cache = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize cache.");
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const int v = StrToBool(CPLGetXMLValue(config, "UnsafeSSL", "false"));
if (v == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of UnsafeSSL: true or false expected.");
ret = CE_Failure;
} else {
m_unsafeSsl = v;
}
}
if (ret == CE_None) {
/* If we dont have projection already set ask mini-driver. */
if (!m_projection.size()) {
const char *proj = m_mini_driver->GetProjectionInWKT();
if (proj != NULL) {
m_projection = proj;
}
}
}
return ret;
}
bool VSIDIRAz::IssueListDir()
{
WriteFuncStruct sWriteFuncData;
const CPLString l_osNextMarker(osNextMarker);
clear();
CPLString osMaxKeys = CPLGetConfigOption("AZURE_MAX_RESULTS", "");
const int AZURE_SERVER_LIMIT_SINGLE_REQUEST = 5000;
if( nMaxFiles > 0 && nMaxFiles < AZURE_SERVER_LIMIT_SINGLE_REQUEST &&
(osMaxKeys.empty() || nMaxFiles < atoi(osMaxKeys)) )
{
osMaxKeys.Printf("%d", nMaxFiles);
}
poHandleHelper->ResetQueryParameters();
CPLString osBaseURL(poHandleHelper->GetURL());
CURLM* hCurlMultiHandle = poFS->GetCurlMultiHandleFor(osBaseURL);
CURL* hCurlHandle = curl_easy_init();
poHandleHelper->AddQueryParameter("comp", "list");
if( !l_osNextMarker.empty() )
poHandleHelper->AddQueryParameter("marker", l_osNextMarker);
if( !osMaxKeys.empty() )
poHandleHelper->AddQueryParameter("maxresults", osMaxKeys);
if( !osBucket.empty() )
{
poHandleHelper->AddQueryParameter("restype", "container");
if( nRecurseDepth == 0 )
poHandleHelper->AddQueryParameter("delimiter", "/");
if( !osObjectKey.empty() )
poHandleHelper->AddQueryParameter("prefix", osObjectKey + "/");
}
struct curl_slist* headers =
VSICurlSetOptions(hCurlHandle, poHandleHelper->GetURL(), nullptr);
curl_easy_setopt(hCurlHandle, CURLOPT_RANGE, nullptr);
VSICURLInitWriteFuncStruct(&sWriteFuncData, nullptr, nullptr, nullptr);
curl_easy_setopt(hCurlHandle, CURLOPT_WRITEDATA, &sWriteFuncData);
curl_easy_setopt(hCurlHandle, CURLOPT_WRITEFUNCTION,
VSICurlHandleWriteFunc);
char szCurlErrBuf[CURL_ERROR_SIZE+1] = {};
curl_easy_setopt(hCurlHandle, CURLOPT_ERRORBUFFER, szCurlErrBuf );
headers = VSICurlMergeHeaders(headers,
poHandleHelper->GetCurlHeaders("GET", headers));
curl_easy_setopt(hCurlHandle, CURLOPT_HTTPHEADER, headers);
MultiPerform(hCurlMultiHandle, hCurlHandle);
if( headers != nullptr )
curl_slist_free_all(headers);
if( sWriteFuncData.pBuffer == nullptr)
{
curl_easy_cleanup(hCurlHandle);
return false;
}
long response_code = 0;
curl_easy_getinfo(hCurlHandle, CURLINFO_HTTP_CODE, &response_code);
if( response_code != 200 )
{
CPLDebug("AZURE", "%s",
sWriteFuncData.pBuffer
? sWriteFuncData.pBuffer : "(null)");
CPLFree(sWriteFuncData.pBuffer);
curl_easy_cleanup(hCurlHandle);
return false;
}
else
{
bool ret = AnalyseAzureFileList( osBaseURL,
sWriteFuncData.pBuffer );
CPLFree(sWriteFuncData.pBuffer);
curl_easy_cleanup(hCurlHandle);
return ret;
}
}
bool VSIDIRAz::AnalyseAzureFileList(
const CPLString& osBaseURL,
const char* pszXML)
{
#if DEBUG_VERBOSE
CPLDebug("AZURE", "%s", pszXML);
#endif
CPLXMLNode* psTree = CPLParseXMLString(pszXML);
if( psTree == nullptr )
return false;
CPLXMLNode* psEnumerationResults = CPLGetXMLNode(psTree, "=EnumerationResults");
bool bNonEmpty = false;
if( psEnumerationResults )
{
CPLString osPrefix = CPLGetXMLValue(psEnumerationResults, "Prefix", "");
CPLXMLNode* psBlobs = CPLGetXMLNode(psEnumerationResults, "Blobs");
if( psBlobs == nullptr )
{
psBlobs = CPLGetXMLNode(psEnumerationResults, "Containers");
if( psBlobs != nullptr )
bNonEmpty = true;
}
// Count the number of occurrences of a path. Can be 1 or 2. 2 in the case
// that both a filename and directory exist
std::map<CPLString, int> aoNameCount;
for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;
psIter != nullptr; psIter = psIter->psNext )
{
if( psIter->eType != CXT_Element )
continue;
if( strcmp(psIter->pszValue, "Blob") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )
{
bNonEmpty = true;
}
else if( pszKey && strlen(pszKey) > osPrefix.size() )
{
bNonEmpty = true;
aoNameCount[pszKey + osPrefix.size()] ++;
}
}
else if( strcmp(psIter->pszValue, "BlobPrefix") == 0 ||
strcmp(psIter->pszValue, "Container") == 0 )
{
bNonEmpty = true;
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strncmp(pszKey, osPrefix, osPrefix.size()) == 0 )
{
CPLString osKey = pszKey;
if( !osKey.empty() && osKey.back() == '/' )
osKey.resize(osKey.size()-1);
if( osKey.size() > osPrefix.size() )
{
aoNameCount[osKey.c_str() + osPrefix.size()] ++;
}
}
}
}
for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;
psIter != nullptr; psIter = psIter->psNext )
{
if( psIter->eType != CXT_Element )
continue;
if( strcmp(psIter->pszValue, "Blob") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )
{
if( nRecurseDepth < 0 )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(pszKey + osPrefix.size());
char* pszMarker = strstr(entry->pszName, GDAL_MARKER_FOR_DIR);
if( pszMarker )
*pszMarker = '\0';
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
}
}
else if( pszKey && strlen(pszKey) > osPrefix.size() )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(pszKey + osPrefix.size());
entry->nSize = static_cast<GUIntBig>(
CPLAtoGIntBig(CPLGetXMLValue(psIter, "Properties.Content-Length", "0")));
entry->bSizeKnown = true;
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
CPLString ETag = CPLGetXMLValue(psIter, "Etag", "");
if( !ETag.empty() )
{
entry->papszExtra = CSLSetNameValue(
entry->papszExtra, "ETag", ETag.c_str());
}
int nYear, nMonth, nDay, nHour, nMinute, nSecond;
if( CPLParseRFC822DateTime(
CPLGetXMLValue(psIter, "Properties.Last-Modified", ""),
&nYear,
&nMonth,
&nDay,
&nHour,
&nMinute,
&nSecond,
nullptr,
nullptr ) )
{
struct tm brokendowntime;
brokendowntime.tm_year = nYear - 1900;
brokendowntime.tm_mon = nMonth - 1;
brokendowntime.tm_mday = nDay;
brokendowntime.tm_hour = nHour;
brokendowntime.tm_min = nMinute;
brokendowntime.tm_sec = nSecond < 0 ? 0 : nSecond;
entry->nMTime =
CPLYMDHMSToUnixTime(&brokendowntime);
entry->bMTimeKnown = true;
}
if( bCacheResults )
{
FileProp prop;
prop.eExists = EXIST_YES;
prop.bHasComputedFileSize = true;
prop.fileSize = entry->nSize;
prop.bIsDirectory = false;
prop.mTime = static_cast<time_t>(entry->nMTime);
prop.ETag = ETag;
CPLString osCachedFilename =
osBaseURL + "/" + osPrefix + entry->pszName;
#if DEBUG_VERBOSE
CPLDebug("AZURE", "Cache %s", osCachedFilename.c_str());
#endif
poFS->SetCachedFileProp(osCachedFilename, prop);
}
}
}
else if( strcmp(psIter->pszValue, "BlobPrefix") == 0 ||
strcmp(psIter->pszValue, "Container") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strncmp(pszKey, osPrefix, osPrefix.size()) == 0 )
{
CPLString osKey = pszKey;
if( !osKey.empty() && osKey.back() == '/' )
osKey.resize(osKey.size()-1);
if( osKey.size() > osPrefix.size() )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(osKey.c_str() + osPrefix.size());
if( aoNameCount[entry->pszName] == 2 )
{
// Add a / suffix to disambiguish the situation
// Normally we don't suffix directories with /, but
// we have no alternative here
CPLString osTemp(entry->pszName);
osTemp += '/';
CPLFree(entry->pszName);
entry->pszName = CPLStrdup(osTemp);
}
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
if( bCacheResults )
{
FileProp prop;
prop.eExists = EXIST_YES;
prop.bIsDirectory = true;
prop.bHasComputedFileSize = true;
prop.fileSize = 0;
prop.mTime = 0;
CPLString osCachedFilename =
osBaseURL + "/" + osPrefix + entry->pszName;
#if DEBUG_VERBOSE
CPLDebug("AZURE", "Cache %s", osCachedFilename.c_str());
#endif
poFS->SetCachedFileProp(osCachedFilename, prop);
}
}
}
}
if( nMaxFiles > 0 && aoEntries.size() > static_cast<unsigned>(nMaxFiles) )
break;
}
osNextMarker = CPLGetXMLValue(psEnumerationResults, "NextMarker", "");
}
CPLDestroyXMLNode(psTree);
return bNonEmpty;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjectId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjectId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing project id");
return FALSE;
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
if (osAPIKey.empty())
{
osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY");
}
if (osAPIKey.empty())
{
CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n");
return FALSE;
}
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.empty() )
return FALSE;
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
if (!osDatasets.empty())
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
// If OVERWRITE: YES, truncate the layer.
if( nLayers==1 &&
CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) )
{
TruncateDataset(papoLayers[0]->GetTableName());
}
return TRUE;
} else {
// If 'datasets' word is in the filename, but no dataset id specified,
// print the list of available datasets
if(std::string(pszFilename).find("datasets") != std::string::npos)
ListDatasets();
}
return TRUE;
}
int OGRGFTDataSource::Open( const char * pszFilename, int bUpdateIn)
{
bReadWrite = bUpdateIn;
pszName = CPLStrdup( pszFilename );
osAuth = OGRGFTGetOptionValue(pszFilename, "auth");
if (osAuth.empty())
osAuth = CPLGetConfigOption("GFT_AUTH", "");
osRefreshToken = OGRGFTGetOptionValue(pszFilename, "refresh");
if (osRefreshToken.empty())
osRefreshToken = CPLGetConfigOption("GFT_REFRESH_TOKEN", "");
osAPIKey = CPLGetConfigOption("GFT_APIKEY", GDAL_API_KEY);
CPLString osTables = OGRGFTGetOptionValue(pszFilename, "tables");
bUseHTTPS = TRUE;
osAccessToken = OGRGFTGetOptionValue(pszFilename, "access");
if (osAccessToken.empty())
osAccessToken = CPLGetConfigOption("GFT_ACCESS_TOKEN","");
if (osAccessToken.empty() && !osRefreshToken.empty())
{
osAccessToken.Seize(GOA2GetAccessToken(osRefreshToken,
FUSION_TABLE_SCOPE));
if (osAccessToken.empty())
return FALSE;
}
/* coverity[copy_paste_error] */
if (osAccessToken.empty() && !osAuth.empty())
{
osRefreshToken.Seize(GOA2GetRefreshToken(osAuth, FUSION_TABLE_SCOPE));
if (osRefreshToken.empty())
return FALSE;
}
if (osAccessToken.empty())
{
if (osTables.empty())
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unauthenticated access requires explicit tables= parameter");
return FALSE;
}
}
if (!osTables.empty())
{
char** papszTables = CSLTokenizeString2(osTables, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = new OGRGFTTableLayer(this, papszTables[i], papszTables[i]);
}
CSLDestroy(papszTables);
return TRUE;
}
/* Get list of tables */
CPLHTTPResult * psResult = RunSQL("SHOW TABLES");
if (psResult == nullptr)
return FALSE;
char* pszLine = (char*) psResult->pabyData;
if (pszLine == nullptr ||
psResult->pszErrBuf != nullptr ||
!STARTS_WITH(pszLine, "table id,name"))
{
CPLHTTPDestroyResult(psResult);
return FALSE;
}
pszLine = OGRGFTGotoNextLine(pszLine);
while(pszLine != nullptr && *pszLine != 0)
{
char* pszNextLine = OGRGFTGotoNextLine(pszLine);
if (pszNextLine)
pszNextLine[-1] = 0;
char** papszTokens = CSLTokenizeString2(pszLine, ",", 0);
if (CSLCount(papszTokens) == 2)
{
CPLString osTableId(papszTokens[0]);
CPLString osLayerName(papszTokens[1]);
for(int i=0;i<nLayers;i++)
{
if (strcmp(papoLayers[i]->GetName(), osLayerName) == 0)
{
osLayerName += " (";
osLayerName += osTableId;
osLayerName += ")";
break;
}
}
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = new OGRGFTTableLayer(this, osLayerName, osTableId);
}
CSLDestroy(papszTokens);
pszLine = pszNextLine;
}
CPLHTTPDestroyResult(psResult);
return TRUE;
}
void OGRDWGLayer::TranslateGenericProperties( OGRFeature *poFeature,
OdDbEntityPtr poEntity )
{
poFeature->SetField( "Layer", TextUnescape(poEntity->layer()) );
poFeature->SetField( "Linetype", TextUnescape(poEntity->layer()) );
CPLString osValue;
osValue.Printf( "%d", (int) poEntity->lineWeight() );
oStyleProperties["LineWeight"] = osValue;
OdDbHandle oHandle = poEntity->getDbHandle();
poFeature->SetField( "EntityHandle", (const char *) oHandle.ascii() );
if( poEntity->colorIndex() != 256 )
{
osValue.Printf( "%d", poEntity->colorIndex() );
oStyleProperties["Color"] = osValue.c_str();
}
/* -------------------------------------------------------------------- */
/* Collect the subclasses. */
/* -------------------------------------------------------------------- */
CPLString osSubClasses;
OdRxClass *poClass = poEntity->isA();
while( poClass != NULL )
{
if( !osSubClasses.empty() )
osSubClasses = ":" + osSubClasses;
osSubClasses = ((const char *) poClass->name()) + osSubClasses;
if( EQUAL(poClass->name(),"AcDbEntity") )
break;
poClass = poClass->myParent();
}
poFeature->SetField( "SubClasses", osSubClasses.c_str() );
/* -------------------------------------------------------------------- */
/* Collect Xdata. */
/* -------------------------------------------------------------------- */
OdResBufPtr poResBufBase = poEntity->xData();
OdResBuf *poResBuf = poResBufBase;
CPLString osFullXData;
for ( ; poResBuf != NULL; poResBuf = poResBuf->next() )
{
CPLString osXDataItem;
switch (OdDxfCode::_getType(poResBuf->restype()))
{
case OdDxfCode::Name:
case OdDxfCode::String:
case OdDxfCode::LayerName:
osXDataItem = (const char *) poResBuf->getString();
break;
case OdDxfCode::Bool:
if( poResBuf->getBool() )
osXDataItem = "true";
else
osXDataItem = "false";
break;
case OdDxfCode::Integer8:
osXDataItem.Printf( "%d", (int) poResBuf->getInt8() );
break;
case OdDxfCode::Integer16:
osXDataItem.Printf( "%d", (int) poResBuf->getInt16() );
break;
case OdDxfCode::Integer32:
osXDataItem.Printf( "%d", (int) poResBuf->getInt32() );
break;
case OdDxfCode::Double:
case OdDxfCode::Angle:
osXDataItem.Printf( "%g", poResBuf->getDouble() );
break;
case OdDxfCode::Point:
{
OdGePoint3d oPoint = poResBuf->getPoint3d();
osXDataItem.Printf( "(%g,%g,%g)", oPoint.x, oPoint.y, oPoint.z );
}
break;
case OdDxfCode::BinaryChunk:
{
OdBinaryData oBinData = poResBuf->getBinaryChunk();
char *pszAsHex = CPLBinaryToHex( oBinData.size(),
(GByte*) oBinData.asArrayPtr() );
osXDataItem = pszAsHex;
CPLFree( pszAsHex );
}
break;
case OdDxfCode::ObjectId:
case OdDxfCode::SoftPointerId:
case OdDxfCode::HardPointerId:
case OdDxfCode::SoftOwnershipId:
case OdDxfCode::HardOwnershipId:
case OdDxfCode::Handle:
osXDataItem = (const char *) poResBuf->getHandle().ascii();
break;
default:
break;
}
if( !osFullXData.empty() )
osFullXData += " ";
osFullXData += (const char *) osXDataItem;
}
poFeature->SetField( "ExtendedEntity", osFullXData );
#ifdef notdef
// OCS vector.
case 210:
oStyleProperties["210_N.dX"] = pszValue;
break;
case 220:
oStyleProperties["220_N.dY"] = pszValue;
break;
case 230:
oStyleProperties["230_N.dZ"] = pszValue;
break;
default:
break;
}
GDALDataset *NDFDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* The user must select the header file (i.e. .H1). */
/* -------------------------------------------------------------------- */
if( !Identify(poOpenInfo) || poOpenInfo->fpL == nullptr )
return nullptr;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The NDF driver does not support update access to existing"
" datasets." );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Read and process the header into a local name/value */
/* stringlist. We just take off the trailing semicolon. The */
/* keyword is already separated from the value by an equal */
/* sign. */
/* -------------------------------------------------------------------- */
const char *pszLine = nullptr;
const int nHeaderMax = 1000;
int nHeaderLines = 0;
char **papszHeader = static_cast<char **>(
CPLMalloc( sizeof(char *) * (nHeaderMax+1) ) );
while( nHeaderLines < nHeaderMax
&& (pszLine = CPLReadLineL( poOpenInfo->fpL )) != nullptr
&& !EQUAL(pszLine,"END_OF_HDR;") )
{
if( strstr(pszLine,"=") == nullptr )
break;
char *pszFixed = CPLStrdup( pszLine );
if( pszFixed[strlen(pszFixed)-1] == ';' )
pszFixed[strlen(pszFixed)-1] = '\0';
papszHeader[nHeaderLines++] = pszFixed;
papszHeader[nHeaderLines] = nullptr;
}
CPL_IGNORE_RET_VAL(VSIFCloseL(poOpenInfo->fpL));
poOpenInfo->fpL = nullptr;
if( CSLFetchNameValue( papszHeader, "PIXELS_PER_LINE" ) == nullptr
|| CSLFetchNameValue( papszHeader, "LINES_PER_DATA_FILE" ) == nullptr
|| CSLFetchNameValue( papszHeader, "BITS_PER_PIXEL" ) == nullptr
|| CSLFetchNameValue( papszHeader, "PIXEL_FORMAT" ) == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Dataset appears to be NDF but is missing a required field.");
CSLDestroy( papszHeader );
return nullptr;
}
if( !EQUAL(CSLFetchNameValue( papszHeader, "PIXEL_FORMAT"), "BYTE" )
|| !EQUAL(CSLFetchNameValue( papszHeader, "BITS_PER_PIXEL"),"8") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently NDF driver supports only 8bit BYTE format." );
CSLDestroy( papszHeader );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszHeader );
CPLError( CE_Failure, CPLE_NotSupported,
"The NDF driver does not support update access to existing"
" datasets.\n" );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
NDFDataset *poDS = new NDFDataset();
poDS->papszHeader = papszHeader;
poDS->nRasterXSize = atoi(poDS->Get("PIXELS_PER_LINE",""));
poDS->nRasterYSize = atoi(poDS->Get("LINES_PER_DATA_FILE",""));
/* -------------------------------------------------------------------- */
/* Create a raw raster band for each file. */
/* -------------------------------------------------------------------- */
const char* pszBand = CSLFetchNameValue(papszHeader,
"NUMBER_OF_BANDS_IN_VOLUME");
if (pszBand == nullptr)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot find band count");
delete poDS;
return nullptr;
}
const int nBands = atoi(pszBand);
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBands, FALSE))
{
delete poDS;
return nullptr;
}
for( int iBand = 0; iBand < nBands; iBand++ )
{
char szKey[100];
snprintf( szKey, sizeof(szKey), "BAND%d_FILENAME", iBand+1 );
CPLString osFilename = poDS->Get(szKey,"");
// NDF1 file do not include the band filenames.
if( osFilename.empty() )
{
char szBandExtension[15];
snprintf( szBandExtension, sizeof(szBandExtension), "I%d", iBand+1 );
osFilename = CPLResetExtension( poOpenInfo->pszFilename,
szBandExtension );
}
else
{
CPLString osBasePath = CPLGetPath(poOpenInfo->pszFilename);
osFilename = CPLFormFilename( osBasePath, osFilename, nullptr);
}
VSILFILE *fpRaw = VSIFOpenL( osFilename, "rb" );
if( fpRaw == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to open band file: %s",
osFilename.c_str() );
delete poDS;
return nullptr;
}
poDS->papszExtraFiles =
CSLAddString( poDS->papszExtraFiles,
osFilename );
RawRasterBand *poBand =
new RawRasterBand( poDS, iBand+1, fpRaw, 0, 1, poDS->nRasterXSize,
GDT_Byte, TRUE, RawRasterBand::OwnFP::YES );
snprintf( szKey, sizeof(szKey), "BAND%d_NAME", iBand+1 );
poBand->SetDescription( poDS->Get(szKey, "") );
snprintf( szKey, sizeof(szKey), "BAND%d_WAVELENGTHS", iBand+1 );
poBand->SetMetadataItem( "WAVELENGTHS", poDS->Get(szKey,"") );
snprintf( szKey, sizeof(szKey), "BAND%d_RADIOMETRIC_GAINS/BIAS", iBand+1 );
poBand->SetMetadataItem( "RADIOMETRIC_GAINS_BIAS",
poDS->Get(szKey,"") );
poDS->SetBand( iBand+1, poBand );
}
/* -------------------------------------------------------------------- */
/* Fetch and parse USGS projection parameters. */
/* -------------------------------------------------------------------- */
double adfUSGSParms[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
char **papszParmTokens =
CSLTokenizeStringComplex( poDS->Get( "USGS_PROJECTION_NUMBER", "" ),
",", FALSE, TRUE );
if( CSLCount( papszParmTokens ) >= 15 )
{
for( int i = 0; i < 15; i++ )
adfUSGSParms[i] = CPLAtof(papszParmTokens[i]);
}
CSLDestroy(papszParmTokens);
papszParmTokens = nullptr;
/* -------------------------------------------------------------------- */
/* Minimal georef support ... should add full USGS style */
/* support at some point. */
/* -------------------------------------------------------------------- */
const int nUSGSProjection = atoi(poDS->Get( "USGS_PROJECTION_NUMBER", "" ));
const int nZone = atoi(poDS->Get("USGS_MAP_ZONE","0"));
OGRSpatialReference oSRS;
oSRS.importFromUSGS( nUSGSProjection, nZone, adfUSGSParms, 12 );
const CPLString osDatum = poDS->Get( "HORIZONTAL_DATUM", "" );
if( EQUAL(osDatum,"WGS84") || EQUAL(osDatum,"NAD83")
|| EQUAL(osDatum,"NAD27") )
{
oSRS.SetWellKnownGeogCS( osDatum );
}
else if( STARTS_WITH_CI(osDatum, "NAD27") )
{
oSRS.SetWellKnownGeogCS( "NAD27" );
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unrecognized datum name in NLAPS/NDF file:%s, "
"assuming WGS84.",
osDatum.c_str() );
oSRS.SetWellKnownGeogCS( "WGS84" );
}
if( oSRS.GetRoot() != nullptr )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = nullptr;
oSRS.exportToWkt( &(poDS->pszProjection) );
}
/* -------------------------------------------------------------------- */
/* Get geotransform. */
/* -------------------------------------------------------------------- */
char **papszUL = CSLTokenizeString2(
poDS->Get("UPPER_LEFT_CORNER",""), ",", 0 );
char **papszUR = CSLTokenizeString2(
poDS->Get("UPPER_RIGHT_CORNER",""), ",", 0 );
char **papszLL = CSLTokenizeString2(
poDS->Get("LOWER_LEFT_CORNER",""), ",", 0 );
if( CSLCount(papszUL) == 4
&& CSLCount(papszUR) == 4
&& CSLCount(papszLL) == 4 )
{
poDS->adfGeoTransform[0] = CPLAtof(papszUL[2]);
poDS->adfGeoTransform[1] =
(CPLAtof(papszUR[2]) - CPLAtof(papszUL[2])) / (poDS->nRasterXSize-1);
poDS->adfGeoTransform[2] =
(CPLAtof(papszUR[3]) - CPLAtof(papszUL[3])) / (poDS->nRasterXSize-1);
poDS->adfGeoTransform[3] = CPLAtof(papszUL[3]);
poDS->adfGeoTransform[4] =
(CPLAtof(papszLL[2]) - CPLAtof(papszUL[2])) / (poDS->nRasterYSize-1);
poDS->adfGeoTransform[5] =
(CPLAtof(papszLL[3]) - CPLAtof(papszUL[3])) / (poDS->nRasterYSize-1);
// Move origin up-left half a pixel.
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[4] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[2] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5;
}
CSLDestroy( papszUL );
CSLDestroy( papszLL );
CSLDestroy( papszUR );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *ROIPACDataset::Open( GDALOpenInfo *poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Confirm that the header is compatible with a ROIPAC dataset. */
/* -------------------------------------------------------------------- */
if ( !Identify(poOpenInfo) )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the .rsc file */
/* -------------------------------------------------------------------- */
CPLString osRscFilename = getRscFilename( poOpenInfo );
if ( osRscFilename.empty() )
{
return NULL;
}
VSILFILE *fpRsc;
if ( poOpenInfo->eAccess == GA_Update )
{
fpRsc = VSIFOpenL( osRscFilename, "r+" );
}
else
{
fpRsc = VSIFOpenL( osRscFilename, "r" );
}
if ( fpRsc == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Load the .rsc information. */
/* -------------------------------------------------------------------- */
char **papszRsc = NULL;
while ( true )
{
const char *pszLine = CPLReadLineL( fpRsc );
if (pszLine == NULL)
{
break;
}
char **papszTokens = CSLTokenizeString2( pszLine, " \t",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES
| CSLT_PRESERVEQUOTES
| CSLT_PRESERVEESCAPES );
if ( papszTokens == NULL
|| papszTokens[0] == NULL || papszTokens[1] == NULL )
{
CSLDestroy ( papszTokens );
break;
}
papszRsc = CSLSetNameValue( papszRsc,
papszTokens[0], papszTokens[1] );
CSLDestroy ( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Fetch required fields. */
/* -------------------------------------------------------------------- */
if ( CSLFetchNameValue( papszRsc, "WIDTH" ) == NULL
|| CSLFetchNameValue( papszRsc, "FILE_LENGTH" ) == NULL )
{
CSLDestroy( papszRsc );
CPL_IGNORE_RET_VAL(VSIFCloseL( fpRsc ));
return NULL;
}
const int nWidth = atoi( CSLFetchNameValue( papszRsc, "WIDTH" ) );
const int nFileLength = atoi( CSLFetchNameValue( papszRsc, "FILE_LENGTH" ) );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ROIPACDataset *poDS = new ROIPACDataset();
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nFileLength;
poDS->eAccess = poOpenInfo->eAccess;
poDS->fpRsc = fpRsc;
poDS->pszRscFilename = CPLStrdup( osRscFilename.c_str() );
/* -------------------------------------------------------------------- */
/* Reopen file in update mode if necessary. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
}
else
{
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
}
if( poDS->fpImage == NULL )
{
delete poDS;
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to re-open %s within ROI_PAC driver.\n",
poOpenInfo->pszFilename );
CSLDestroy( papszRsc );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType;
int nBands;
enum Interleave { LINE, PIXEL } eInterleave;
const char *pszExtension = CPLGetExtension(poOpenInfo->pszFilename);
if ( strcmp( pszExtension, "raw" ) == 0 )
{
/* ------------------------------------------------------------ */
/* TODO: ROI_PAC raw images are what would be GDT_CInt8 typed, */
/* but since that type do not exist, we will have to implement */
/* a specific case in the RasterBand to convert it to */
/* GDT_CInt16 for example */
/* ------------------------------------------------------------ */
#if 0
eDataType = GDT_CInt8;
nBands = 1;
eInterleave = PIXEL;
#else
CPLError( CE_Failure, CPLE_NotSupported,
"Reading ROI_PAC raw files is not supported yet." );
delete poDS;
CSLDestroy( papszRsc );
return NULL;
#endif
}
else if ( strcmp( pszExtension, "int" ) == 0
|| strcmp( pszExtension, "slc" ) == 0 )
{
eDataType = GDT_CFloat32;
nBands = 1;
eInterleave = PIXEL;
}
else if ( strcmp( pszExtension, "amp" ) == 0 )
{
eDataType = GDT_Float32;
nBands = 2;
eInterleave = PIXEL;
}
else if ( strcmp( pszExtension, "cor" ) == 0
|| strcmp( pszExtension, "hgt" ) == 0
|| strcmp( pszExtension, "unw" ) == 0
|| strcmp( pszExtension, "msk" ) == 0
|| strcmp( pszExtension, "trans" ) == 0 )
{
eDataType = GDT_Float32;
nBands = 2;
eInterleave = LINE;
}
else if ( strcmp( pszExtension, "dem" ) == 0 )
{
eDataType = GDT_Int16;
nBands = 1;
eInterleave = PIXEL;
}
else if ( strcmp( pszExtension, "flg" ) == 0 )
{
eDataType = GDT_Byte;
nBands = 1;
eInterleave = PIXEL;
}
else { /* Eeek */
delete poDS;
CSLDestroy( papszRsc );
return NULL;
}
int nPixelOffset;
int nLineOffset;
int nBandOffset;
if (eInterleave == LINE)
{
nPixelOffset = GDALGetDataTypeSize(eDataType)/8;
nLineOffset = nPixelOffset * nWidth * nBands;
nBandOffset = GDALGetDataTypeSize(eDataType)/8 * nWidth;
}
else { /* PIXEL */
nPixelOffset = GDALGetDataTypeSize(eDataType)/8 * nBands;
nLineOffset = nPixelOffset * nWidth;
nBandOffset = GDALGetDataTypeSize(eDataType)/8;
if( nBands > 1 )
{
// GDAL 2.0.[0-3] and 2.1.0 had a value of nLineOffset that was
// equal to the theoretical nLineOffset multiplied by nBands...
VSIFSeekL( poDS->fpImage, 0, SEEK_END );
const GUIntBig nWrongFileSize = GDALGetDataTypeSizeBytes(eDataType) *
nWidth * (static_cast<GUIntBig>(nFileLength - 1) * nBands * nBands + nBands);
if( VSIFTellL( poDS->fpImage ) == nWrongFileSize )
{
CPLError(CE_Warning, CPLE_AppDefined,
"This file has been incorrectly generated by an older "
"GDAL version whose line offset computation was erroneous. "
"Taking that into account, but the file should be re-encoded ideally");
nLineOffset = nLineOffset * nBands;
}
}
}
poDS->nBands = nBands;
for (int b = 0; b < nBands; b++)
{
poDS->SetBand( b + 1,
new ROIPACRasterBand( poDS, b + 1, poDS->fpImage,
nBandOffset * b,
nPixelOffset, nLineOffset,
eDataType, TRUE,
TRUE, FALSE ) );
}
/* -------------------------------------------------------------------- */
/* Interpret georeferencing, if present. */
/* -------------------------------------------------------------------- */
if ( CSLFetchNameValue( papszRsc, "X_FIRST" ) != NULL
&& CSLFetchNameValue( papszRsc, "X_STEP" ) != NULL
&& CSLFetchNameValue( papszRsc, "Y_FIRST" ) != NULL
&& CSLFetchNameValue( papszRsc, "Y_STEP" ) != NULL )
{
poDS->adfGeoTransform[0] = CPLAtof( CSLFetchNameValue( papszRsc,
"X_FIRST" ) );
poDS->adfGeoTransform[1] = CPLAtof( CSLFetchNameValue( papszRsc,
"X_STEP" ) );
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = CPLAtof( CSLFetchNameValue( papszRsc,
"Y_FIRST" ) );
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = CPLAtof( CSLFetchNameValue( papszRsc,
"Y_STEP" ) );
poDS->bValidGeoTransform = true;
}
if ( CSLFetchNameValue( papszRsc, "PROJECTION" ) != NULL )
{
/* ------------------------------------------------------------ */
/* In ROI_PAC, images are georeferenced either with lat/long or */
/* UTM projection. However, using UTM projection is dangerous */
/* because there is no North/South field, or use of latitude */
/* bands! */
/* ------------------------------------------------------------ */
OGRSpatialReference oSRS;
if ( strcmp( CSLFetchNameValue( papszRsc, "PROJECTION" ),
"LL" ) == 0 )
{
if ( CSLFetchNameValue( papszRsc, "DATUM" ) != NULL )
{
oSRS.SetWellKnownGeogCS( CSLFetchNameValue( papszRsc,
"DATUM" ) );
}
else {
oSRS.SetWellKnownGeogCS( "WGS84" );
}
}
else if( STARTS_WITH(CSLFetchNameValue( papszRsc, "PROJECTION" ), "UTM") )
{
const char *pszZone = CSLFetchNameValue( papszRsc,
"PROJECTION" ) + 3;
oSRS.SetUTM( atoi( pszZone ), TRUE ); /* FIXME: north/south? */
if ( CSLFetchNameValue( papszRsc, "DATUM" ) != NULL )
{
oSRS.SetWellKnownGeogCS( CSLFetchNameValue( papszRsc,
"DATUM" ) );
}
else {
oSRS.SetWellKnownGeogCS( "NAD27" );
}
}
oSRS.exportToWkt( &poDS->pszProjection );
}
if ( CSLFetchNameValue( papszRsc, "Z_OFFSET" ) != NULL )
{
const double dfOffset
= strtod( CSLFetchNameValue( papszRsc, "Z_OFFSET" ), NULL);
for (int b = 1; b <= nBands; b++)
{
GDALRasterBand *poBand = poDS->GetRasterBand(b);
poBand->SetOffset( dfOffset );
}
}
if ( CSLFetchNameValue( papszRsc, "Z_SCALE" ) != NULL )
{
const double dfScale
= strtod( CSLFetchNameValue( papszRsc, "Z_SCALE" ), NULL);
for (int b = 1; b <= nBands; b++)
{
GDALRasterBand *poBand = poDS->GetRasterBand(b);
poBand->SetScale( dfScale );
}
}
/* -------------------------------------------------------------------- */
/* Set all the other header metadata into the ROI_PAC domain */
/* -------------------------------------------------------------------- */
for (int i = 0; i < CSLCount( papszRsc ); i++)
{
char **papszTokens = CSLTokenizeString2( papszRsc[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "FILE_LENGTH" ) == 0
|| strcmp( papszTokens[0], "X_FIRST" ) == 0
|| strcmp( papszTokens[0], "X_STEP" ) == 0
|| strcmp( papszTokens[0], "Y_FIRST" ) == 0
|| strcmp( papszTokens[0], "Y_STEP" ) == 0
|| strcmp( papszTokens[0], "PROJECTION" ) == 0
|| strcmp( papszTokens[0], "DATUM" ) == 0
|| strcmp( papszTokens[0], "Z_OFFSET" ) == 0
|| strcmp( papszTokens[0], "Z_SCALE" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
poDS->SetMetadataItem(papszTokens[0], papszTokens[1], "ROI_PAC");
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Free papszRsc */
/* -------------------------------------------------------------------- */
CSLDestroy( papszRsc );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}