// --------------------------------------------------------------------------- // Constructeur // ------------ bDBFTable ::bDBFTable( const char* path, const char* name, bool create, double* reso, double* ox, double* oy, int* tsrid, int* asrid, int* status) :bStdTable(*reso,*ox,*oy,*tsrid,*asrid,status){ _bTrace_("bDBFTable::bDBFTable",false); char fpath[1024]; sprintf(fpath,"%s%s",path,name); _dbf=DBFOpen(fpath,"rb+"); if(!_dbf){ _dbf=DBFOpen(fpath,"rb"); } if(_dbf){ return; } if(!create){ *status=-1; _te_("table not found : "+fpath); return; } _dbf=DBFCreate(fpath); if(!_dbf){ _te_("creation failed for : "+fpath); *status=-1; return; } *status=0; }
bool surfaceVectorField::CreateShape() { char DataBaseID[64]=""; hSHP=SHPCreate(ShapeFileName.c_str(), SHPT_POINT); if(hSHP==NULL) return false; SHPClose( hSHP ); // Create the database. hDBF=DBFCreate(DataBaseName.c_str()); if(hDBF==NULL) return false; //sprintf(DataBaseID, "%s", "Xcoord"); //DBFAddField(hDBF, DataBaseID, FTDouble, 16, 6); //sprintf(DataBaseID, "%s", "Ycoord"); //DBFAddField(hDBF, DataBaseID, FTDouble, 16, 6); sprintf(DataBaseID, "%s", "Windspd"); DBFAddField(hDBF, DataBaseID, FTDouble, 16, 6 ); sprintf(DataBaseID, "%s", "Winddir"); DBFAddField(hDBF, DataBaseID, FTInteger, 8, 0); sprintf(DataBaseID, "%s", "AV_dir"); DBFAddField(hDBF, DataBaseID, FTInteger, 8, 0 ); sprintf(DataBaseID, "%s", "AM_dir"); DBFAddField(hDBF, DataBaseID, FTInteger, 8, 0 ); DBFClose(hDBF); return true; }
DBFHandle DBFCloneEmpty(DBFHandle psDBF, const char * pszFilename ) { DBFHandle newDBF; newDBF = DBFCreate ( pszFilename ); if ( newDBF == NULL ) return ( NULL ); newDBF->pszHeader = (char *) malloc ( 32 * psDBF->nFields ); memcpy ( newDBF->pszHeader, psDBF->pszHeader, 32 * psDBF->nFields ); newDBF->nFields = psDBF->nFields; newDBF->nRecordLength = psDBF->nRecordLength; newDBF->nHeaderLength = psDBF->nHeaderLength; newDBF->panFieldOffset = (int *) malloc ( sizeof(int) * psDBF->nFields ); memcpy ( newDBF->panFieldOffset, psDBF->panFieldOffset, sizeof(int) * psDBF->nFields ); newDBF->panFieldSize = (int *) malloc ( sizeof(int) * psDBF->nFields ); memcpy ( newDBF->panFieldSize, psDBF->panFieldSize, sizeof(int) * psDBF->nFields ); newDBF->panFieldDecimals = (int *) malloc ( sizeof(int) * psDBF->nFields ); memcpy ( newDBF->panFieldDecimals, psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields ); newDBF->pachFieldType = (char *) malloc ( sizeof(int) * psDBF->nFields ); memcpy ( newDBF->pachFieldType, psDBF->pachFieldType, sizeof(int) * psDBF->nFields ); newDBF->bNoHeader = TRUE; newDBF->bUpdated = TRUE; DBFWriteHeader ( newDBF ); DBFClose ( newDBF ); newDBF = DBFOpen ( pszFilename, "rb+" ); return ( newDBF ); }
DBFHandle TeCreateDBFFile (const string& dbfFilename, TeAttributeList& attList) { DBFHandle hDBF = DBFCreate( dbfFilename.c_str() ); if( hDBF == 0 ) return 0; int i =0; TeAttributeList::iterator it=attList.begin(); while ( it != attList.end() ) { TeAttribute at = (*it); string atName = at.rep_.name_; if (atName.size() > 10) { int extra = (int)(atName.size() - 10)/2; int middle = (int)(atName.size()/2); string str = atName.substr(0,middle-extra-1); str += atName.substr(middle+extra); atName = str; } if (at.rep_.type_ == TeSTRING ) { if (DBFAddField( hDBF, atName.c_str(), FTString, at.rep_.numChar_, 0 ) == -1 ) return 0; } else if (at.rep_.type_ == TeINT) { if (DBFAddField( hDBF, atName.c_str(), FTInteger, 32, 0 ) == -1 ) return 0; } else if (at.rep_.type_ == TeREAL) { if (DBFAddField( hDBF, atName.c_str(), FTDouble, 40, 15 ) == -1 ) return 0; } // OBS: shapelib doesn´t deal with xBase field type for Date // we are transforming it to string else if (at.rep_.type_ == TeDATETIME) { if (DBFAddField( hDBF, atName.c_str(), FTDate, 8, 0 ) == -1 ) return 0; } ++i; ++it; } return hDBF; }
jboolean Java_org_maptools_shapelib_android_util_TestUtils_createShapefile(JNIEnv * env, jclass clazz, jstring file, jobject listObject) { // create a shapefile and dbf (e.g. /sdcard/foo/bar) const char *fileStr = (*env)->GetStringUTFChars(env, file, 0); SHPHandle hSHP = SHPCreate(fileStr, SHPT_POINT); DBFHandle hDBF = DBFCreate(fileStr); // define the shapefile attributes DBFAddField(hDBF, "name", FTString, 25, 0); DBFAddField(hDBF, "height", FTDouble, 8, 8); DBFAddField(hDBF, "apples", FTInteger, 1, 0); process(env, hSHP, hDBF, file, listObject); SHPClose(hSHP); DBFClose(hDBF); }
/** * Open and initialize all files belonging to shapefile (.shp/shx/dbf/prj/cpg). * Uses m_filename_base and m_sequence_number plus suffix to build filename. */ void open() { std::ostringstream filename; filename << m_filename_base; if (m_sequence_number) { filename << "_" << m_sequence_number; } m_shp_handle = SHPCreate(filename.str().c_str(), m_type); if (m_shp_handle == 0) { throw std::runtime_error("Can't open shapefile: " + filename.str() + ".shp/shx"); } m_dbf_handle = DBFCreate(filename.str().c_str()); if (m_dbf_handle == 0) { throw std::runtime_error("Can't open shapefile: " + filename.str() + ".dbf"); } std::ofstream file; file.open((filename.str() + ".prj").c_str()); if (file.fail()) { throw std::runtime_error("Can't open shapefile: " + filename.str() + ".prj"); } file << "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]]" << std::endl; file.close(); file.open((filename.str() + ".cpg").c_str()); if (file.fail()) { throw std::runtime_error("Can't open shapefile: " + filename.str() + ".cpg"); } file << "UTF-8" << std::endl; file.close(); // If any fields are defined already, add them here. This will do nothing if // called from the constructor. for (std::vector<Field>::const_iterator it = m_fields.begin(); it != m_fields.end(); ++it) { DBFAddField(m_dbf_handle, it->name().c_str(), it->type(), it->width(), it->decimals()); } }
OGRLayer * OGRShapeDataSource::CreateLayer( const char * pszLayerName, OGRSpatialReference *poSRS, OGRwkbGeometryType eType, char ** papszOptions ) { SHPHandle hSHP; DBFHandle hDBF; int nShapeType; /* -------------------------------------------------------------------- */ /* Verify we are in update mode. */ /* -------------------------------------------------------------------- */ if( !bDSUpdate ) { CPLError( CE_Failure, CPLE_NoWriteAccess, "Data source %s opened read-only.\n" "New layer %s cannot be created.\n", pszName, pszLayerName ); return NULL; } /* -------------------------------------------------------------------- */ /* Figure out what type of layer we need. */ /* -------------------------------------------------------------------- */ if( eType == wkbUnknown || eType == wkbLineString ) nShapeType = SHPT_ARC; else if( eType == wkbPoint ) nShapeType = SHPT_POINT; else if( eType == wkbPolygon ) nShapeType = SHPT_POLYGON; else if( eType == wkbMultiPoint ) nShapeType = SHPT_MULTIPOINT; else if( eType == wkbPoint25D ) nShapeType = SHPT_POINTZ; else if( eType == wkbLineString25D ) nShapeType = SHPT_ARCZ; else if( eType == wkbMultiLineString ) nShapeType = SHPT_ARC; else if( eType == wkbMultiLineString25D ) nShapeType = SHPT_ARCZ; else if( eType == wkbPolygon25D ) nShapeType = SHPT_POLYGONZ; else if( eType == wkbMultiPolygon ) nShapeType = SHPT_POLYGON; else if( eType == wkbMultiPolygon25D ) nShapeType = SHPT_POLYGONZ; else if( eType == wkbMultiPoint25D ) nShapeType = SHPT_MULTIPOINTZ; else if( eType == wkbNone ) nShapeType = SHPT_NULL; else nShapeType = -1; /* -------------------------------------------------------------------- */ /* Has the application overridden this with a special creation */ /* option? */ /* -------------------------------------------------------------------- */ const char *pszOverride = CSLFetchNameValue( papszOptions, "SHPT" ); if( pszOverride == NULL ) /* ignore */; else if( EQUAL(pszOverride,"POINT") ) { nShapeType = SHPT_POINT; eType = wkbPoint; } else if( EQUAL(pszOverride,"ARC") ) { nShapeType = SHPT_ARC; eType = wkbLineString; } else if( EQUAL(pszOverride,"POLYGON") ) { nShapeType = SHPT_POLYGON; eType = wkbPolygon; } else if( EQUAL(pszOverride,"MULTIPOINT") ) { nShapeType = SHPT_MULTIPOINT; eType = wkbMultiPoint; } else if( EQUAL(pszOverride,"POINTZ") ) { nShapeType = SHPT_POINTZ; eType = wkbPoint25D; } else if( EQUAL(pszOverride,"ARCZ") ) { nShapeType = SHPT_ARCZ; eType = wkbLineString25D; } else if( EQUAL(pszOverride,"POLYGONZ") ) { nShapeType = SHPT_POLYGONZ; eType = wkbPolygon25D; } else if( EQUAL(pszOverride,"MULTIPOINTZ") ) { nShapeType = SHPT_MULTIPOINTZ; eType = wkbMultiPoint25D; } else if( EQUAL(pszOverride,"NONE") ) { nShapeType = SHPT_NULL; } else { CPLError( CE_Failure, CPLE_NotSupported, "Unknown SHPT value of `%s' passed to Shapefile layer\n" "creation. Creation aborted.\n", pszOverride ); return NULL; } if( nShapeType == -1 ) { CPLError( CE_Failure, CPLE_NotSupported, "Geometry type of `%s' not supported in shapefiles.\n" "Type can be overridden with a layer creation option\n" "of SHPT=POINT/ARC/POLYGON/MULTIPOINT/POINTZ/ARCZ/POLYGONZ/MULTIPOINTZ.\n", OGRGeometryTypeToName(eType) ); return NULL; } /* -------------------------------------------------------------------- */ /* What filename do we use, excluding the extension? */ /* -------------------------------------------------------------------- */ char *pszBasename; if( bSingleNewFile && nLayers == 0 ) { char *pszPath = CPLStrdup(CPLGetPath(pszName)); char *pszFBasename = CPLStrdup(CPLGetBasename(pszName)); pszBasename = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL)); CPLFree( pszFBasename ); CPLFree( pszPath ); } else if( bSingleNewFile ) { char *pszPath = CPLStrdup(CPLGetPath(pszName)); pszBasename = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL)); CPLFree( pszPath ); } else pszBasename = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL)); /* -------------------------------------------------------------------- */ /* Create the shapefile. */ /* -------------------------------------------------------------------- */ char *pszFilename; if( nShapeType != SHPT_NULL ) { pszFilename = CPLStrdup(CPLFormFilename( NULL, pszBasename, "shp" )); hSHP = SHPCreate( pszFilename, nShapeType ); if( hSHP == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open Shapefile `%s'.\n", pszFilename ); CPLFree( pszFilename ); CPLFree( pszBasename ); return NULL; } CPLFree( pszFilename ); } else hSHP = NULL; /* -------------------------------------------------------------------- */ /* Create a DBF file. */ /* -------------------------------------------------------------------- */ pszFilename = CPLStrdup(CPLFormFilename( NULL, pszBasename, "dbf" )); hDBF = DBFCreate( pszFilename ); if( hDBF == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open Shape DBF file `%s'.\n", pszFilename ); CPLFree( pszFilename ); CPLFree( pszBasename ); return NULL; } CPLFree( pszFilename ); /* -------------------------------------------------------------------- */ /* Create the .prj file, if required. */ /* -------------------------------------------------------------------- */ if( poSRS != NULL ) { char *pszWKT = NULL; CPLString osPrjFile = CPLFormFilename( NULL, pszBasename, "prj"); FILE *fp; /* the shape layer needs it's own copy */ poSRS = poSRS->Clone(); poSRS->morphToESRI(); if( poSRS->exportToWkt( &pszWKT ) == OGRERR_NONE && (fp = VSIFOpen( osPrjFile, "wt" )) != NULL ) { VSIFWrite( pszWKT, strlen(pszWKT), 1, fp ); VSIFClose( fp ); } CPLFree( pszWKT ); poSRS->morphFromESRI(); } /* -------------------------------------------------------------------- */ /* Create the layer object. */ /* -------------------------------------------------------------------- */ OGRShapeLayer *poLayer; poLayer = new OGRShapeLayer( pszBasename, hSHP, hDBF, poSRS, TRUE, eType ); poLayer->InitializeIndexSupport( pszBasename ); CPLFree( pszBasename ); /* -------------------------------------------------------------------- */ /* Add layer to data source layer list. */ /* -------------------------------------------------------------------- */ papoLayers = (OGRShapeLayer **) CPLRealloc( papoLayers, sizeof(OGRShapeLayer *) * (nLayers+1) ); papoLayers[nLayers++] = poLayer; return poLayer; }
static void write_shapefile (local_data_t *local_data) { guint npolys; char *shape_filename; SHPHandle shape_file = NULL; SHPObject *shape; double *vertex_x, *vertex_y; guint i, j; projUV p; char *dbf_filename; DBFHandle dbf_file = NULL; int nunits_field_index; int avg_ninfected_field_index; int avg_ndestroyed_field_index; int avg_nvaccinated_field_index; int avg_frinfected_field_index; int avg_frdestroyed_field_index; int avg_frvaccinated_field_index; #if DEBUG g_debug ("----- ENTER write_shapefile (%s)", MODEL_NAME); #endif vertex_x = g_new (double, local_data->max_nvertices); vertex_y = g_new (double, local_data->max_nvertices); /* We are going to write 2 files: the .shp file, containing the geometry of * the polygons, and the .dbf file, containing the numeric attributes * attached to the polygons. */ shape_filename = g_strdup_printf ("%s.shp", local_data->base_filename); #if DEBUG g_debug ("creating new shapefile \"%s\"", shape_filename); #endif shape_file = SHPCreate (shape_filename, SHPT_POLYGON); g_assert (shape_file != NULL); npolys = local_data->polys->len; for (i = 0; i < npolys; i++) { gpc_polygon *poly; gpc_vertex_list *contour; poly = (gpc_polygon *) g_ptr_array_index (local_data->polys, i); g_assert (poly->num_contours == 1); contour = &(poly->contour[0]); for (j = 0; j < contour->num_vertices; j++) { /* The polygon vertices are in x-y coordinates. We need to * "unproject" them back to lat-long. */ p.u = contour->vertex[j].x; p.v = contour->vertex[j].y; p = pj_inv (p, local_data->projection); vertex_x[j] = p.u * RAD_TO_DEG; vertex_y[j] = p.v * RAD_TO_DEG; } shape = SHPCreateSimpleObject (SHPT_POLYGON, j, vertex_x, vertex_y, NULL); SHPWriteObject (shape_file, -1, shape); SHPDestroyObject (shape); } if (shape_file != NULL) SHPClose (shape_file); g_free (shape_filename); /* Now the attribute file */ dbf_filename = g_strdup_printf ("%s.dbf", local_data->base_filename); #if DEBUG g_debug ("creating new attributes file \"%s\"", dbf_filename); #endif dbf_file = DBFCreate (dbf_filename); g_assert (dbf_file != NULL); /* Add attribute definitions. */ #if DEBUG g_debug ("adding field definitions to DBF file \"%s\": nunits, avgninf, avgndest, avgnvacc, avgfrinf, avgfrdest, avgfrvacc", dbf_filename); #endif /* 9-digit integers should be enough to count # of units in a polygon. */ nunits_field_index = DBFAddField (dbf_file, "nunits", FTInteger, 9, 0); /* 1 decimal place for average # of units infected or destroyed, 3 for * average fraction of units. */ avg_ninfected_field_index = DBFAddField (dbf_file, "avgninf", FTDouble, 9, 1); avg_ndestroyed_field_index = DBFAddField (dbf_file, "avgndest", FTDouble, 9, 1); avg_nvaccinated_field_index = DBFAddField (dbf_file, "avgnvacc", FTDouble, 9, 1); avg_frinfected_field_index = DBFAddField (dbf_file, "avgfrinf", FTDouble, 9, 3); avg_frdestroyed_field_index = DBFAddField (dbf_file, "avgfrdest", FTDouble, 9, 3); avg_frvaccinated_field_index = DBFAddField (dbf_file, "avgfrvacc", FTDouble, 9, 3); /* Write the attributes to the file. */ #if DEBUG g_debug ("writing attributes to \"%s\"", dbf_filename); #endif for (i = 0; i < npolys; i++) { guint nunits; /* Divide the counts by the number of runs to get the mean */ local_data->ninfected[i] /= local_data->nruns; local_data->ndestroyed[i] /= local_data->nruns; local_data->nvaccinated[i] /= local_data->nruns; nunits = local_data->unit_count[i]; DBFWriteIntegerAttribute (dbf_file, i, nunits_field_index, nunits); DBFWriteDoubleAttribute (dbf_file, i, avg_ninfected_field_index, local_data->ninfected[i]); DBFWriteDoubleAttribute (dbf_file, i, avg_ndestroyed_field_index, local_data->ndestroyed[i]); DBFWriteDoubleAttribute (dbf_file, i, avg_nvaccinated_field_index, local_data->nvaccinated[i]); DBFWriteDoubleAttribute (dbf_file, i, avg_frinfected_field_index, local_data->ninfected[i] / nunits); DBFWriteDoubleAttribute (dbf_file, i, avg_frdestroyed_field_index, local_data->ndestroyed[i] / nunits); DBFWriteDoubleAttribute (dbf_file, i, avg_frvaccinated_field_index, local_data->nvaccinated[i] / nunits); } if (dbf_file != NULL) DBFClose (dbf_file); g_free (dbf_filename); /* Clean up. */ g_free (vertex_y); g_free (vertex_x); #if DEBUG g_debug ("----- EXIT write_shapefile (%s)", MODEL_NAME); #endif return; }
/** * Vectoriza todos los trazos de una imagen binaria. Los trazos deben estar completamente adelgazados * @param imgBase Imagen binaria CV_8U * @param filename Nombre del archivo de salida (sin extensión) * @param deltaRDP Delta de reducción de puntos Ramen-Douglas-Peucker, entre más grande más agresivo, en 0 no se hace reducción de puntos (valores ejemplo: 0.5, 1, 2...) * @param suavizado Nivel de suavizado con interpolación spline Catmull-Rom, en 0 no se suavizan los trazos (valores ejemplo: 0, 1, 2, 4...) */ void vect::execVectorize(Mat &imgBase, const char *filename, float deltaRDP, short int suavizado, InfoMapa *iMapa) { SHPHandle sh = SHPCreate(filename, SHPT_ARC); DBFHandle dbf = DBFCreate(filename); int res = DBFAddField(dbf,"T_ALT", FTDouble, 12, 4); DBFClose(dbf); DBFHandle hDBF = DBFOpen(filename,"rb+"); cout<<res<<",,,,,,,,,,,,,,,,,,,,,,,"<<endl; int imgAncho = imgBase.cols; int imgAlto = imgBase.rows; Point pA = Point(iMapa->recXmin,iMapa->recYmin); cout<<"XMIN"<<iMapa->recXmin<<endl; cout<<"YMIN"<<iMapa->recYmin<<endl; /* Point pA = Point(492, 372); iMapa->setCoordsPuntosRef(1060000, 770000, 1075000, 770000, 1075000, 760000, 1060000, 760000); iMapa->setPosPuntosRef(522, 371,9957, 475, 9882, 6799, 453, 6701); */ transformGeo *objGeo = new transformGeo(); objGeo->setCoeficients(iMapa); // recorremos toda la imagen buscando puntos finales int altop = 0; vector<Point> punFinales; vect::puntosFinales(imgBase, punFinales); // para cada punto final, recorremos el trazo correspondiente y guardamos el vector Point pun; vector<Point2f> trazo; vector<Point2f> trazoSuave; for(vector<Point>::iterator it = punFinales.begin(); it != punFinales.end(); ++it) { pun = *it; cout << "recorrerTrazo() " << pun << endl; recorrerTrazo(imgBase, pun, trazo, false); if (trazo.size() > 1) { vec_RDP::reducirPuntos(trazo, deltaRDP); // aplicamos reducción de puntos Ramer-Douglas-Peucker catmull::interpolar(trazo, trazoSuave, suavizado); agregarShape(((suavizado > 0) ? trazoSuave : trazo), altop, sh, objGeo, pA, hDBF); } } // Buscamos en toda la imagen, si aún hay pixeles sin borrar, son de trayectos cerrados unsigned int x, y; uchar* fila; uchar intensidad; for (y = 1 ; y < (imgAlto - 1) ; ++y) { fila = imgBase.ptr<uchar>(y); for (x = 1 ; x < (imgAncho - 1) ; ++x) { intensidad = fila[x]; if (intensidad == 0) { pun = Point(x, y); recorrerTrazo(imgBase, pun, trazo, true); if (trazo.size() > 1) { vec_RDP::reducirPuntos(trazo, deltaRDP); // aplicamos reducción de puntos Ramer-Douglas-Peucker catmull::interpolar(trazo, trazoSuave, suavizado); agregarShape(((suavizado > 0) ? trazoSuave : trazo), imgAlto, sh, objGeo, pA, hDBF); } } } } DBFClose(hDBF); SHPClose(sh); }
void Builder::print_shpObjects() { QgsDebugMsg( QString( "Number of primitives: %1" ).arg( shpObjects.size() ) ); QgsDebugMsg( QString( "Number of text fields: %1" ).arg( textObjects.size() ) ); QgsDebugMsg( QString( "Number of inserts fields: %1" ).arg( insertObjects.size() ) ); SHPHandle hSHP; if ( fname.endsWith( ".shp", Qt::CaseInsensitive ) ) { QString fn( fname.mid( fname.length() - 4 ) ); outputdbf = fn + ".dbf"; outputshp = fn + ".shp"; outputtdbf = fn + "_texts.dbf"; outputtshp = fn + "_texts.shp"; outputidbf = fn + "_inserts.dbf"; outputishp = fn + "_inserts.shp"; } else { outputdbf = outputtdbf = outputidbf = fname + ".dbf"; outputshp = outputtshp = outputishp = fname + ".shp"; } DBFHandle dbffile = DBFCreate( outputdbf.toUtf8() ); DBFAddField( dbffile, "myid", FTInteger, 10, 0 ); hSHP = SHPCreate( outputshp.toUtf8(), shapefileType ); QgsDebugMsg( "Writing to main shp file..." ); for ( int i = 0; i < shpObjects.size(); i++ ) { SHPWriteObject( hSHP, -1, shpObjects[i] ); SHPDestroyObject( shpObjects[i] ); DBFWriteIntegerAttribute( dbffile, i, 0, i ); } SHPClose( hSHP ); DBFClose( dbffile ); QgsDebugMsg( "Done!" ); if ( !textObjects.isEmpty() ) { SHPHandle thSHP; DBFHandle Tdbffile = DBFCreate( outputtdbf.toUtf8() ); thSHP = SHPCreate( outputtshp.toUtf8(), SHPT_POINT ); DBFAddField( Tdbffile, "tipx", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tipy", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tipz", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapx", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapy", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapz", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "height", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "scale", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "flags", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "hjust", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "vjust", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "text", FTString, 50, 0 ); DBFAddField( Tdbffile, "style", FTString, 50, 0 ); DBFAddField( Tdbffile, "angle", FTDouble, 20, 10 ); QgsDebugMsg( "Writing Texts' shp File..." ); for ( int i = 0; i < textObjects.size(); i++ ) { SHPObject *psObject; double x = textObjects[i].ipx; double y = textObjects[i].ipy; double z = textObjects[i].ipz; psObject = SHPCreateObject( SHPT_POINT, i, 0, NULL, NULL, 1, &x, &y, &z, NULL ); SHPWriteObject( thSHP, -1, psObject ); DBFWriteDoubleAttribute( Tdbffile, i, 0, textObjects[i].ipx ); DBFWriteDoubleAttribute( Tdbffile, i, 1, textObjects[i].ipy ); DBFWriteDoubleAttribute( Tdbffile, i, 2, textObjects[i].ipz ); DBFWriteDoubleAttribute( Tdbffile, i, 3, textObjects[i].apx ); DBFWriteDoubleAttribute( Tdbffile, i, 4, textObjects[i].apy ); DBFWriteDoubleAttribute( Tdbffile, i, 5, textObjects[i].apz ); DBFWriteDoubleAttribute( Tdbffile, i, 6, textObjects[i].height ); DBFWriteDoubleAttribute( Tdbffile, i, 7, textObjects[i].xScaleFactor ); DBFWriteIntegerAttribute( Tdbffile, i, 8, textObjects[i].textGenerationFlags ); DBFWriteIntegerAttribute( Tdbffile, i, 9, textObjects[i].hJustification ); DBFWriteIntegerAttribute( Tdbffile, i, 10, textObjects[i].vJustification ); DBFWriteStringAttribute( Tdbffile, i, 11, textObjects[i].text.c_str() ); DBFWriteStringAttribute( Tdbffile, i, 12, textObjects[i].style.c_str() ); DBFWriteDoubleAttribute( Tdbffile, i, 13, textObjects[i].angle ); SHPDestroyObject( psObject ); } SHPClose( thSHP ); DBFClose( Tdbffile ); QgsDebugMsg( "Done!" ); } if ( !insertObjects.isEmpty() ) { SHPHandle ihSHP; DBFHandle Idbffile = DBFCreate( outputidbf.toUtf8() ); ihSHP = SHPCreate( outputishp.toUtf8(), SHPT_POINT ); DBFAddField( Idbffile, "name", FTString, 200, 0 ); DBFAddField( Idbffile, "ipx", FTDouble, 20, 10 ); DBFAddField( Idbffile, "ipy", FTDouble, 20, 10 ); DBFAddField( Idbffile, "ipz", FTDouble, 20, 10 ); DBFAddField( Idbffile, "sx", FTDouble, 20, 10 ); DBFAddField( Idbffile, "sy", FTDouble, 20, 10 ); DBFAddField( Idbffile, "sz", FTDouble, 20, 10 ); DBFAddField( Idbffile, "angle", FTDouble, 20, 10 ); DBFAddField( Idbffile, "cols", FTInteger, 20, 0 ); DBFAddField( Idbffile, "rows", FTInteger, 20, 0 ); DBFAddField( Idbffile, "colsp", FTDouble, 20, 10 ); DBFAddField( Idbffile, "rowsp", FTDouble, 20, 10 ); QgsDebugMsg( "Writing Insert' shp File..." ); for ( int i = 0; i < insertObjects.size(); i++ ) { SHPObject *psObject; double &x = insertObjects[i].ipx; double &y = insertObjects[i].ipy; double &z = insertObjects[i].ipz; psObject = SHPCreateObject( SHPT_POINT, i, 0, NULL, NULL, 1, &x, &y, &z, NULL ); SHPWriteObject( ihSHP, -1, psObject ); int c = 0; DBFWriteStringAttribute( Idbffile, i, c++, insertObjects[i].name.c_str() ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].ipx ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].ipy ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].ipz ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].sx ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].sy ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].sz ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].angle ); DBFWriteIntegerAttribute( Idbffile, i, c++, insertObjects[i].cols ); DBFWriteIntegerAttribute( Idbffile, i, c++, insertObjects[i].rows ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].colSp ); DBFWriteDoubleAttribute( Idbffile, i, c++, insertObjects[i].rowSp ); SHPDestroyObject( psObject ); } SHPClose( ihSHP ); DBFClose( Idbffile ); QgsDebugMsg( "Done!" ); } }
void Builder::print_shpObjects() { int dim = shpObjects.size(); int dimTexts = textObjects.size(); QgsDebugMsg( QString( "Number of primitives: %1" ).arg( dim ) ); QgsDebugMsg( QString( "Number of text fields: %1" ).arg( dimTexts ) ); SHPHandle hSHP; if ( fname.substr( fname.length() - 4 ).compare( ".shp" ) == 0 ) { outputdbf = fname; outputdbf = outputdbf.replace(( outputdbf.length() - 3 ), outputdbf.length(), "dbf" ); outputshp = fname; outputshp = outputshp.replace(( outputshp.length() - 3 ), outputshp.length(), "shp" ); outputtdbf = fname; outputtdbf = outputtdbf.replace(( outputtdbf.length() - 4 ), outputtdbf.length(), "_texts.dbf" ); outputtshp = fname; outputtshp = outputtshp.replace(( outputtshp.length() - 4 ), outputtshp.length(), "_texts.shp" ); } else { outputdbf = outputtdbf = fname + ".dbf"; outputshp = outputtshp = fname + ".shp"; } DBFHandle dbffile = DBFCreate( outputdbf.c_str() ); DBFAddField( dbffile, "myid", FTInteger, 10, 0 ); hSHP = SHPCreate( outputshp.c_str(), shapefileType ); QgsDebugMsg( "Writing to main shp file..." ); for ( int i = 0; i < dim; i++ ) { SHPWriteObject( hSHP, -1, shpObjects[i] ); SHPDestroyObject( shpObjects[i] ); DBFWriteIntegerAttribute( dbffile, i, 0, i ); } SHPClose( hSHP ); DBFClose( dbffile ); QgsDebugMsg( "Done!" ); if ( convertText && dimTexts > 0 ) { SHPHandle thSHP; DBFHandle Tdbffile = DBFCreate( outputtdbf.c_str() ); thSHP = SHPCreate( outputtshp.c_str(), SHPT_POINT ); DBFAddField( Tdbffile, "tipx", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tipy", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tipz", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapx", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapy", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "tapz", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "height", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "scale", FTDouble, 20, 10 ); DBFAddField( Tdbffile, "flags", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "hjust", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "vjust", FTInteger, 10, 0 ); DBFAddField( Tdbffile, "text", FTString, 50, 0 ); DBFAddField( Tdbffile, "style", FTString, 50, 0 ); DBFAddField( Tdbffile, "angle", FTDouble, 20, 10 ); QgsDebugMsg( "Writing Texts' shp File..." ); for ( int i = 0; i < dimTexts; i++ ) { SHPObject *psObject; double x = textObjects[i].ipx; double y = textObjects[i].ipy; double z = textObjects[i].ipz; psObject = SHPCreateObject( SHPT_POINT, i, 0, NULL, NULL, 1, &x, &y, &z, NULL ); SHPWriteObject( thSHP, -1, psObject ); DBFWriteDoubleAttribute( Tdbffile, i, 0, textObjects[i].ipx ); DBFWriteDoubleAttribute( Tdbffile, i, 1, textObjects[i].ipy ); DBFWriteDoubleAttribute( Tdbffile, i, 2, textObjects[i].ipz ); DBFWriteDoubleAttribute( Tdbffile, i, 3, textObjects[i].apx ); DBFWriteDoubleAttribute( Tdbffile, i, 4, textObjects[i].apy ); DBFWriteDoubleAttribute( Tdbffile, i, 5, textObjects[i].apz ); DBFWriteDoubleAttribute( Tdbffile, i, 6, textObjects[i].height ); DBFWriteDoubleAttribute( Tdbffile, i, 7, textObjects[i].xScaleFactor ); DBFWriteIntegerAttribute( Tdbffile, i, 8, textObjects[i].textGenerationFlags ); DBFWriteIntegerAttribute( Tdbffile, i, 9, textObjects[i].hJustification ); DBFWriteIntegerAttribute( Tdbffile, i, 10, textObjects[i].vJustification ); DBFWriteStringAttribute( Tdbffile, i, 11, textObjects[i].text.c_str() ); DBFWriteStringAttribute( Tdbffile, i, 12, textObjects[i].style.c_str() ); DBFWriteDoubleAttribute( Tdbffile, i, 13, textObjects[i].angle ); SHPDestroyObject( psObject ); } SHPClose( thSHP ); DBFClose( Tdbffile ); QgsDebugMsg( "Done!" ); } }
/** * Create Voronoi shape files using Triangle. * @param argc is the number of arguments provided from the command line * (including the command name). * @param argv is an array of strings that contains the argc arguments. * @return An error code if something goes wrong or 0 if there was no error * during the conversion process. * \todo Allow generation of empty report file. */ int main( int argc, char **argv ) { int error; char line[MAXLINE]; char wline[MAXLINE]; char *textpointer = NULL, *prev_textpointer = NULL; int nPolygons; int nShapeType, nEntities, nVertices, nParts, *panParts, i, j, iPart; int nNodes, nNodeRef; SHPObject *psCShape; int byRing = 1; int nPolygonPoints; char boolWriteShape; int nShapes = 0; double padfMinBound[4]; double padfMaxBound[4]; int nDcidIndex = -1; char *pDCID; strcpy(vertex_line_name, ""); num_vertices = 0; /* parameter check */ if(((argc != 3)|| ((!str_is_shp(argv[1])||(!str_is_shp(argv[2])))))) { printf("shpvoronoi 0.1.0 (c) 2005 Steffen Macke\n"); printf("usage: shpvoronoi input_shapefile voronoi_shapefile\n"); exit(1); } remove_shp(argv[2]); hPointSHP = SHPOpen(argv[1], "rb" ); hPointDBF = DBFOpen(argv[1], "rb"); if(hPointSHP == NULL || hPointDBF == NULL ) { printf("FATAL ERROR: Unable to open input file:%s\n", argv[1] ); exit(1); } nDcidIndex = DBFGetFieldIndex(hPointDBF, "dc_id"); if(nDcidIndex == -1) { printf("FATAL ERROR: Shapefile:%s is lacking the 'dc_id field.'\n", argv[1]); SHPClose(hPointSHP); DBFClose(hPointDBF); exit(1); } SHPGetInfo(hPointSHP, &nEntities, &nShapeType, padfMinBound, padfMaxBound); if(nShapeType != SHPT_POINT) { printf("FATAL ERROR: Input is not a point shapefile:%s\n", argv[1]); SHPClose(hPointSHP); DBFClose(hPointDBF); exit(1); } if(nEntities > MAXNUMNODES) { printf("FATAL ERROR: Too many nodes. Please recompile.\n"); SHPClose(hPointSHP); DBFClose(hPointDBF); exit(1); } /** * \todo Dynamic filename */ hTextFile = fopen("shptriangle.node", "wt"); if(hTextFile == NULL) { printf("FATAL ERROR: Cannot open output file:%s\n", "shptriangle.node"); SHPClose(hPointSHP); DBFClose(hPointDBF); exit(1); } fprintf(hTextFile, "2\n%d\n", nEntities+4); for(i=0; i<nEntities;i++) { psCShape = SHPReadObject(hPointSHP, i); fprintf(hTextFile, "%f %f\n", psCShape->dfXMin, psCShape->dfYMin); } fprintf(hTextFile, "%f %f\n", padfMinBound[0]-dBuffer, padfMinBound[1]-dBuffer); fprintf(hTextFile, "%f %f\n", padfMinBound[0]-dBuffer, padfMaxBound[1]+dBuffer); fprintf(hTextFile, "%f %f\n", padfMaxBound[0]+dBuffer, padfMaxBound[1]+dBuffer); fprintf(hTextFile, "%f %f\n", padfMaxBound[0]+dBuffer, padfMinBound[1]-dBuffer); fclose(hTextFile); SHPClose(hPointSHP); DBFClose(hPointDBF); system("qvoronoi.exe o < shptriangle.node > shptriangle.off"); hTextFile = fopen("shptriangle.off", "rt"); if(hTextFile == NULL) { printf("FATAL ERROR: Cannot open input file:%s\n", "shptriangle.off"); exit(1); } if(fgets(line, MAXLINE, hTextFile) == NULL) { printf("FATAL ERROR reading first line of shptriangle.off\n"); fclose(hTextFile); exit(1); } i = atoi(line); if(i != 2) { printf("FATAL ERROR: Wrong dimension in first line of shptriangle.off\n"); fclose(hTextFile); exit(1); } if(fgets(line, MAXLINE, hTextFile) == NULL) { printf("FATAL ERROR reading second line of shptriangle.off\n"); fclose(hTextFile); exit(1); } //printf("%s\n", line); num_vertices = atoi(line); if(num_vertices > MAXNUMNODES) { printf("FATAL ERROR: Too many nodes, please recompile: %d\n", num_vertices); fclose(hTextFile); exit(1); } //printf("%d nodes\n", num_vertices); textpointer = strchr(line, ' '); nPolygons = atoi(textpointer); //printf("%d polygons\n", nPolygons); /** * Build node list */ for(i=0; i < num_vertices; i++) { if(fgets(line, MAXLINE, hTextFile) == NULL) { printf("FATAL ERROR: shptriangle.off does not contain enough nodes.\n"); fclose(hTextFile); exit(1); } node_x[i] = atof(line); textpointer = strchr(line, ' '); node_y[i] = atof(textpointer); //printf("Vertex %d %f %f\n", i, node_x[i], node_y[i]); } hVoronoiSHP = SHPCreate(argv[2], SHPT_POLYGON); hVoronoiDBF = DBFCreate(argv[2]); hPointDBF = DBFOpen(argv[1], "rb"); if(hVoronoiSHP == NULL || hVoronoiDBF == NULL || hPointDBF == NULL) { fprintf(stderr, "FATAL ERROR: Unable to create file '%s'.\n", argv[2]); fclose(hTextFile); exit(1); } DBFAddField(hVoronoiDBF, "dc_id", FTString, 16, 0); for(i=0; i < nPolygons; i++) { //printf("Polygon %d\n", i); if(fgets(line, MAXLINE, hTextFile) == NULL) { printf("FATAL ERROR: shptriangle.off does not contain enough polygons.\n"); SHPClose(hVoronoiSHP); DBFClose(hVoronoiDBF); DBFClose(hPointDBF); fclose(hTextFile); exit(1); } nNodes = 0; nPolygonPoints = atoi(line); //printf("Polygon Point Count: %d\n", nPolygonPoints); if((nPolygonPoints < 0)||(nPolygonPoints > num_vertices)) { printf("FATAL ERROR: shptriangle.off contains illegal point count.\n"); SHPClose(hVoronoiSHP); DBFClose(hVoronoiDBF); DBFClose(hPointDBF); fclose(hTextFile); exit(1); } textpointer = line; boolWriteShape = 1; for(j=0; j < nPolygonPoints; j++) { textpointer = strchr(textpointer+1, ' '); nNodes++; nNodeRef = atoi(textpointer); if((nNodeRef < 0)||(nNodeRef > num_vertices)) { printf("FATAL ERROR: shptriangle.off contains illegal node reference.\n"); SHPClose(hVoronoiSHP); DBFClose(hVoronoiDBF); DBFClose(hPointDBF); fclose(hTextFile); exit(1); } /** * Don't write boundary shapes */ if(nNodeRef == 0) { boolWriteShape = 0; break; } //printf("Node reference %d\n", nNodeRef); polygon_x[nNodes-1] = node_x[nNodeRef]; polygon_y[nNodes-1] = node_y[nNodeRef]; } if(boolWriteShape == 1) { nNodes++; polygon_x[nNodes-1] = polygon_x[0]; polygon_y[nNodes-1] = polygon_y[0]; //printf("Polygon %d with %d nodes\n", i, nNodes); psCShape = SHPCreateSimpleObject( SHPT_POLYGON, nNodes, polygon_x, polygon_y, NULL ); SHPWriteObject(hVoronoiSHP, -1, psCShape); SHPDestroyObject(psCShape); /** * Take over DC_ID field. */ if(nShapes < nEntities) { pDCID = DBFReadStringAttribute(hPointDBF, nShapes, nDcidIndex); DBFWriteStringAttribute(hVoronoiDBF, nShapes, 0, pDCID); } else { DBFWriteStringAttribute(hVoronoiDBF, nShapes, 0, ""); } nShapes++; } } SHPClose(hVoronoiSHP); DBFClose(hVoronoiDBF); DBFClose(hPointDBF); fclose(hTextFile); }
static void WriteAttributeDBF( const char * pszShapefile, SDTSTransfer * poTransfer, const char * pszMODN ) { SDTSAttrReader *poAttrReader; /* -------------------------------------------------------------------- */ /* Fetch a reference to the indexed Pointgon reader. */ /* -------------------------------------------------------------------- */ poAttrReader = (SDTSAttrReader *) poTransfer->GetLayerIndexedReader( poTransfer->FindLayer( pszMODN ) ); if( poAttrReader == NULL ) { fprintf( stderr, "Failed to open %s.\n", poTransfer->GetCATD()->GetModuleFilePath( pszMODN ) ); return; } poAttrReader->Rewind(); /* -------------------------------------------------------------------- */ /* Create the database file, and our basic set of attributes. */ /* -------------------------------------------------------------------- */ DBFHandle hDBF; char szDBFFilename[1024]; sprintf( szDBFFilename, "%s.dbf", pszShapefile ); hDBF = DBFCreate( szDBFFilename ); if( hDBF == NULL ) { fprintf( stderr, "Unable to create shapefile .dbf for `%s'\n", pszShapefile ); return; } DBFAddField( hDBF, "SDTSRecId", FTInteger, 8, 0 ); /* -------------------------------------------------------------------- */ /* Prepare the schema. */ /* -------------------------------------------------------------------- */ char **papszMODNList = CSLAddString( NULL, pszMODN ); AddPrimaryAttrToDBFSchema( hDBF, poTransfer, papszMODNList ); CSLDestroy( papszMODNList ); /* ==================================================================== */ /* Process all the records in the module. */ /* ==================================================================== */ SDTSAttrRecord *poRecord; int iRecord = 0; while((poRecord = (SDTSAttrRecord*)poAttrReader->GetNextFeature()) != NULL) { DBFWriteIntegerAttribute( hDBF, iRecord, 0, poRecord->oModId.nRecord ); WriteAttrRecordToDBF( hDBF, iRecord, poTransfer, poRecord->poATTR ); if( !poAttrReader->IsIndexed() ) delete poRecord; iRecord++; } /* -------------------------------------------------------------------- */ /* Close, and cleanup. */ /* -------------------------------------------------------------------- */ DBFClose( hDBF ); }
bool _pnts_save_shp(const d_points * pnts, const char * filename) { if (!pnts) { writelog(LOG_WARNING, "NULL pointer to points."); return false; }; DBFHandle hDBF; SHPHandle hSHP; hSHP = SHPOpen( filename, "rb+" ); hDBF = DBFOpen( filename, "rb+" ); if (hSHP == NULL || hDBF == NULL) { if (hSHP) SHPClose( hSHP ); if (hDBF) DBFClose( hDBF ); hSHP = SHPCreate( filename, SHPT_POINT ); if( hSHP == NULL ) { writelog(LOG_ERROR, "Unable to create:%s", filename ); return false; } hDBF = DBFCreate( filename ); } int shpType; SHPGetInfo(hSHP, NULL, &shpType, NULL, NULL); if (shpType != SHPT_POINT) { writelog(LOG_ERROR, "%s : Wrong shape type!", filename); SHPClose( hSHP ); DBFClose( hDBF ); return false; } int name_field = DBFGetFieldIndex( hDBF, "NAME" ); int val_field = DBFGetFieldIndex( hDBF, "VALUE" ); if (name_field == -1) { if( DBFAddField( hDBF, "NAME", FTString, 50, 0 ) == -1 ) { writelog(LOG_ERROR, "DBFAddField(%s,FTString) failed.", "NAME"); SHPClose( hSHP ); DBFClose( hDBF ); return false; } name_field = DBFGetFieldIndex( hDBF, "NAME" ); } if (val_field == -1) { if( DBFAddField( hDBF, "VALUE", FTDouble, 50, 0 ) == -1 ) { writelog(LOG_ERROR, "DBFAddField(%s,FTString) failed.", "VALUE"); SHPClose( hSHP ); DBFClose( hDBF ); return false; } val_field = DBFGetFieldIndex( hDBF, "VALUE" ); } char buf[1024]; size_t i; for (i = 0; i < pnts->size(); i++) { double x = (*(pnts->X))(i); double y = (*(pnts->Y))(i); SHPObject * psObject = SHPCreateObject(SHPT_POINT, -1, 0, NULL, NULL, 1, &x, &y, NULL, NULL); SHPComputeExtents(psObject); int pos = SHPWriteObject(hSHP, -1, psObject); SHPDestroyObject(psObject); if (pnts->names) DBFWriteStringAttribute(hDBF, pos, name_field, (*(pnts->names))(i) ); else { sprintf(buf,"%d",(int)i); DBFWriteStringAttribute(hDBF, pos, name_field, buf ); } REAL val = (*(pnts->Z))(i); DBFWriteDoubleAttribute(hDBF, pos, val_field, val); } SHPClose( hSHP ); DBFClose( hDBF ); return true; };
int main( int argc, char ** argv ) { DBFHandle hDBF; int i; /* -------------------------------------------------------------------- */ /* Display a usage message. */ /* -------------------------------------------------------------------- */ if( argc < 2 ) { printf( "dbfcreate xbase_file [[-s field_name width],[-n field_name width decimals]]...\n" ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Create the database. */ /* -------------------------------------------------------------------- */ hDBF = DBFCreate( argv[1] ); if( hDBF == NULL ) { printf( "DBFCreate(%s) failed.\n", argv[1] ); exit( 2 ); } /* -------------------------------------------------------------------- */ /* Loop over the field definitions adding new fields. */ /* -------------------------------------------------------------------- */ for( i = 2; i < argc; i++ ) { if( strcmp(argv[i],"-s") == 0 && i < argc-2 ) { if( DBFAddField( hDBF, argv[i+1], FTString, atoi(argv[i+2]), 0 ) == -1 ) { printf( "DBFAddField(%s,FTString,%d,0) failed.\n", argv[i+1], atoi(argv[i+2]) ); exit( 4 ); } i = i + 2; } else if( strcmp(argv[i],"-n") == 0 && i < argc-3 ) { if( DBFAddField( hDBF, argv[i+1], FTDouble, atoi(argv[i+2]), atoi(argv[i+3]) ) == -1 ) { printf( "DBFAddField(%s,FTDouble,%d,%d) failed.\n", argv[i+1], atoi(argv[i+2]), atoi(argv[i+3]) ); exit( 4 ); } i = i + 3; } else { printf( "Argument incomplete, or unrecognised:%s\n", argv[i] ); exit( 3 ); } } DBFClose( hDBF ); return( 0 ); }
void shape_ursa_init(char *inFile, char *header) { char *dbaseFile; DBFHandle dbase; SHPHandle shape; dbf_header_t *dbf; int ii, nCols, length=50; // Read configuration file read_header_config("URSA", &dbf, &nCols); // Open database for initialization dbaseFile = appendExt(inFile, ".dbf"); dbase = DBFCreate(dbaseFile); if (!dbase) asfPrintError("Could not create database file '%s'\n", dbaseFile); // Add fields to database for (ii=0; ii<nCols; ii++) { if (strcmp(dbf[ii].header, "Granule_Name") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "GRAN_NAME", FTString, length, 0) == -1) asfPrintError("Could not add GRAN_NAME field to database file\n"); } else if (strcmp(dbf[ii].header, "Granule_Type") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "GRAN_TYPE", FTString, length, 0) == -1) asfPrintError("Could not add GRAN_TYPE field to database file\n"); } else if (strcmp(dbf[ii].header, "Platform") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PLATFORM", FTString, length, 0) == -1) asfPrintError("Could not add PLATFORM field to database file\n"); } else if (strcmp(dbf[ii].header, "Sensor") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "SENSOR", FTString, length, 0) == -1) asfPrintError("Could not add SENSOR field to database file\n"); } else if (strcmp(dbf[ii].header, "Orbit") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "ORBIT", FTInteger, 7, 0) == -1) asfPrintError("Could not add ORBIT field to database file\n"); } else if (strcmp(dbf[ii].header, "Beam_Mode") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "BEAM_MODE", FTString, length, 0) == -1) asfPrintError("Could not add BEAM_MODE field to database file\n"); } else if (strcmp(dbf[ii].header, "Off_Nadir_Angle") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "OFF_NADIR", FTDouble, 16, 4) == -1) asfPrintError("Could not add OFF_NADIR field to database file\n"); } else if (strcmp(dbf[ii].header, "Start_Time") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "START_TIME", FTString, length, 0) == -1) asfPrintError("Could not add START_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "End_Time") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "END_TIME", FTString, length, 0) == -1) asfPrintError("Could not add END_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_Start_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "NSTART_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add NSTART_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_Start_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "NSTART_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add NSTART_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_Start_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FSTART_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add FSTART_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_Start_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FSTART_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add FSTART_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_End_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "N_END_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add N_END_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_End_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "N_END_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add N_END_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_End_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "F_END_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add F_END_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_End_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "F_END_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add F_END_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Center_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "CENTER_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add CENTER_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Center_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "CENTER_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add CENTER_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Path_Number") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PATH_NUM", FTInteger, 10, 0) == -1) asfPrintError("Could not add PATH_NUM field to database file\n"); } else if (strcmp(dbf[ii].header, "Frame_Number") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FRAME_NUM", FTInteger, 10, 0) == -1) asfPrintError("Could not add FRAME_NUM field to database file\n"); } else if (strcmp(dbf[ii].header, "Cloud_Cover") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "CLOUDCOVER", FTInteger, 5, 0) == -1) asfPrintError("Could not add CLOUDCOVER field to database file\n"); } else if (strcmp(dbf[ii].header, "Faraday_Rotation") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FARADAYROT", FTDouble, 16, 1) == -1) asfPrintError("Could not add FARADAYROT field to database file\n"); } } // Close the database for initialization DBFClose(dbase); // Open shapefile for initialization shape = SHPCreate(inFile, SHPT_POLYGON); if (!shape) asfPrintError("Could not create shapefile '%s'\n", inFile); // Close shapefile for initialization SHPClose(shape); FREE(dbaseFile); return; }
void openfiles() { /* -------------------------------------------------------------------- */ /* Open the DBF file. */ /* -------------------------------------------------------------------- */ setext(infile, "dbf"); hDBF = DBFOpen( infile, "rb" ); if( hDBF == NULL ) { printf( "ERROR: Unable to open the input DBF:%s\n", infile ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Open the append DBF file. */ /* -------------------------------------------------------------------- */ if (strcmp(outfile,"")) { setext(outfile, "dbf"); hDBFappend = DBFOpen( outfile, "rb+" ); newdbf=0; if( hDBFappend == NULL ) { newdbf=1; hDBFappend = DBFCreate( outfile ); if( hDBFappend == NULL ) { printf( "ERROR: Unable to open the append DBF:%s\n", outfile ); exit( 1 ); } } } /* -------------------------------------------------------------------- */ /* Open the passed shapefile. */ /* -------------------------------------------------------------------- */ setext(infile, "shp"); hSHP = SHPOpen( infile, "rb" ); if( hSHP == NULL ) { printf( "ERROR: Unable to open the input shape file:%s\n", infile ); exit( 1 ); } SHPGetInfo( hSHP, &nEntities, &nShapeType, NULL, NULL ); /* -------------------------------------------------------------------- */ /* Open the passed append shapefile. */ /* -------------------------------------------------------------------- */ if (strcmp(outfile,"")) { setext(outfile, "shp"); hSHPappend = SHPOpen( outfile, "rb+" ); if( hSHPappend == NULL ) { hSHPappend = SHPCreate( outfile, nShapeType ); if( hSHPappend == NULL ) { printf( "ERROR: Unable to open the append shape file:%s\n", outfile ); exit( 1 ); } } SHPGetInfo( hSHPappend, &nEntitiesAppend, &nShapeTypeAppend, NULL, NULL ); if (nShapeType != nShapeTypeAppend) { puts( "ERROR: Input and Append shape files are of different types."); exit( 1 ); } } }
void shapefileClip::CreateShapeFile(vector<ossimPolygon> &polys, const char *shapeFilename) { if (polys.empty()) { cerr << "The polygons do not exist...cannot create shape file" << endl << "Line: " << __LINE__ << " " << __FILE__ << endl; return; } SHPObject *psObject; SHPHandle hSHP; double *px, *py; vector<ossimPolygon>::iterator polyIter; vector<ossimDpt> vertices; vector<ossimDpt>::iterator vertIter; hSHP = SHPCreate(shapeFilename, SHPT_POLYGON); if( hSHP == NULL || shapeFilename == NULL) { cerr << "Unable to create: " << shapeFilename << endl << "Line: " << __LINE__ << " " << __FILE__ << endl; exit(EXIT_FAILURE); } // Build DBF. DBFHandle hDBF; hDBF = DBFCreate(shapeFilename); if( hDBF == NULL) { cerr << "Unable to create: " << shapeFilename << " DBF File" << endl << "Line: " << __LINE__ << " " << __FILE__ << endl; exit(EXIT_FAILURE); } // Add fields. DBFAddField(hDBF, "poly_num", FTString, 30, 0); polyIter = polys.begin(); int arrayIndex; int poly_num = 0; while (polyIter != polys.end()) { DBFWriteStringAttribute(hDBF, poly_num, 0, ossimString::toString(poly_num)); vertices = (*polyIter).getVertexList(); vertIter = vertices.begin(); double *x = new double[vertices.size()]; double *y = new double[vertices.size()]; int *panParts = new int[vertices.size()]; panParts[0] = 0; // SHPCreateObject deletes these px = &x[0]; py = &y[0]; arrayIndex = 0; while (vertIter != vertices.end()) { x[arrayIndex] = (*vertIter).x; y[arrayIndex++] = (*vertIter).y; vertIter++; } psObject = SHPCreateObject( SHPT_POLYGON, -1, 1, panParts, NULL, vertices.size(), px, py, NULL, NULL ); if (psObject != NULL) { SHPWriteObject( hSHP, -1, psObject ); SHPDestroyObject( psObject ); } else { cerr << "Shape object could not be written to file" << endl << "Line: " << __LINE__ << " " << __FILE__ << endl; SHPClose(hSHP); delete []x; delete []y; delete [] panParts; exit(EXIT_FAILURE); } polyIter++; poly_num++; delete []x; delete []y; delete [] panParts; } DBFClose(hDBF); SHPClose( hSHP ); }
char* darxen_shapefiles_filter_shp(DarxenShapefile* shapefile, int dataLevel, const char* site, float latCenter, float lonCenter, float radius) { GSList* lstNewDBFs = NULL; GSList* lstNewSHPs = NULL; DBFHandle hDBF; SHPHandle hSHP; SHPHandle hNewSHP = NULL; DBFHandle hNewDBF = NULL; int pnEntities; int pnShapeType; int i; SHPObject *psObject = NULL; char* filteredPath; g_assert(shapefile->file); g_assert(!shapefile->dataLevels || shapefile->dataLevels->field); g_assert(!shapefile->dataLevels || (dataLevel >= 0 && dataLevel < g_slist_length(shapefile->dataLevels->levels))); gchar* gfilteredFile; if (shapefile->dataLevels) gfilteredFile = g_strdup_printf("%s_%s_%i", shapefile->file, site, dataLevel); else gfilteredFile = g_strdup_printf("%s_%s", shapefile->file, site); gchar* gfilteredPath = g_build_filename(darxen_file_support_get_app_path(), "shapefiles", "cache", gfilteredFile, NULL); filteredPath = strdup(gfilteredPath); g_free(gfilteredFile); g_free(gfilteredPath); //don't recreate the file, just return the path gchar* shpFile = g_strdup_printf("%s.shp", filteredPath); gchar* dbfFile = g_strdup_printf("%s.dbf", filteredPath); if (g_file_test(shpFile, G_FILE_TEST_EXISTS) && g_file_test(dbfFile, G_FILE_TEST_EXISTS)) { g_free(shpFile); g_free(dbfFile); return filteredPath; } g_free(shpFile); g_free(dbfFile); gchar* pathPart = g_strdup_printf("%s.shp", shapefile->file); gchar* pathPart2 = g_build_filename("shapefiles", pathPart, NULL); gchar* shapefilePath = darxen_file_support_get_overridable_file_path(pathPart2); //g_build_filename(darxen_file_support_get_app_path(), "shapefiles", shapefile->file, NULL); g_free(pathPart); g_free(pathPart2); g_assert(shapefilePath); shapefilePath[strlen(shapefilePath)-4] = '\0'; hSHP = SHPOpen(shapefilePath, "rb"); if (!hSHP) { g_free(shapefilePath); g_critical("Invalid shapefile path: %s", shapefile->file); return NULL; } hDBF = DBFOpen(shapefilePath, "rb"); if (!hDBF) { g_free(shapefilePath); g_critical("Invalid shapefile dbf path: %s", shapefile->file); return NULL; } g_free(shapefilePath); int dbfCount = DBFGetRecordCount(hDBF); SHPGetInfo(hSHP, &pnEntities, &pnShapeType, NULL, NULL); if (dbfCount != pnEntities) { g_critical("dbf and shp have a differing number of records!"); SHPClose(hSHP); DBFClose(hDBF); return NULL; } if (shapefile->dataLevels) { GSList* pLevel = shapefile->dataLevels->levels; i = 0; while (pLevel) { gfilteredFile = g_strdup_printf("%s_%s_%i", shapefile->file, site, i); gfilteredPath = g_build_filename(darxen_file_support_get_app_path(), "shapefiles", "cache", gfilteredFile, NULL); hNewDBF = DBFCreate(gfilteredPath); hNewSHP = SHPCreate(gfilteredPath, pnShapeType); if (!hNewDBF || !hNewSHP || !create_required_fields(shapefile, hDBF, hNewDBF)) { SHPClose(hSHP); DBFClose(hDBF); if (hNewDBF) DBFClose(hNewDBF); if (hNewSHP) SHPClose(hNewSHP); GSList* plstNewDBFs = lstNewDBFs; while (plstNewDBFs) { DBFClose((DBFHandle)plstNewDBFs->data); plstNewDBFs = plstNewDBFs->next; } g_slist_free(lstNewDBFs); GSList* plstNewSHPs = lstNewSHPs; while (plstNewSHPs) { SHPClose((SHPHandle)plstNewSHPs->data); plstNewSHPs = plstNewSHPs->next; } g_slist_free(lstNewSHPs); g_critical("Unable to create filtered shapefile lists: (level %i)", i); return NULL; } lstNewDBFs = g_slist_append(lstNewDBFs, hNewDBF); lstNewSHPs = g_slist_append(lstNewSHPs, hNewSHP); g_free(gfilteredPath); g_free(gfilteredFile); i++; pLevel = pLevel->next; } hNewDBF = NULL; hNewSHP = NULL; } else { hNewSHP = SHPCreate(filteredPath, pnShapeType); if (!hNewSHP) { SHPClose(hSHP); DBFClose(hDBF); g_critical("Unable to create filtered shapefile: %s", filteredPath); return NULL; } hNewDBF = DBFCreate(filteredPath); if (!hNewDBF || !create_required_fields(shapefile, hDBF, hNewDBF)) { SHPClose(hSHP); DBFClose(hDBF); SHPClose(hNewSHP); g_critical("Unable to create filtered dbf shapefile: %s", filteredPath); return NULL; } } float filterRegionX1 = lonCenter - radius; float filterRegionX2 = lonCenter + radius; float filterRegionY1 = latCenter - radius; float filterRegionY2 = latCenter + radius; for (i = 0; i < pnEntities; i++) { psObject = SHPReadObject(hSHP, i); if (((filterRegionX1 >= psObject->dfXMin && filterRegionX1 <= psObject->dfXMax) || (filterRegionX2 >= psObject->dfXMin && filterRegionX2 <= psObject->dfXMax) || (psObject->dfXMin >= filterRegionX1 && psObject->dfXMin <= filterRegionX2) || (psObject->dfXMax >= filterRegionX1 && psObject->dfXMax <= filterRegionX2)) && ((filterRegionY1 >= psObject->dfYMin && filterRegionY1 <= psObject->dfYMax) || (filterRegionY2 >= psObject->dfYMin && filterRegionY2 <= psObject->dfYMax) || (psObject->dfYMin >= filterRegionY1 && psObject->dfYMin <= filterRegionY2) || (psObject->dfYMax >= filterRegionY1 && psObject->dfYMax <= filterRegionY2))) { psObject->nShapeId = -1; if (shapefile->dataLevels) { int fieldIndex = DBFGetFieldIndex(hDBF, shapefile->dataLevels->field); GSList* pDataLevels = shapefile->dataLevels->levels; GSList* pLstNewSHPs = lstNewSHPs; GSList* pLstNewDBFs = lstNewDBFs; while (pDataLevels) { DarxenShapefileDataLevel* level = (DarxenShapefileDataLevel*)pDataLevels->data; hNewSHP = (SHPHandle)pLstNewSHPs->data; hNewDBF = (DBFHandle)pLstNewDBFs->data; double value = DBFReadDoubleAttribute(hDBF, i, fieldIndex); gboolean cond; switch (shapefile->dataLevels->comparisonType) { case DATALEVELS_COMPARISON_TYPE_MIN: cond = (level->value < value); break; case DATALEVELS_COMPARISON_TYPE_MAX: cond = (level->value > value); break; default: g_warning("Invalid comparison type: %i", shapefile->dataLevels->comparisonType); cond = TRUE; } if (cond) { int index = SHPWriteObject(hNewSHP, -1, psObject); write_fields(shapefile, i, index, hDBF, hNewDBF); break; } pDataLevels = pDataLevels->next; pLstNewDBFs = pLstNewDBFs->next; pLstNewSHPs = pLstNewSHPs->next; } hNewDBF = NULL; hNewSHP = NULL; } else { int index = SHPWriteObject(hNewSHP, -1, psObject); write_fields(shapefile, i, index, hDBF, hNewDBF); } } SHPDestroyObject(psObject); } SHPClose(hSHP); DBFClose(hDBF); if (hNewDBF) DBFClose(hNewDBF); if (hNewSHP) SHPClose(hNewSHP); GSList* plstNewDBFs = lstNewDBFs; while (plstNewDBFs) { DBFClose((DBFHandle)plstNewDBFs->data); plstNewDBFs = plstNewDBFs->next; } g_slist_free(lstNewDBFs); GSList* plstNewSHPs = lstNewSHPs; while (plstNewSHPs) { SHPClose((SHPHandle)plstNewSHPs->data); plstNewSHPs = plstNewSHPs->next; } g_slist_free(lstNewSHPs); // g_assert(g_file_test(filteredPath, G_FILE_TEST_EXISTS)); return filteredPath; }
void init_baseline_shape(char *inFile, int sensor_count) { char *dbaseFile; DBFHandle dbase; SHPHandle shape; // Open database for initialization dbaseFile = (char *) MALLOC(sizeof(char)*(strlen(inFile)+5)); sprintf(dbaseFile, "%s.dbf", inFile); dbase = DBFCreate(dbaseFile); if (!dbase) asfPrintError("Could not create database file '%s'\n", dbaseFile); // Add fields to database if (sensor_count == 1) { if (DBFAddField(dbase, "Sensor", FTString, 15, 0) == -1) asfPrintError("Could not add sensor field to database file\n"); } else { if (DBFAddField(dbase, "Master_sensor", FTString, 15, 0) == -1) asfPrintError("Could not add sensor field to database file\n"); if (DBFAddField(dbase, "Slave_sensor", FTString, 15, 0) == -1) asfPrintError("Could not add sensor field to database file\n"); } if (DBFAddField(dbase, "Beam_mode", FTString, 5, 0) == -1) asfPrintError("Could not add beam mode to database file\n"); if (DBFAddField(dbase, "Frame", FTInteger, 4, 0) == -1) asfPrintError("Could not add frame field to database file\n"); if (DBFAddField(dbase, "Direction", FTString, 15, 0) == -1) asfPrintError("Could not add orbit direction field to database file\n"); if (DBFAddField(dbase, "Master", FTInteger, 5, 0) == -1) asfPrintError("Could not add master field to database file\n"); if (DBFAddField(dbase, "Master_date", FTString, 20, 0) == -1) asfPrintError("Could not add master acquisition date field" " to database file\n"); if (DBFAddField(dbase, "Slave", FTInteger, 5, 0) == -1) asfPrintError("Could not add slave field to database file\n"); if (DBFAddField(dbase, "Slave_date", FTString, 20, 0) == -1) asfPrintError("Could not add slave acquisition date field" " to database file\n"); if (DBFAddField(dbase, "B_par", FTInteger, 5, 0) == -1) asfPrintError("Could not add parallel baseline field to database file\n"); if (DBFAddField(dbase, "B_perp", FTInteger, 5, 0) == -1) asfPrintError("Could not add perpendicular baseline field" " to database file\n"); if (DBFAddField(dbase, "B_temp", FTInteger, 5, 0) == -1) asfPrintError("Could not add temporal baseline field to database file\n"); if (DBFAddField(dbase, "Center_Lat", FTDouble, 9, 4) == -1) asfPrintError("Could not add center latitude field to database file\n"); if (DBFAddField(dbase, "Center_Lon", FTDouble, 9, 4) == -1) asfPrintError("Could not add center longitude field to database file\n"); if (DBFAddField(dbase, "Lat1", FTDouble, 9, 4) == -1) asfPrintError("Could not add latitude field to database file\n"); if (DBFAddField(dbase, "Lon1", FTDouble, 9, 4) == -1) asfPrintError("Could not add longitude field to database file\n"); if (DBFAddField(dbase, "Lat2", FTDouble, 9, 4) == -1) asfPrintError("Could not add latitude field to database file\n"); if (DBFAddField(dbase, "Lon2", FTDouble, 9, 4) == -1) asfPrintError("Could not add longitude field to database file\n"); if (DBFAddField(dbase, "Lat3", FTDouble, 9, 4) == -1) asfPrintError("Could not add latitude field to database file\n"); if (DBFAddField(dbase, "Lon3", FTDouble, 9, 4) == -1) asfPrintError("Could not add longitude field to database file\n"); if (DBFAddField(dbase, "Lat4", FTDouble, 9, 4) == -1) asfPrintError("Could not add latitude field to database file\n"); if (DBFAddField(dbase, "Lon4", FTDouble, 9, 4) == -1) asfPrintError("Could not add longitude field to database file\n"); // Close the database for initialization DBFClose(dbase); // Open shapefile for initialization shape = SHPCreate(inFile, SHPT_POLYGON); if (!shape) asfPrintError("Could not create shapefile '%s'\n", inFile); // Close shapefile for initialization SHPClose(shape); FREE(dbaseFile); return; }
panSuccess[i] = TRUE; } } /* -------------------------------------------------------------------- */ /* geox/geoy to pixel/line using search algorithm. */ /* -------------------------------------------------------------------- */ #ifdef notdef else { int i; int nStartX = -1, nStartY = -1; #ifdef SHAPE_DEBUG hSHP = SHPCreate( "tracks.shp", SHPT_ARC ); hDBF = DBFCreate( "tracks.dbf" ); DBFAddField( hDBF, "GEOX", FTDouble, 10, 4 ); DBFAddField( hDBF, "GEOY", FTDouble, 10, 4 ); #endif for( i = 0; i < nPointCount; i++ ) { double dfGeoLocX, dfGeoLocY; if( padfX[i] == HUGE_VAL || padfY[i] == HUGE_VAL ) { panSuccess[i] = FALSE; continue; } if( !FindGeoLocPosition( psTransform, padfX[i], padfY[i], -1, -1, &dfGeoLocX, &dfGeoLocY ) )
bool vtStructureArray::WriteFootprintsToSHP(const char* filename) { SHPHandle hSHP = SHPCreate(filename, SHPT_POLYGON); if (!hSHP) return false; vtString dbfname = filename; dbfname = dbfname.Left(dbfname.GetLength() - 4); dbfname += ".dbf"; DBFHandle db = DBFCreate(dbfname); if (!db) return false; // Field 0: height in meters DBFAddField(db, "Height", FTDouble, 3, 2); // width, decimals uint i, j, count = GetSize(), record = 0; for (i = 0; i < count; i++) //for each coordinate { vtBuilding *bld = GetAt(i)->GetBuilding(); if (!bld) continue; const DLine2 &poly = bld->GetLevel(0)->GetOuterFootprint(); int total = poly.GetSize() + 1; double *dX = new double[total]; double *dY = new double[total]; int vert = 0; for (j=0; j < poly.GetSize(); j++) //for each vertex { DPoint2 pt = poly.GetAt(j); dX[vert] = pt.x; dY[vert] = pt.y; vert++; } // duplicate first vertex, it's just what SHP files do. DPoint2 pt = poly.GetAt(0); dX[vert] = pt.x; dY[vert] = pt.y; vert++; // Save to SHP SHPObject *obj = SHPCreateSimpleObject(SHPT_POLYGON, total, dX, dY, NULL); SHPWriteObject(hSHP, -1, obj); SHPDestroyObject(obj); delete [] dY; delete [] dX; // Save to DBF float h = bld->GetTotalHeight(); DBFWriteDoubleAttribute(db, record, 0, h); // Because not every structure may be a building, there may be fewer // records than structures. record++; } DBFClose(db); SHPClose(hSHP); return true; }
int save_table(int t) { int i, j, ncols, nrows, ret, field, rec; char name[2000], fname[20], element[100]; DBFHandle dbf; ROW *rows; VALUE *val; int dbftype, width, decimals; G_debug(2, "save_table %d", t); /* Note: because if driver is killed during the time the table is written, the process * is not completed and DATA ARE LOST. To minimize this, data are first written * to temporary file and then this file is renamed to 'database/table.dbf'. * Hopefully both file are on the same disk/partition */ if (!(db.tables[t].alive) || !(db.tables[t].updated)) return DB_OK; /* Construct our temp name because shapelib doesn't like '.' in name */ G__temp_element(element); sprintf(fname, "%d.dbf", getpid()); G_file_name(name, element, fname, G_mapset()); G_debug(2, "Write table to tempfile: '%s'", name); dbf = DBFCreate(name); if (dbf == NULL) return DB_FAILED; ncols = db.tables[t].ncols; rows = db.tables[t].rows; nrows = db.tables[t].nrows; for (i = 0; i < ncols; i++) { switch (db.tables[t].cols[i].type) { case DBF_INT: dbftype = FTInteger; break; case DBF_CHAR: dbftype = FTString; break; case DBF_DOUBLE: dbftype = FTDouble; break; } width = db.tables[t].cols[i].width; decimals = db.tables[t].cols[i].decimals; DBFAddField(dbf, db.tables[t].cols[i].name, dbftype, width, decimals); } G_debug(2, "Write %d rows", nrows); rec = 0; for (i = 0; i < nrows; i++) { if (rows[i].alive == FALSE) continue; for (j = 0; j < ncols; j++) { field = j; val = &(rows[i].values[j]); if (val->is_null) { DBFWriteNULLAttribute(dbf, rec, field); } else { switch (db.tables[t].cols[j].type) { case DBF_INT: ret = DBFWriteIntegerAttribute(dbf, rec, field, val->i); break; case DBF_CHAR: if (val->c != NULL) ret = DBFWriteStringAttribute(dbf, rec, field, val->c); else ret = DBFWriteStringAttribute(dbf, rec, field, ""); break; case DBF_DOUBLE: ret = DBFWriteDoubleAttribute(dbf, rec, field, val->d); break; } } } rec++; } G_debug(2, "Written %d records", rec); DBFClose(dbf); /* Copy */ if (G_rename_file(name, db.tables[t].file)) { append_error("Cannot move %s\nto %s\n", name, db.tables[t].file); return DB_FAILED; }; return DB_OK; }
static void WriteLineShapefile( const char * pszShapefile, SDTSTransfer * poTransfer, const char * pszMODN ) { /* -------------------------------------------------------------------- */ /* Fetch a reference to the indexed Pointgon reader. */ /* -------------------------------------------------------------------- */ SDTSLineReader *poLineReader = (SDTSLineReader *) poTransfer->GetLayerIndexedReader( poTransfer->FindLayer( pszMODN ) ); if( poLineReader == NULL ) { fprintf( stderr, "Failed to open %s.\n", poTransfer->GetCATD()->GetModuleFilePath( pszMODN ) ); return; } poLineReader->Rewind(); /* -------------------------------------------------------------------- */ /* Create the Shapefile. */ /* -------------------------------------------------------------------- */ SHPHandle hSHP; hSHP = SHPCreate( pszShapefile, SHPT_ARC ); if( hSHP == NULL ) { fprintf( stderr, "Unable to create shapefile `%s'\n", pszShapefile ); return; } /* -------------------------------------------------------------------- */ /* Create the database file, and our basic set of attributes. */ /* -------------------------------------------------------------------- */ DBFHandle hDBF; int nLeftPolyField, nRightPolyField; int nStartNodeField, nEndNodeField, nSDTSRecordField; char szDBFFilename[1024]; sprintf( szDBFFilename, "%s.dbf", pszShapefile ); hDBF = DBFCreate( szDBFFilename ); if( hDBF == NULL ) { fprintf( stderr, "Unable to create shapefile .dbf for `%s'\n", pszShapefile ); return; } nSDTSRecordField = DBFAddField( hDBF, "SDTSRecId", FTInteger, 8, 0 ); nLeftPolyField = DBFAddField( hDBF, "LeftPoly", FTString, 12, 0 ); nRightPolyField = DBFAddField( hDBF, "RightPoly", FTString, 12, 0 ); nStartNodeField = DBFAddField( hDBF, "StartNode", FTString, 12, 0 ); nEndNodeField = DBFAddField( hDBF, "EndNode", FTString, 12, 0 ); char **papszModRefs = poLineReader->ScanModuleReferences(); AddPrimaryAttrToDBFSchema( hDBF, poTransfer, papszModRefs ); CSLDestroy( papszModRefs ); /* ==================================================================== */ /* Process all the line features in the module. */ /* ==================================================================== */ SDTSRawLine *poRawLine = NULL; while( (poRawLine = poLineReader->GetNextLine()) != NULL ) { /* -------------------------------------------------------------------- */ /* Write out a shape with the vertices. */ /* -------------------------------------------------------------------- */ SHPObject *psShape = SHPCreateSimpleObject( SHPT_ARC, poRawLine->nVertices, poRawLine->padfX, poRawLine->padfY, poRawLine->padfZ ); int iShape = SHPWriteObject( hSHP, -1, psShape ); SHPDestroyObject( psShape ); /* -------------------------------------------------------------------- */ /* Write out the attributes. */ /* -------------------------------------------------------------------- */ char szID[13]; DBFWriteIntegerAttribute( hDBF, iShape, nSDTSRecordField, poRawLine->oModId.nRecord ); sprintf( szID, "%s:%d", poRawLine->oLeftPoly.szModule, poRawLine->oLeftPoly.nRecord ); DBFWriteStringAttribute( hDBF, iShape, nLeftPolyField, szID ); sprintf( szID, "%s:%d", poRawLine->oRightPoly.szModule, poRawLine->oRightPoly.nRecord ); DBFWriteStringAttribute( hDBF, iShape, nRightPolyField, szID ); sprintf( szID, "%s:%d", poRawLine->oStartNode.szModule, poRawLine->oStartNode.nRecord ); DBFWriteStringAttribute( hDBF, iShape, nStartNodeField, szID ); sprintf( szID, "%s:%d", poRawLine->oEndNode.szModule, poRawLine->oEndNode.nRecord ); DBFWriteStringAttribute( hDBF, iShape, nEndNodeField, szID ); WritePrimaryAttrToDBF( hDBF, iShape, poTransfer, poRawLine ); if( !poLineReader->IsIndexed() ) delete poRawLine; } /* -------------------------------------------------------------------- */ /* Close, and cleanup. */ /* -------------------------------------------------------------------- */ DBFClose( hDBF ); SHPClose( hSHP ); }
static void WritePointShapefile( const char * pszShapefile, SDTSTransfer * poTransfer, const char * pszMODN ) { SDTSPointReader *poPointReader; /* -------------------------------------------------------------------- */ /* Fetch a reference to the indexed Pointgon reader. */ /* -------------------------------------------------------------------- */ poPointReader = (SDTSPointReader *) poTransfer->GetLayerIndexedReader( poTransfer->FindLayer( pszMODN ) ); if( poPointReader == NULL ) { fprintf( stderr, "Failed to open %s.\n", poTransfer->GetCATD()->GetModuleFilePath( pszMODN ) ); return; } poPointReader->Rewind(); /* -------------------------------------------------------------------- */ /* Create the Shapefile. */ /* -------------------------------------------------------------------- */ SHPHandle hSHP; hSHP = SHPCreate( pszShapefile, SHPT_POINT ); if( hSHP == NULL ) { fprintf( stderr, "Unable to create shapefile `%s'\n", pszShapefile ); return; } /* -------------------------------------------------------------------- */ /* Create the database file, and our basic set of attributes. */ /* -------------------------------------------------------------------- */ DBFHandle hDBF; int nAreaField, nSDTSRecordField; char szDBFFilename[1024]; sprintf( szDBFFilename, "%s.dbf", pszShapefile ); hDBF = DBFCreate( szDBFFilename ); if( hDBF == NULL ) { fprintf( stderr, "Unable to create shapefile .dbf for `%s'\n", pszShapefile ); return; } nSDTSRecordField = DBFAddField( hDBF, "SDTSRecId", FTInteger, 8, 0 ); nAreaField = DBFAddField( hDBF, "AreaId", FTString, 12, 0 ); char **papszModRefs = poPointReader->ScanModuleReferences(); AddPrimaryAttrToDBFSchema( hDBF, poTransfer, papszModRefs ); CSLDestroy( papszModRefs ); /* ==================================================================== */ /* Process all the line features in the module. */ /* ==================================================================== */ SDTSRawPoint *poRawPoint; while( (poRawPoint = poPointReader->GetNextPoint()) != NULL ) { int iShape; /* -------------------------------------------------------------------- */ /* Write out a shape with the vertices. */ /* -------------------------------------------------------------------- */ SHPObject *psShape; psShape = SHPCreateSimpleObject( SHPT_POINT, 1, &(poRawPoint->dfX), &(poRawPoint->dfY), &(poRawPoint->dfZ) ); iShape = SHPWriteObject( hSHP, -1, psShape ); SHPDestroyObject( psShape ); /* -------------------------------------------------------------------- */ /* Write out the attributes. */ /* -------------------------------------------------------------------- */ char szID[13]; DBFWriteIntegerAttribute( hDBF, iShape, nSDTSRecordField, poRawPoint->oModId.nRecord ); sprintf( szID, "%s:%ld", poRawPoint->oAreaId.szModule, poRawPoint->oAreaId.nRecord ); DBFWriteStringAttribute( hDBF, iShape, nAreaField, szID ); WritePrimaryAttrToDBF( hDBF, iShape, poTransfer, poRawPoint ); if( !poPointReader->IsIndexed() ) delete poRawPoint; } /* -------------------------------------------------------------------- */ /* Close, and cleanup. */ /* -------------------------------------------------------------------- */ DBFClose( hDBF ); SHPClose( hSHP ); }
void shape_datapool_init(char *inFile, char *header) { char *dbaseFile; DBFHandle dbase; SHPHandle shape; dbf_header_t *dbf; int ii, nCols, length=32, length2=255; // Read configuration file read_header_config("DATAPOOL", &dbf, &nCols); // Open database for initialization dbaseFile = appendExt(inFile, ".dbf"); dbase = DBFCreate(dbaseFile); if (!dbase) asfPrintError("Could not create database file '%s'\n", dbaseFile); // Add fields to database for (ii=0; ii<nCols; ii++) { if (strcmp(dbf[ii].header, "Granule_Name") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "GRAN_NAME", FTString, length, 0) == -1) asfPrintError("Could not add GRAN_NAME field to database file\n"); } else if (strcmp(dbf[ii].header, "Platform") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PLATFORM", FTString, length, 0) == -1) asfPrintError("Could not add PLATFORM field to database file\n"); } else if (strcmp(dbf[ii].header, "Sensor") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "SENSOR", FTString, length, 0) == -1) asfPrintError("Could not add SENSOR field to database file\n"); } else if (strcmp(dbf[ii].header, "Beam_Mode") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "BEAM_MODE", FTString, length2, 0) == -1) asfPrintError("Could not add BEAM_MODE field to database file\n"); } else if (strcmp(dbf[ii].header, "Beam_Mode_Description") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "BEAM_MODE_D", FTString, length, 0) == -1) asfPrintError("Could not add BEAM_MODE_D field to database file\n"); } else if (strcmp(dbf[ii].header, "Orbit") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "ORBIT", FTInteger, 7, 0) == -1) asfPrintError("Could not add ORBIT field to database file\n"); } else if (strcmp(dbf[ii].header, "Path_Number") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PATH_NUM", FTInteger, 10, 0) == -1) asfPrintError("Could not add PATH_NUM field to database file\n"); } else if (strcmp(dbf[ii].header, "Frame_Number") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FRAME_NUM", FTInteger, 10, 0) == -1) asfPrintError("Could not add FRAME_NUM field to database file\n"); } else if (strcmp(dbf[ii].header, "Acquisition_Date") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "ACQ_DATE", FTString, length, 0) == -1) asfPrintError("Could not add ACQ_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "Processing_Date") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PROC_DATE", FTString, length, 0) == -1) asfPrintError("Could not add PROC_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "Processing_Level") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "PROC_LEVEL", FTString, 10, 0) == -1) asfPrintError("Could not add PROC_LEVEL field to database file\n"); } else if (strcmp(dbf[ii].header, "Start_Time") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "START_TIME", FTString, length, 0) == -1) asfPrintError("Could not add START_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "End_Time") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "END_TIME", FTString, length, 0) == -1) asfPrintError("Could not add END_TIME field to database file\n"); } else if (strcmp(dbf[ii].header, "Center_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "CENTER_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add CENTER_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Center_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "CENTER_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add CENTER_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_Start_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "NSTART_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add NSTART_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_Start_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "NSTART_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add NSTART_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_Start_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FSTART_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add FSTART_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_Start_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FSTART_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add FSTART_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_End_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "N_END_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add N_END_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Near_End_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "N_END_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add N_END_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_End_Lat") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "F_END_LAT", FTDouble, 16, 4) == -1) asfPrintError("Could not add F_END_LAT field to database file\n"); } else if (strcmp(dbf[ii].header, "Far_End_Lon") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "F_END_LON", FTDouble, 16, 4) == -1) asfPrintError("Could not add F_END_LON field to database file\n"); } else if (strcmp(dbf[ii].header, "Faraday_Rotation") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "FARADAYROT", FTDouble, 16, 1) == -1) asfPrintError("Could not add FARADAYROT field to database file\n"); } else if (strcmp(dbf[ii].header, "Orbit_Direction") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "ORBIT_DIR", FTString, length, 0) == -1) asfPrintError("Could not add ORBIT_DIR field to database file\n"); } else if (strcmp(dbf[ii].header, "Url") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "URL", FTString, length2, 0) == -1) asfPrintError("Could not add URL field to database file\n"); } else if (strcmp(dbf[ii].header, "Size") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "SIZE_MB", FTDouble, 16, 2) == -1) asfPrintError("Could not add SIZE_MB field to database file\n"); } else if (strcmp(dbf[ii].header, "Off_Nadir_Angle") == 0 && dbf[ii].visible) { if (DBFAddField(dbase, "OFF_NADIR", FTDouble, 16, 2) == -1) asfPrintError("Could not add OFF_NADIR field to database file\n"); } } // Close the database for initialization DBFClose(dbase); // Open shapefile for initialization shape = SHPCreate(inFile, SHPT_POLYGON); if (!shape) asfPrintError("Could not create shapefile '%s'\n", inFile); // Close shapefile for initialization SHPClose(shape); FREE(dbaseFile); return; }
static void WritePolygonShapefile( const char * pszShapefile, SDTSTransfer * poTransfer, const char * pszMODN ) { SDTSPolygonReader *poPolyReader; /* -------------------------------------------------------------------- */ /* Fetch a reference to the indexed polygon reader. */ /* -------------------------------------------------------------------- */ poPolyReader = (SDTSPolygonReader *) poTransfer->GetLayerIndexedReader( poTransfer->FindLayer( pszMODN ) ); if( poPolyReader == NULL ) { fprintf( stderr, "Failed to open %s.\n", poTransfer->GetCATD()->GetModuleFilePath( pszMODN ) ); return; } /* -------------------------------------------------------------------- */ /* Assemble polygon geometries from all the line layers. */ /* -------------------------------------------------------------------- */ poPolyReader->AssembleRings( poTransfer, poTransfer->FindLayer(pszMODN) ); /* -------------------------------------------------------------------- */ /* Create the Shapefile. */ /* -------------------------------------------------------------------- */ SHPHandle hSHP; hSHP = SHPCreate( pszShapefile, SHPT_POLYGON ); if( hSHP == NULL ) { fprintf( stderr, "Unable to create shapefile `%s'\n", pszShapefile ); return; } /* -------------------------------------------------------------------- */ /* Create the database file, and our basic set of attributes. */ /* -------------------------------------------------------------------- */ DBFHandle hDBF; int nSDTSRecordField; char szDBFFilename[1024]; sprintf( szDBFFilename, "%s.dbf", pszShapefile ); hDBF = DBFCreate( szDBFFilename ); if( hDBF == NULL ) { fprintf( stderr, "Unable to create shapefile .dbf for `%s'\n", pszShapefile ); return; } nSDTSRecordField = DBFAddField( hDBF, "SDTSRecId", FTInteger, 8, 0 ); char **papszModRefs = poPolyReader->ScanModuleReferences(); AddPrimaryAttrToDBFSchema( hDBF, poTransfer, papszModRefs ); CSLDestroy( papszModRefs ); /* ==================================================================== */ /* Process all the polygon features in the module. */ /* ==================================================================== */ SDTSRawPolygon *poRawPoly; poPolyReader->Rewind(); while( (poRawPoly = (SDTSRawPolygon *) poPolyReader->GetNextFeature()) != NULL ) { int iShape; /* -------------------------------------------------------------------- */ /* Write out a shape with the vertices. */ /* -------------------------------------------------------------------- */ SHPObject *psShape; psShape = SHPCreateObject( SHPT_POLYGON, -1, poRawPoly->nRings, poRawPoly->panRingStart, NULL, poRawPoly->nVertices, poRawPoly->padfX, poRawPoly->padfY, poRawPoly->padfZ, NULL ); iShape = SHPWriteObject( hSHP, -1, psShape ); SHPDestroyObject( psShape ); /* -------------------------------------------------------------------- */ /* Write out the attributes. */ /* -------------------------------------------------------------------- */ DBFWriteIntegerAttribute( hDBF, iShape, nSDTSRecordField, poRawPoly->oModId.nRecord ); WritePrimaryAttrToDBF( hDBF, iShape, poTransfer, poRawPoly ); if( !poPolyReader->IsIndexed() ) delete poRawPoly; } /* -------------------------------------------------------------------- */ /* Close, and cleanup. */ /* -------------------------------------------------------------------- */ DBFClose( hDBF ); SHPClose( hSHP ); }
bool _curv_save_shp(const d_curv * contour, const char * filename) { if (!contour->getName()) writelog(LOG_MESSAGE,"saving curv to ERSI shape file %s", filename); else writelog(LOG_MESSAGE,"saving curv \"%s\" to ERSI shape file %s", contour->getName(), filename); if (!contour) { writelog(LOG_WARNING, "NULL pointer to curv."); return false; }; DBFHandle hDBF; SHPHandle hSHP; hSHP = SHPOpen( filename, "rb+" ); hDBF = DBFOpen( filename, "rb+" ); if (hSHP == NULL || hDBF == NULL) { if (hSHP) SHPClose( hSHP ); if (hDBF) DBFClose( hDBF ); hSHP = SHPCreate( filename, SHPT_ARC ); if( hSHP == NULL ) { writelog(LOG_ERROR, "Unable to create:%s", filename ); return false; } hDBF = DBFCreate( filename ); } int shpType; SHPGetInfo(hSHP, NULL, &shpType, NULL, NULL); if (shpType != SHPT_ARC) { writelog(LOG_ERROR, "%s : Wrong shape type! Should be SHPT_ARC.", filename); SHPClose( hSHP ); DBFClose( hDBF ); return false; } int name_field = DBFGetFieldIndex( hDBF, "NAME" ); if (name_field == -1) { if( DBFAddField( hDBF, "NAME", FTString, 50, 0 ) == -1 ) { writelog(LOG_ERROR, "DBFAddField(%s,FTString) failed.", "NAME"); SHPClose( hSHP ); DBFClose( hDBF ); return false; } name_field = DBFGetFieldIndex( hDBF, "NAME" ); }; std::vector<REAL> data_x(contour->size()); std::vector<REAL> data_y(contour->size()); std::copy(contour->X->begin(), contour->X->end(), data_x.begin()); std::copy(contour->Y->begin(), contour->Y->end(), data_y.begin()); SHPObject * psObject = SHPCreateObject(SHPT_ARC, -1, 0, NULL, NULL, contour->size(), &*(data_x.begin()), &*(data_y.begin()), NULL, NULL); SHPComputeExtents(psObject); int pos = SHPWriteObject(hSHP, -1, psObject); SHPDestroyObject(psObject); if (contour->getName()) DBFWriteStringAttribute(hDBF, pos, name_field, contour->getName() ); SHPClose( hSHP ); DBFClose( hDBF ); return true; };
CC_FILE_ERROR ShpFilter::saveToFile(ccHObject* entity, const std::vector<GenericField*>& fields, QString filename) { if (!entity) return CC_FERR_BAD_ENTITY_TYPE; //this filter only supports point clouds, meshes and polylines! ESRI_SHAPE_TYPE inputShapeType = SHP_NULL_SHAPE; ccHObject::Container toSave; GetSupportedShapes(entity,toSave,inputShapeType/*,m_closedPolylinesAsPolygons*/); if (inputShapeType == SHP_NULL_SHAPE || toSave.empty()) return CC_FERR_BAD_ENTITY_TYPE; ESRI_SHAPE_TYPE outputShapeType = inputShapeType; if (m_closedPolylinesAsPolygons && (inputShapeType == SHP_POLYLINE || inputShapeType == SHP_POLYLINE_Z)) { //check if all the polylines are closed! bool allAreClosed = true; for (size_t i=0; i<toSave.size() && allAreClosed; ++i) { if (!static_cast<ccPolyline*>(toSave[i])->isClosed()) allAreClosed = false; } if (allAreClosed) { //promote 'polylines' to 'polygon' outputShapeType = SHP_POLYLINE ? SHP_POLYGON : SHP_POLYGON_Z; } } ccLog::Print("[SHP] Output type: " + ToString(outputShapeType)); QFileInfo fi(filename); QString baseFileName = fi.path() + QString("/") + fi.completeBaseName(); //the main file (suffix should be ".shp") QString shpFilename = baseFileName+QString(".shp"); QFile file(shpFilename); if (!file.open(QIODevice::WriteOnly)) return CC_FERR_WRITING; //index file (same base name + ".shx") QString indexFilename = baseFileName+QString(".shx"); QFile indexFile(indexFilename); if (!indexFile.open(QIODevice::WriteOnly)) return CC_FERR_WRITING; //build header (refer to ESRI Shapefile Technical Description) char header[100]; memset(header,0,100); { /*** WARNING: the beginning of the header is written with big endianness! ***/ char* _header = header; //Byte 0: SHP code const int32_t code = qToBigEndian<int32_t>(9994); memcpy(_header,(const char*)&code,4); _header += 4; //Byte 4: unused (20 bytes) _header += 20; //Byte 24: file length (will be written... later ;) _header += 4; /*** WARNING: from now on, we only write data with little endianness! ***/ //Byte 28: file verion const int32_t version = qToLittleEndian<int32_t>(1000); memcpy(_header,(const char*)&version,4); _header += 4; //Byte 32: shape type int32_t shapeTypeInt = qToLittleEndian<int32_t>(outputShapeType); memcpy(_header,(const char*)&shapeTypeInt,4); _header += 4; ccBBox box = entity->getBB(); assert(box.isValid()); //X and Y bounaries double xMin = qToLittleEndian<double>(box.minCorner().x); double xMax = qToLittleEndian<double>(box.maxCorner().x); double yMin = qToLittleEndian<double>(box.minCorner().y); double yMax = qToLittleEndian<double>(box.maxCorner().y); //Byte 36: box X min memcpy(_header,(const char*)&xMin,8); _header += 8; //Byte 44: box Y min memcpy(_header,(const char*)&yMin,8); _header += 8; //Byte 52: box X max memcpy(_header,(const char*)&xMax,8); _header += 8; //Byte 60: box Y max memcpy(_header,(const char*)&yMax,8); _header += 8; //Z bounaries //Unused, with value 0.0, if not Measured or Z type double zMin = outputShapeType < SHP_POINT_Z ? 0.0 : qToLittleEndian<double>(box.minCorner().z); double zMax = outputShapeType < SHP_POINT_Z ? 0.0 : qToLittleEndian<double>(box.maxCorner().z); //Byte 68: box Z min memcpy(_header,(const char*)&zMin,8); _header += 8; //Byte 76: box Z max memcpy(_header,(const char*)&zMax,8); _header += 8; //M bounaries (M = measures) double mMin = ESRI_NO_DATA; double mMax = ESRI_NO_DATA; //Byte 84: M min memcpy(_header,(const char*)&mMin,8); _header += 8; //Byte 92: M max memcpy(_header,(const char*)&mMax,8); _header += 8; } //actually write the header if (!file.write(header,100)) return CC_FERR_WRITING; if (!indexFile.write(header,100)) //exact same header for index file! return CC_FERR_WRITING; int32_t fileLength = 100; //save shapes unsigned shapeIndex = 0; for (unsigned i=0; i<toSave.size(); ++i) { ccHObject* child = toSave[i]; //check entity elligibility if (child->isA(CC_TYPES::POLY_LINE)) { if (static_cast<ccPolyline*>(child)->size() < 3) { ccLog::Warning(QString("Polyline '%1' is too small! It won't be saved...").arg(child->getName())); continue; } } int32_t recordSize = 0; qint64 recordStart = file.pos(); //write shape record in main SHP file { //Byte 0: Record Number const int32_t recordNumber = qToBigEndian<int32_t>(++shapeIndex); //Record numbers begin at 1 file.write((const char*)&recordNumber,4); //Byte 4: Content Length file.write((const char*)&recordSize,4); //will be updated later } fileLength += 8; CC_FILE_ERROR error = CC_FERR_NO_ERROR; switch (inputShapeType) { case SHP_POLYLINE: case SHP_POLYLINE_Z: assert(child->isKindOf(CC_TYPES::POLY_LINE)); error = SavePolyline(static_cast<ccPolyline*>(child),file,recordSize,outputShapeType); break; case SHP_MULTI_POINT_Z: assert(child->isKindOf(CC_TYPES::POINT_CLOUD)); error = SaveAsCloud(ccHObjectCaster::ToGenericPointCloud(child),file,recordSize); break; //case SHP_MULTI_PATCH: // assert(child->isKindOf(CC_TYPES::MESH)); // error = SaveAsMesh(ccHObjectCaster::ToMesh(child),file,recordSize); // break; default: assert(false); break; } if (error != CC_FERR_NO_ERROR) return error; fileLength += recordSize; //update record size { //backup current pos qint64 currentPos = file.pos(); assert((qint64)fileLength == currentPos); //go backward file.seek(recordStart+4); int32_t recordSize16bits = qToBigEndian<int32_t>(recordSize/2); //recordSize is measured in 16-bit words file.write((const char*)&recordSize16bits,4); //restore last pos file.seek(currentPos); } //write corresponding entry in index SHX file { //Byte 0: Offset int32_t recordStart16bits = qToBigEndian<int32_t>(recordStart/2); //recordStart is measured in 16-bit words indexFile.write((const char*)&recordStart16bits,4); //Byte 4: Content Length int32_t recordSize16bits= qToBigEndian<int32_t>(recordSize/2); //recordSize is measured in 16-bit words indexFile.write((const char*)&recordSize16bits,4); } } //update main file length { file.seek(24); //Byte 24: file length (in 16-bit words) int32_t fileLength16bits = qToBigEndian<int32_t>(fileLength/2); file.write((const char*)&fileLength16bits,4); } file.close(); //update idx file length { indexFile.seek(24); //Byte 24: file length (in 16-bit words) int32_t idxFileLength = (int32_t)indexFile.size(); int32_t idxFileLength16bits = qToBigEndian<int32_t>(idxFileLength/2); indexFile.write((const char*)&idxFileLength16bits,4); } indexFile.close(); CC_FILE_ERROR result = CC_FERR_NO_ERROR; //eventually, we create the DB file (suffix should be ".dbf") QString dbfFilename = baseFileName+QString(".dbf"); DBFHandle dbfHandle = DBFCreate(qPrintable(dbfFilename)); if (dbfHandle) { while (true) //trick: we use 'while' to be able to break anytime { //always write an 'index' table { int fieldIdx = DBFAddField(dbfHandle,"local_idx",FTInteger,6,0); if (fieldIdx >= 0) { for (unsigned i=0; i<toSave.size(); ++i) DBFWriteIntegerAttribute(dbfHandle,static_cast<int>(i),fieldIdx,static_cast<int>(i)+1); } else { ccLog::Warning(QString("[ShpFilter::saveToFile] Failed to save field 'index' (default)")); result = CC_FERR_WRITING; break; } } //and write the other tables (specified by the user) for (std::vector<GenericField*>::const_iterator it = fields.begin(); it != fields.end(); ++it) { const GenericField* field = *it; if (field->is3D()) //3D case { int xFieldIdx = DBFAddField(dbfHandle,qPrintable(field->name()+QString("_x")),field->type(),field->width(),field->decimal()); int yFieldIdx = DBFAddField(dbfHandle,qPrintable(field->name()+QString("_y")),field->type(),field->width(),field->decimal()); int zFieldIdx = DBFAddField(dbfHandle,qPrintable(field->name()+QString("_z")),field->type(),field->width(),field->decimal()); if (xFieldIdx >= 0 && yFieldIdx >= 0 && zFieldIdx >= 0) { if (!(*it)->save(dbfHandle,xFieldIdx,yFieldIdx,zFieldIdx)) xFieldIdx = -1; } if (xFieldIdx < 0) { ccLog::Warning(QString("[ShpFilter::saveToFile] Failed to save field '%1'").arg(field->name())); result = CC_FERR_WRITING; break; } } else //1D case { int fieldIdx = DBFAddField(dbfHandle,qPrintable(field->name()),field->type(),field->width(),field->decimal()); if (fieldIdx >= 0) { if (!(*it)->save(dbfHandle,fieldIdx)) fieldIdx = -1; } if (fieldIdx < 0) { ccLog::Warning(QString("[ShpFilter::saveToFile] Failed to save field '%1'").arg(field->name())); result = CC_FERR_WRITING; break; } } } break; } DBFClose(dbfHandle); } else { result = CC_FERR_WRITING; } return result; }
OGRLayer * OGRShapeDataSource::CreateLayer( const char * pszLayerName, OGRSpatialReference *poSRS, OGRwkbGeometryType eType, char ** papszOptions ) { SHPHandle hSHP; DBFHandle hDBF; int nShapeType; int iLayer; /* -------------------------------------------------------------------- */ /* Check that the layer doesn't already exist. */ /* -------------------------------------------------------------------- */ for( iLayer = 0; iLayer < nLayers; iLayer++ ) { OGRLayer *poLayer = papoLayers[iLayer]; if( poLayer != NULL && EQUAL(poLayer->GetLayerDefn()->GetName(),pszLayerName) ) { CPLError( CE_Failure, CPLE_AppDefined, "Layer '%s' already exists", pszLayerName); return NULL; } } /* -------------------------------------------------------------------- */ /* Verify we are in update mode. */ /* -------------------------------------------------------------------- */ if( !bDSUpdate ) { CPLError( CE_Failure, CPLE_NoWriteAccess, "Data source %s opened read-only.\n" "New layer %s cannot be created.\n", pszName, pszLayerName ); return NULL; } /* -------------------------------------------------------------------- */ /* Figure out what type of layer we need. */ /* -------------------------------------------------------------------- */ if( eType == wkbUnknown || eType == wkbLineString ) nShapeType = SHPT_ARC; else if( eType == wkbPoint ) nShapeType = SHPT_POINT; else if( eType == wkbPolygon ) nShapeType = SHPT_POLYGON; else if( eType == wkbMultiPoint ) nShapeType = SHPT_MULTIPOINT; else if( eType == wkbPoint25D ) nShapeType = SHPT_POINTZ; else if( eType == wkbLineString25D ) nShapeType = SHPT_ARCZ; else if( eType == wkbMultiLineString ) nShapeType = SHPT_ARC; else if( eType == wkbMultiLineString25D ) nShapeType = SHPT_ARCZ; else if( eType == wkbPolygon25D ) nShapeType = SHPT_POLYGONZ; else if( eType == wkbMultiPolygon ) nShapeType = SHPT_POLYGON; else if( eType == wkbMultiPolygon25D ) nShapeType = SHPT_POLYGONZ; else if( eType == wkbMultiPoint25D ) nShapeType = SHPT_MULTIPOINTZ; else if( eType == wkbNone ) nShapeType = SHPT_NULL; else nShapeType = -1; /* -------------------------------------------------------------------- */ /* Has the application overridden this with a special creation */ /* option? */ /* -------------------------------------------------------------------- */ const char *pszOverride = CSLFetchNameValue( papszOptions, "SHPT" ); if( pszOverride == NULL ) /* ignore */; else if( EQUAL(pszOverride,"POINT") ) { nShapeType = SHPT_POINT; eType = wkbPoint; } else if( EQUAL(pszOverride,"ARC") ) { nShapeType = SHPT_ARC; eType = wkbLineString; } else if( EQUAL(pszOverride,"POLYGON") ) { nShapeType = SHPT_POLYGON; eType = wkbPolygon; } else if( EQUAL(pszOverride,"MULTIPOINT") ) { nShapeType = SHPT_MULTIPOINT; eType = wkbMultiPoint; } else if( EQUAL(pszOverride,"POINTZ") ) { nShapeType = SHPT_POINTZ; eType = wkbPoint25D; } else if( EQUAL(pszOverride,"ARCZ") ) { nShapeType = SHPT_ARCZ; eType = wkbLineString25D; } else if( EQUAL(pszOverride,"POLYGONZ") ) { nShapeType = SHPT_POLYGONZ; eType = wkbPolygon25D; } else if( EQUAL(pszOverride,"MULTIPOINTZ") ) { nShapeType = SHPT_MULTIPOINTZ; eType = wkbMultiPoint25D; } else if( EQUAL(pszOverride,"NONE") ) { nShapeType = SHPT_NULL; } else { CPLError( CE_Failure, CPLE_NotSupported, "Unknown SHPT value of `%s' passed to Shapefile layer\n" "creation. Creation aborted.\n", pszOverride ); return NULL; } if( nShapeType == -1 ) { CPLError( CE_Failure, CPLE_NotSupported, "Geometry type of `%s' not supported in shapefiles.\n" "Type can be overridden with a layer creation option\n" "of SHPT=POINT/ARC/POLYGON/MULTIPOINT/POINTZ/ARCZ/POLYGONZ/MULTIPOINTZ.\n", OGRGeometryTypeToName(eType) ); return NULL; } /* -------------------------------------------------------------------- */ /* What filename do we use, excluding the extension? */ /* -------------------------------------------------------------------- */ char *pszBasename; if( bSingleFileDataSource && nLayers == 0 ) { char *pszPath = CPLStrdup(CPLGetPath(pszName)); char *pszFBasename = CPLStrdup(CPLGetBasename(pszName)); pszBasename = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL)); CPLFree( pszFBasename ); CPLFree( pszPath ); } else if( bSingleFileDataSource ) { /* This is a very weird use case : the user creates/open a datasource */ /* made of a single shapefile 'foo.shp' and wants to add a new layer */ /* to it, 'bar'. So we create a new shapefile 'bar.shp' in the same */ /* directory as 'foo.shp' */ /* So technically, we will not be any longer a single file */ /* datasource ... Ahem ahem */ char *pszPath = CPLStrdup(CPLGetPath(pszName)); pszBasename = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL)); CPLFree( pszPath ); } else pszBasename = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL)); /* -------------------------------------------------------------------- */ /* Create the shapefile. */ /* -------------------------------------------------------------------- */ char *pszFilename; if( nShapeType != SHPT_NULL ) { pszFilename = CPLStrdup(CPLFormFilename( NULL, pszBasename, "shp" )); hSHP = SHPCreate( pszFilename, nShapeType ); if( hSHP == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open Shapefile `%s'.\n", pszFilename ); CPLFree( pszFilename ); CPLFree( pszBasename ); return NULL; } CPLFree( pszFilename ); } else hSHP = NULL; /* -------------------------------------------------------------------- */ /* Has a specific LDID been specified by the caller? */ /* -------------------------------------------------------------------- */ const char *pszLDID = CSLFetchNameValue( papszOptions, "ENCODING" ); /* -------------------------------------------------------------------- */ /* Create a DBF file. */ /* -------------------------------------------------------------------- */ pszFilename = CPLStrdup(CPLFormFilename( NULL, pszBasename, "dbf" )); if( pszLDID != NULL ) hDBF = DBFCreateEx( pszFilename, pszLDID ); else hDBF = DBFCreate( pszFilename ); if( hDBF == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open Shape DBF file `%s'.\n", pszFilename ); CPLFree( pszFilename ); CPLFree( pszBasename ); SHPClose(hSHP); return NULL; } CPLFree( pszFilename ); /* -------------------------------------------------------------------- */ /* Create the .prj file, if required. */ /* -------------------------------------------------------------------- */ if( poSRS != NULL ) { char *pszWKT = NULL; CPLString osPrjFile = CPLFormFilename( NULL, pszBasename, "prj"); VSILFILE *fp; /* the shape layer needs it's own copy */ poSRS = poSRS->Clone(); poSRS->morphToESRI(); if( poSRS->exportToWkt( &pszWKT ) == OGRERR_NONE && (fp = VSIFOpenL( osPrjFile, "wt" )) != NULL ) { VSIFWriteL( pszWKT, strlen(pszWKT), 1, fp ); VSIFCloseL( fp ); } CPLFree( pszWKT ); poSRS->morphFromESRI(); } /* -------------------------------------------------------------------- */ /* Create the layer object. */ /* -------------------------------------------------------------------- */ OGRShapeLayer *poLayer; poLayer = new OGRShapeLayer( pszBasename, hSHP, hDBF, poSRS, TRUE, TRUE, eType ); poLayer->InitializeIndexSupport( pszBasename ); CPLFree( pszBasename ); /* -------------------------------------------------------------------- */ /* Add layer to data source layer list. */ /* -------------------------------------------------------------------- */ papoLayers = (OGRShapeLayer **) CPLRealloc( papoLayers, sizeof(OGRShapeLayer *) * (nLayers+1) ); papoLayers[nLayers++] = poLayer; return poLayer; }