void NASReader::PushFeature( const char *pszElement,
const Attributes &attrs )
{
int iClass;
/* -------------------------------------------------------------------- */
/* Find the class of this element. */
/* -------------------------------------------------------------------- */
for( iClass = 0; iClass < GetClassCount(); iClass++ )
{
if( EQUAL(pszElement,GetClass(iClass)->GetElementName()) )
break;
}
/* -------------------------------------------------------------------- */
/* Create a new feature class for this element, if there is no */
/* existing class for it. */
/* -------------------------------------------------------------------- */
if( iClass == GetClassCount() )
{
CPLAssert( !IsClassListLocked() );
GMLFeatureClass *poNewClass = new GMLFeatureClass( pszElement );
AddClass( poNewClass );
}
/* -------------------------------------------------------------------- */
/* Create a feature of this feature class. */
/* -------------------------------------------------------------------- */
GMLFeature *poFeature = new GMLFeature( GetClass( iClass ) );
/* -------------------------------------------------------------------- */
/* Create and push a new read state. */
/* -------------------------------------------------------------------- */
GMLReadState *poState;
poState = new GMLReadState();
poState->m_poFeature = poFeature;
PushState( poState );
/* -------------------------------------------------------------------- */
/* Check for gml:id, and if found push it as an attribute named */
/* gml_id. */
/* -------------------------------------------------------------------- */
int nFIDIndex;
XMLCh anFID[100];
tr_strcpy( anFID, "gml:id" );
nFIDIndex = attrs.getIndex( anFID );
if( nFIDIndex != -1 )
{
char *pszFID = tr_strdup( attrs.getValue( nFIDIndex ) );
SetFeatureProperty( "gml_id", pszFID );
CPLFree( pszFID );
}
}
// Get the nth implementation coclass id.
HRESULT CAAFPluginServer::GetClassObjectID(ULONG index, CLSID *pClassID)
{
// Validate pre-conditions and parameters.
if (0 == GetClassCount())
return CLASS_E_CLASSNOTAVAILABLE;
if (index >= GetClassCount() || NULL == pClassID)
return E_INVALIDARG;
// Lookup the corresponding object info pointer from our table.
memcpy(pClassID, AAFPluginObjectMap[index].pCLSID, sizeof(CLSID));
return S_OK;
}
// Get the nth implementation coclass id.
HRESULT CAAFInProcServer::GetClassObjectID(ULONG index, CLSID *pClassID)
{
// Validate pre-conditions and parameters.
if (!_ppObjectInfoKey || 0 == GetClassCount())
return CLASS_E_CLASSNOTAVAILABLE;
if (index >= GetClassCount() || !pClassID)
return E_INVALIDARG;
// Lookup the corresponding object info pointer from our table.
AAFComObjectInfo_t *pInfo = _ppObjectInfoKey[index];
assert(pInfo!=0);
memcpy(pClassID, pInfo->pCLSID, sizeof(CLSID));
return S_OK;
}
int GMLReader::IsFeatureElement( const char *pszElement )
{
CPLAssert( m_poState != NULL );
const char *pszLast = m_poState->GetLastComponent();
int nLen = strlen(pszLast);
if( nLen < 6 || !(EQUAL(pszLast+nLen-6,"member") ||
EQUAL(pszLast+nLen-7,"members")) )
return FALSE;
// If the class list isn't locked, any element that is a featureMember
// will do.
if( !IsClassListLocked() )
return TRUE;
// otherwise, find a class with the desired element name.
for( int i = 0; i < GetClassCount(); i++ )
{
if( EQUAL(pszElement,GetClass(i)->GetElementName()) )
return TRUE;
}
return FALSE;
}
bool Node::UpdateEstimation(float* pEstimation) const
{
if(!const_cast<Node*>(this)->IsLeaf())
return false;
const float* pIncrement = mpCut->GetIncrement();
int nClassCount = GetClassCount();
if(nClassCount == 1)
{
*pEstimation += *pIncrement;
}
else
{
common::utility::VectorAdd(pEstimation, pIncrement, GetClassCount());
}
return true;
}
float GetClassPercent(int c_class)
{
if(GetLoadedMobCount() > 0)
return 100.0 * ((float)GetClassCount(c_class)/(float)GetLoadedMobCount());
return 0.0;
}
int NASReader::IsFeatureElement( const char *pszElement )
{
CPLAssert( m_poState != NULL );
const char *pszLast = m_poState->GetLastComponent();
int nLen = strlen(pszLast);
// There seem to be two major NAS classes of feature identifiers
// -- either a wfs:Insert or a gml:featureMember.
if( (nLen < 6 || !EQUAL(pszLast+nLen-6,"Insert"))
&& (nLen < 13 || !EQUAL(pszLast+nLen-13,"featureMember")) )
return FALSE;
// If the class list isn't locked, any element that is a featureMember
// will do.
if( !IsClassListLocked() )
return TRUE;
// otherwise, find a class with the desired element name.
for( int i = 0; i < GetClassCount(); i++ )
{
if( EQUAL(pszElement,GetClass(i)->GetElementName()) )
return TRUE;
}
return FALSE;
}
void GMLReader::PushFeature( const char *pszElement,
const char *pszFID )
{
int iClass;
/* -------------------------------------------------------------------- */
/* Find the class of this element. */
/* -------------------------------------------------------------------- */
for( iClass = 0; iClass < GetClassCount(); iClass++ )
{
if( EQUAL(pszElement,GetClass(iClass)->GetElementName()) )
break;
}
/* -------------------------------------------------------------------- */
/* Create a new feature class for this element, if there is no */
/* existing class for it. */
/* -------------------------------------------------------------------- */
if( iClass == GetClassCount() )
{
CPLAssert( !IsClassListLocked() );
GMLFeatureClass *poNewClass = new GMLFeatureClass( pszElement );
AddClass( poNewClass );
}
/* -------------------------------------------------------------------- */
/* Create a feature of this feature class. Try to set the fid */
/* if available. */
/* -------------------------------------------------------------------- */
GMLFeature *poFeature = new GMLFeature( GetClass( iClass ) );
if( pszFID != NULL )
{
poFeature->SetFID( pszFID );
}
/* -------------------------------------------------------------------- */
/* Create and push a new read state. */
/* -------------------------------------------------------------------- */
GMLReadState *poState;
poState = new GMLReadState();
poState->m_poFeature = poFeature;
PushState( poState );
}
HRESULT CAAFPluginServer::GetClassObject
(
REFCLSID rclsid,
REFIID riid,
void ** ppv )
{
HRESULT hr = CLASS_E_CLASSNOTAVAILABLE;
if (NULL == ppv)
return E_INVALIDARG;
*ppv = NULL;
// Search the object table for the given class id.
// Lookup the class id in the com object table.
AAFPluginObjectInfo_t *pResult = NULL;
for (aafUInt32 i = 0; i < GetClassCount(); ++i)
{
if (!memcmp(&rclsid,AAFPluginObjectMap[i].pCLSID,sizeof(rclsid)))
{
pResult = &AAFPluginObjectMap[i];
break;
}
}
if (NULL == pResult)
return hr;
// We found the requested class id so attempt to create a class factory.
CAAFClassFactory *pAAFClassFactory = new CAAFClassFactory(pResult->pfnCreate);
if (NULL == pAAFClassFactory)
return E_OUTOFMEMORY;
// We now have a local reference.
pAAFClassFactory->AddRef();
// See of the factory supports the requested interface. If this succeeds
// then the reference count will be two. If it fails the reference
// count will be one and the following release will delete the factory
// object.
hr = pAAFClassFactory->QueryInterface(riid, ppv);
// We are through with this object.
pAAFClassFactory->Release();
return hr;
}
VOID
ListDevicesByType(HWND hTreeView,
HTREEITEM hRoot,
BOOL bShowHidden)
{
PDEVCLASS_ENTRY pClassArray;
ULONG ulClassCount;
ulClassCount = GetClassCount();
pClassArray = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
ulClassCount * sizeof(DEVCLASS_ENTRY));
if (pClassArray == NULL)
return;
EnumDeviceClasses(hTreeView,
hRoot,
pClassArray,
ulClassCount);
EnumDevices(hTreeView,
pClassArray,
ulClassCount,
bShowHidden);
CleanupDeviceClasses(hTreeView,
pClassArray,
ulClassCount);
if (pClassArray != NULL)
HeapFree(GetProcessHeap(), 0, pClassArray);
(void)TreeView_Expand(hTreeView,
hRoot,
TVE_EXPAND);
(void)TreeView_SortChildren(hTreeView,
hRoot,
0);
(void)TreeView_SelectItem(hTreeView,
hRoot);
}
int GMLReader::SaveClasses( const char *pszFile )
{
// Add logic later to determine reasonable default schema file.
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Create in memory schema tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClassList" );
for( int iClass = 0; iClass < GetClassCount(); iClass++ )
{
GMLFeatureClass *poClass = GetClass( iClass );
CPLAddXMLChild( psRoot, poClass->SerializeToXML() );
}
/* -------------------------------------------------------------------- */
/* Serialize to disk. */
/* -------------------------------------------------------------------- */
FILE *fp;
int bSuccess = TRUE;
char *pszWholeText = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
fp = VSIFOpen( pszFile, "wb" );
if( fp == NULL )
bSuccess = FALSE;
else if( VSIFWrite( pszWholeText, strlen(pszWholeText), 1, fp ) != 1 )
bSuccess = FALSE;
else
VSIFClose( fp );
CPLFree( pszWholeText );
return bSuccess;
}
int GMLReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
if( poFeature->GetGeometry() != NULL
&& strlen(poFeature->GetGeometry()) != 0 )
{
poGeometry = OGRGeometryFactory::createFromGML(
poFeature->GetGeometry() );
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}
int GMLReader::ReArrangeTemplateClasses ( GFSTemplateList *pCC )
{
/* rearranging the final FeatureClass list [SEQUENTIAL] */
int m_nSavedClassCount = GetClassCount();
/* saving the previous FeatureClass list */
GMLFeatureClass **m_papoSavedClass = (GMLFeatureClass **)
CPLMalloc( sizeof(void*) * m_nSavedClassCount );
int clIdx;
for (clIdx = 0; clIdx < GetClassCount(); clIdx++)
{
/* tranferring any previous FeatureClass */
m_papoSavedClass[clIdx] = m_papoClass[clIdx];
}
/* cleaning the previous FeatureClass list */
SetClassListLocked( FALSE );
CPLFree( m_papoClass );
m_nClassCount = 0;
m_papoClass = NULL;
GFSTemplateItem *pItem = pCC->GetFirst();
while ( pItem != NULL )
{
/*
* re-inserting any required FeatureClassup
* accordingly to actual SEQUENTIAL layout
*/
GMLFeatureClass* poClass = NULL;
for( int iClass = 0; iClass < m_nSavedClassCount; iClass++ )
{
GMLFeatureClass* poItem = m_papoSavedClass[iClass];
if( EQUAL(poItem->GetName(), pItem->GetName() ))
{
poClass = poItem;
break;
}
}
if (poClass != NULL)
{
if (poClass->GetFeatureCount() > 0)
AddClass( poClass );
}
pItem = pItem->GetNext();
}
SetClassListLocked( TRUE );
/* destroying the saved List and any unused FeatureClass */
for( int iClass = 0; iClass < m_nSavedClassCount; iClass++ )
{
int bUnused = TRUE;
GMLFeatureClass* poClass = m_papoSavedClass[iClass];
for( int iClass2 = 0; iClass2 < m_nClassCount; iClass2++ )
{
if (m_papoClass[iClass2] == poClass)
{
bUnused = FALSE;
break;
}
}
if ( bUnused == TRUE )
delete poClass;
}
CPLFree( m_papoSavedClass );
return 1;
}
int NASReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
if( poFeature->GetGeometry() != NULL
&& strlen(poFeature->GetGeometry()) != 0 )
{
poGeometry = (OGRGeometry *) OGR_G_CreateFromGML(
poFeature->GetGeometry() );
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
OGRwkbGeometryType eGType = (OGRwkbGeometryType)
poClass->GetGeometryType();
// Merge geometry type into layer.
if( poClass->GetFeatureCount() == 1 && eGType == wkbUnknown )
eGType = wkbNone;
poClass->SetGeometryType(
(int) OGRMergeGeometryTypes(
eGType, poGeometry->getGeometryType() ) );
// merge extents.
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
else
{
if( poClass->GetGeometryType() == (int) wkbUnknown
&& poClass->GetFeatureCount() == 1 )
poClass->SetGeometryType( wkbNone );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}
int NASReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
std::string osWork;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
const CPLXMLNode* const * papsGeometry = poFeature->GetGeometryList();
if( papsGeometry[0] != NULL )
{
poGeometry = (OGRGeometry*) OGR_G_CreateFromGMLTree(papsGeometry[0]);
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
OGRwkbGeometryType eGType = (OGRwkbGeometryType)
poClass->GetGeometryType();
// Merge SRSName into layer.
const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork, FALSE);
// if (pszSRSName != NULL)
// m_bCanUseGlobalSRSName = FALSE;
poClass->MergeSRSName(pszSRSName);
// Merge geometry type into layer.
if( poClass->GetFeatureCount() == 1 && eGType == wkbUnknown )
eGType = wkbNone;
poClass->SetGeometryType(
(int) OGRMergeGeometryTypes(
eGType, poGeometry->getGeometryType() ) );
// merge extents.
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
else
{
if( poClass->GetGeometryType() == (int) wkbUnknown
&& poClass->GetFeatureCount() == 1 )
poClass->SetGeometryType( wkbNone );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}