예제 #1
0
파일: Fields.cpp 프로젝트: ViacheslavN/GIS
	void CFields::RebuildFieldIndexMap() const
	{
		m_mapFieldIndex.clear();

		for(uint32 i = 0; i < m_vecFields.size(); ++i)
		{
			IFieldPtr field = m_vecFields[i];
			if(!field.get())
				continue;
			m_mapFieldIndex.insert(TMapFieldIndex::value_type(field->getName(), (int)i));
		}
	}
예제 #2
0
bool AOToOGRFields(IFields* pFields, OGRFeatureDefn* pOGRFeatureDef, std::vector<long> & ogrToESRIFieldMapping)
{
  HRESULT hr;

  long fieldCount;
  if (FAILED(hr = pFields->get_FieldCount(&fieldCount)))
    return false;

  ogrToESRIFieldMapping.clear();

  for (long i = 0; i < fieldCount; ++i)
  {

    IFieldPtr ipField;
    if (FAILED(hr = pFields->get_Field(i, &ipField)))
      return AOErr(hr, "Error getting field");

    CComBSTR name;
    if (FAILED(hr = ipField->get_Name(&name)))
      return AOErr(hr, "Could not get field name");

    esriFieldType fieldType;
    if (FAILED(hr = ipField->get_Type(&fieldType)))
      return AOErr(hr, "Error getting field type");

    //skip these
    if (fieldType == esriFieldTypeOID || fieldType == esriFieldTypeGeometry)
      continue;

    OGRFieldType ogrType;
    if (!AOToOGRFieldType(fieldType, &ogrType))
    {
      // field cannot be mapped, skipping it
      CPLError( CE_Warning, CPLE_AppDefined, "Skipping field %s", CW2A(name) );
      continue;
    }

    OGRFieldDefn fieldTemplate( CW2A(name), ogrType);
    pOGRFeatureDef->AddFieldDefn( &fieldTemplate );

    ogrToESRIFieldMapping.push_back(i);
  }

  CPLAssert(ogrToESRIFieldMapping.size() == pOGRFeatureDef->GetFieldCount());

  return true;
}
STDMETHODIMP CSimplePointDatasetHelper::get_Fields(long ClassIndex, IFields **FieldSet)
{
	if (! FieldSet) return E_POINTER;
	
	HRESULT hr;
  
	// First get the standard fields for an feature class
	IObjectClassDescriptionPtr ipOCDesc;
	hr = ipOCDesc.CreateInstance(CLSID_FeatureClassDescription);
	if (FAILED(hr)) return hr;

	IFieldsPtr ipFields;
	hr = ipOCDesc->get_RequiredFields(&ipFields);
	if (FAILED(hr)) return hr;

  IFieldPtr ipField;

  // We will have: a shape field name of "shape"
  // an UnknownCoordinateSystem
  // Just need to change the geometry type to Point
	long i;
	long lNumFields;
	esriFieldType eFieldType;
	hr = ipFields->get_FieldCount(&lNumFields);
	if (FAILED(hr)) return hr;

	for (i=0; i < lNumFields; i++)
  {
    hr = ipFields->get_Field(i, &ipField);
		if (FAILED(hr)) return hr;

		hr = ipField->get_Type(&eFieldType);
		if (eFieldType == esriFieldTypeGeometry)
		{
			IGeometryDefPtr ipGeomDef;
			hr = ipField->get_GeometryDef(&ipGeomDef);
			if (FAILED(hr)) return hr;

  		IGeometryDefEditPtr ipGeomDefEdit = ipGeomDef;
			if (ipGeomDefEdit == NULL) return E_FAIL;

			hr = ipGeomDefEdit->put_GeometryType(esriGeometryPoint);
			if (FAILED(hr)) return hr;
		}
	}

		// Add the extra text field
	IFieldEditPtr ipFieldEdit;
	hr = ipFieldEdit.CreateInstance(CLSID_Field);
  if (FAILED(hr)) return hr;

	hr = ipFieldEdit->put_Name(L"Column1");
	if (FAILED(hr)) return hr;
	
	hr = ipFieldEdit->put_Type(esriFieldTypeString);
	if (FAILED(hr)) return hr;

	hr = ipFieldEdit->put_Length(1);
	if (FAILED(hr)) return hr;

  IFieldsEditPtr ipFieldsEdit = ipFields;
  if (ipFieldsEdit == NULL) return E_FAIL;

	ipField = ipFieldEdit;
	if (ipField == NULL) return E_FAIL;

  hr = ipFieldsEdit->AddField(ipField);
	if (FAILED(hr)) return hr;

  *FieldSet = ipFields.Detach(); // pass ownership of object to client 

	return S_OK;
}
예제 #4
0
파일: aolayer.cpp 프로젝트: 0004c/node-gdal
bool AOLayer::Initialize(ITable* pTable)
{
  HRESULT hr;

  m_ipTable = pTable;

  CComBSTR temp;

  IDatasetPtr ipDataset = m_ipTable;
  if (FAILED(hr = ipDataset->get_Name(&temp)))
    return false;

  m_pFeatureDefn = new OGRFeatureDefn(CW2A(temp)); //Should I "new" an OGR smart pointer - sample says so, but it doesn't seem right
                                                   //as long as we use the same compiler & settings in both the ogr build and this
                                                   //driver, we should be OK
  m_pFeatureDefn->Reference();

  IFeatureClassPtr ipFC = m_ipTable;

  VARIANT_BOOL hasOID = VARIANT_FALSE;
  ipFC->get_HasOID(&hasOID);

  if (hasOID == VARIANT_TRUE)
  {
    ipFC->get_OIDFieldName(&temp);
    m_strOIDFieldName = CW2A(temp);
  }

  if (FAILED(hr = ipFC->get_ShapeFieldName(&temp)))
    return AOErr(hr, "No shape field found!");

  m_strShapeFieldName = CW2A(temp);

  IFieldsPtr ipFields;
  if (FAILED(hr = ipFC->get_Fields(&ipFields)))
    return AOErr(hr, "Fields not found!");

  long shapeIndex = -1;
  if (FAILED(hr = ipFields->FindField(temp, &shapeIndex)))
    return AOErr(hr, "Shape field not found!");

  IFieldPtr ipShapeField;
  if (FAILED(hr = ipFields->get_Field(shapeIndex, &ipShapeField)))
    return false;
    
  // Use GeometryDef to set OGR shapetype and Spatial Reference information
  //

  IGeometryDefPtr ipGeoDef;
  if (FAILED(hr = ipShapeField->get_GeometryDef(&ipGeoDef)))
    return false;

  OGRwkbGeometryType ogrGeoType;
  if (!AOToOGRGeometry(ipGeoDef, &ogrGeoType))
    return false;

  m_pFeatureDefn->SetGeomType(ogrGeoType);

  if (wkbFlatten(ogrGeoType) == wkbMultiLineString || wkbFlatten(ogrGeoType) == wkbMultiPoint)
    m_forceMulti = true;

  
  // Mapping of Spatial Reference will be passive about errors
  // (it is possible we won't be able to map some ESRI-specific projections)

  esriGeometry::ISpatialReferencePtr ipSR = NULL;

  if (FAILED(hr = ipGeoDef->get_SpatialReference(&ipSR)))
  {
    AOErr(hr, "Failed Fetching ESRI spatial reference");
  }
  else
  {
    if (!AOToOGRSpatialReference(ipSR, &m_pSRS))
    {
      //report error, but be passive about it
      CPLError( CE_Warning, CPLE_AppDefined, "Failed Mapping ESRI Spatial Reference");
    }
  }


  // Map fields
  //
  return AOToOGRFields(ipFields, m_pFeatureDefn, m_OGRFieldToESRIField);
}
예제 #5
0
		int64 SQLiteInsertCursor::InsertRow(IRow* pRow)
		{
			if(!m_bInit)
			{
				init();
				m_bInit = true;
			}
			if(!m_bValidCursor)
				return -1;
			IFeature *pFeature = NULL;
			//IFieldSetPtr pFieldSet = pRow->GetFieldSet();
			//if(!pFieldSet.get() || pFieldSet->GetCount() == 0)
			//	pFieldSet = m_pFieldSet;
			{
				//for (int i = 0; i < pFieldSet->GetCount(); ++i)
				for (int i = 0, sz = (int)m_vecTypes.size(); i < sz; ++i)
				
				{
					
					/*const CommonLib::CString& sName = pFieldSet->Get(i);
					TFieldsInfo::const_iterator c_it = m_mapFieldInfo.find(sName);
					if(c_it == m_mapFieldInfo.end())
					{
						//TO DO Error
						return -1;
					}*/

					if(m_vecTypes[i] == dtGeometry)
					{
						pFeature = (IFeature *)pRow;
						if(!pFeature)
						{
							//TO DO Error
							return -1;
						}
						
						CommonLib::IGeoShapePtr pShape = pFeature->GetShape();
						if(pShape.get())
						{
						 
							//pShape->compress(&m_WriteShapeStream, &m_comp_params);
							if (!pShape->IsSuccinct())
								pShape->InnerEncode(&m_WriteShapeStream, &m_comp_params);
							m_pStmt->ColumnBindBlob(i + 1, pShape->buffer(), pShape->size());
							m_WriteShapeStream.seek(0, CommonLib::soFromBegin);
						}
						

					}
					else
					{
						m_pStmt->ColumnBind(i + 1, m_vecTypes[i], pRow->GetValue(i));
						 
					}
					if(m_pStmt->IsError())
					{
						//TO DO error
						m_bValidCursor = false;
						return -1;

					}
				}

				m_pStmt->StepNext();
				if(m_pStmt->IsError())
				{
					//TO DO error
					m_bValidCursor = false;
					return -1;
				}

				m_pStmt->reset();
			}
			
			int64 nLastRowID = m_pDB->GetLastInsertRowID();
			if(pFeature)
			{
				IFieldPtr pOIDField = pRow->GetSourceFields()->GetField(m_pTable->GetOIDFieldName());

				int64 nOID = -1;
				if(m_pTable->HasOIDField())
					nOID = pRow->GetOID();
				if(nOID == -1)
					nOID = nLastRowID;

				CommonLib::IGeoShapePtr pShape = pFeature->GetShape();
				CommonLib::bbox bb;
				if (m_ShapeType == CommonLib::shape_type_general_multipoint)
				{
					if (!InsertMultiPointSpatialIndex(pShape, nOID, pOIDField->GetType()))
						return -1;
				}
				else
				{
					if (m_ShapeType == CommonLib::shape_type_general_polygon || m_ShapeType == CommonLib::shape_type_general_polyline)
					{
						bb = pShape->getBB();
					}
					else if (m_ShapeType == CommonLib::shape_type_general_point)
					{
						auto *pXY = pShape->getPoints();

						bb.xMax = pXY->x;
						bb.xMin = pXY->x;
						bb.yMax = pXY->y;
						bb.yMin = pXY->y;
					}

					if (!InsertSpatialIndex(bb, nOID, pOIDField->GetType()))
						return -1;
				}
			}
			pRow->SetRowID(nLastRowID);
			return nLastRowID;
		}
예제 #6
0
		void SQLiteInsertCursor::init()
		{
		
			CommonLib::CString sSQL = L"INSERT INTO  " + m_pTable->GetDatasetName() + L" ( ";
			CommonLib::CString sValues = " VALUES ( ";


			if(!m_pFieldSet.get())
			{
				m_pFieldSet = new CFieldSet();
				for (int i = 0, sz = m_pSourceFields->GetFieldCount(); i < sz; ++i)
				{
					IFieldPtr pField = m_pSourceFields->GetField(i);
					m_pFieldSet->Add(pField->GetName());
				}
			}

			for (int i = 0; i < m_pFieldSet->GetCount(); ++i)
			{

				const CommonLib::CString& sFieldName = m_pFieldSet->Get(i);
				IFieldPtr pField = m_pSourceFields->GetField(sFieldName);

				if(!pField.get())
				{
					//TO DO error
					m_bValidCursor = false;
				}
				//m_mapFieldInfo.insert(std::make_pair(sFieldName, SFieldInfo(i, pField->GetType())));

				m_vecTypes.push_back(pField->GetType());
				if(i != 0)
				{
					sSQL += L", ";
					sValues += L", ";
				}

				sSQL += m_pFieldSet->Get(i);
				sValues += "?";
				
			}
			
			sValues  += L" )";
			sSQL += L" )";

			sSQL += sValues;

			m_pStmt = m_pDB->prepare_query(sSQL);
			if(!m_pStmt.get())
			{
				 //TO DO error
				m_bValidCursor = false;
				return;
			 
			}

			
			if(m_pTable->GetDatasetType() == dtFeatureClass)
			{
				CSQLiteFeatureClass *pFC = dynamic_cast<CSQLiteFeatureClass*>(m_pTable.get());
				assert(pFC);
				const CommonLib::CString& sRTreeIndex = pFC->GetRTReeIndexName();
				CommonLib::CString sSQL = L"INSERT INTO  " + sRTreeIndex + L"(feature_id, minX, maxX, minY, maxY)" + 
					" VALUES (?, ?, ?, ?, ?)";
				m_pStmtSpatial = m_pDB->prepare_query(sSQL);
				if(!m_pStmtSpatial.get())
				{
					m_bValidCursor = false;
				}
							
				GisGeometry::IEnvelopePtr pEnvelope =  pFC->GetExtent();
				m_comp_params = pEnvelope->GetCompressParams();
				m_ShapeType = CommonLib::CGeoShape::GetGeneralType(pFC->GetGeometryType());
				
			}
			
		}