Exemplo n.º 1
0
extern int
Dbf_GetFieldIndexFromObj (Tcl_Interp * interp, DBFHandle dbfHandle,
                          Tcl_Obj * objPtr, int *indexPtr)
{
  if (objPtr->typePtr == &dbfFieldType && GetDBFHandle (objPtr) == dbfHandle)
    {  
      *indexPtr = GetFieldIndex (objPtr);
      return TCL_OK;
    }
  else
    {
      if ((*indexPtr =
           DBFGetFieldIndex (dbfHandle, Tcl_GetString (objPtr))) == -1)
        {
          Tcl_SetResult (interp, "missing value to go with key", TCL_STATIC);
          Tcl_SetErrorCode (interp, "DBF", "VALUE", "DICTIONARY", NULL);
          return TCL_ERROR;
        }
      FreeInternalRep (objPtr);
      objPtr->typePtr = &dbfFieldType;
      SetFieldIndex (objPtr, *indexPtr);
      SetDBFHandle (objPtr, dbfHandle);
      return TCL_OK;
    }
}
Exemplo n.º 2
0
Arquivo: shape.c Projeto: peko/tttm2
// extract info from dbf
void
shapes_load_dbf(const char* filename, const char* column){

    DBFHandle hDBF;

    hDBF = DBFOpen( filename, "rb" );
    if( hDBF == NULL ) {
        fprintf(stderr, "DBFOpen(%s,\"r\") failed.\n", filename );
        return;
    }

    // INFO ABOUT DBF
    // int  *panWidth;
    // int  nWidth, nDecimals;
    // fprintf (stderr, "Info for %s\n", filename);
    // i = DBFGetFieldCount(hDBF);
    // fprintf (stderr, "%d Columns,  %d Records in file\n",i,DBFGetRecordCount(hDBF));
    // panWidth = (int *) malloc( DBFGetFieldCount( hDBF ) * sizeof(int) );
    // for( int i = 0; i < DBFGetFieldCount(hDBF); i++ ) {
    //     DBFFieldType    eType;
    //     char szTitle[256];
    //     eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals );
    //     fprintf(stderr, "%4d: %10s %c", i, szTitle, i%4 ? '|':'\n');
    // }
    // fprintf(stderr, "\n");

    // print names
    uint32_t fid = DBFGetFieldIndex(hDBF, column);
    for(uint32_t i = 0; i < DBFGetRecordCount(hDBF); i++ ) {
       char* name_long = (char *) DBFReadStringAttribute(hDBF, i, fid);
       fprintf(stderr, "%d: %s\n", i, name_long);
    }

    DBFClose( hDBF );
}
Exemplo n.º 3
0
int dbf_get_field_index(DBFHandle handle, int row, const char *field_name) {
    assert(handle);
    assert(field_name);
    assert(row < DBFGetRecordCount(handle));
    // if (row >= DBFGetRecordCount(handle)) throw(std::runtime_error("row=" + std::to_string(row) + " is out of bounds."));
    int index = DBFGetFieldIndex(handle, field_name);
    if (index == -1) throw(std::runtime_error("DBFfile doesnt contain " + std::string(field_name)));
    return index;
}
Exemplo n.º 4
0
//  Function to read outlets from a shapefile - overloaded to return an array of integer ID's
int readoutlets(char *outletsfile, int *noutlets, double*& x, double*& y, int*& id)
{
	SHPHandle shp = SHPOpen(outletsfile, "rb");
	char dbffile[MAXLN];
	nameadd(dbffile, outletsfile, ".dbf");
	DBFHandle dbf = DBFOpen(dbffile, "rb");
	if ((shp != NULL) && (dbf != NULL)) {
		int nEntities = 0;
		int nShapeType = 0;
		SHPGetInfo(shp, &nEntities, &nShapeType, NULL, NULL );
		if (nShapeType != SHPT_POINT)
		{
			fprintf(stderr, "Outlets shapefile %s is not a point shapefile\n", outletsfile);
			fflush(stderr);
			return 1;
		}
	long p_size;
	long countPts = 0;

	int nfld = DBFGetFieldCount(dbf);
	//int idfld = DBFGetFieldIndex(dbf, "id");
	int idfld = DBFGetFieldIndex(dbf, "OBJECTID"); // ZhuLJ, 2015/6/16
	for( int i=0; i<nEntities; i++) {
		SHPObject * shape = SHPReadObject(shp, i);
		countPts += shape->nVertices;
		SHPDestroyObject(shape);
	}
	x = new double[countPts];
	y = new double[countPts];
	if (idfld >= 0)
		id = new int[countPts];
    int nxy=0;
	for( int i=0; i<nEntities; i++) {
		SHPObject * shape = SHPReadObject(shp, i);
		p_size = shape->nVertices;
		for( int j=0; j<p_size; j++) {
			x[nxy] = shape->padfX[j];
			y[nxy] = shape->padfY[j];
			if (idfld >= 0)
			{
				id[nxy] = DBFReadIntegerAttribute(dbf, i, idfld);
			}
			nxy++;
		}
		SHPDestroyObject(shape);
	}
	*noutlets=nxy;
	SHPClose(shp);
	return 0;
	}
	else { 
		fprintf(stderr, "Error opening outlets shapefile: %s\n", outletsfile);
		fflush(stderr);
		return 1;
	}	
}
Exemplo n.º 5
0
Arquivo: shape.c Projeto: peko/tttm2
strings_v
shape_load_names(const char* filename, const char* colname) {

    DBFHandle hDBF;
    strings_v col;
    kv_init(col);

    hDBF = DBFOpen( filename, "rb" );
    if( hDBF == NULL ) {
        fprintf(stderr, "DBFOpen(%s,\"r\") failed.\n", filename );
        return col;
    }
    uint32_t fid = DBFGetFieldIndex(hDBF, colname);
    for(uint32_t i = 0; i < DBFGetRecordCount(hDBF); i++ ) {
        char* str = (char *) DBFReadStringAttribute(hDBF, i, fid);
        if(str != NULL)
            kv_push(char*, col, strdup(str));
        else            
            kv_push(char*, col, NULL);
    }

    DBFClose( hDBF );
    return col;
}
Exemplo n.º 6
0
GeoDataDocument *ShpRunner::parseFile(const QString &fileName, DocumentRole role, QString &error)
{
    QFileInfo fileinfo( fileName );
    if (fileinfo.suffix().compare(QLatin1String("shp"), Qt::CaseInsensitive) != 0) {
        error = QStringLiteral("File %1 does not have a shp suffix").arg(fileName);
        mDebug() << error;
        return nullptr;
    }

    SHPHandle handle = SHPOpen( fileName.toStdString().c_str(), "rb" );
    if ( !handle ) {
        error = QStringLiteral("Failed to read %1").arg(fileName);
        mDebug() << error;
        return nullptr;
    }
    int entities;
    int shapeType;
    SHPGetInfo( handle, &entities, &shapeType, NULL, NULL );
    mDebug() << " SHP info " << entities << " Entities "
             << shapeType << " Shape Type ";

    DBFHandle dbfhandle;
    dbfhandle = DBFOpen( fileName.toStdString().c_str(), "rb");
    int nameField = DBFGetFieldIndex( dbfhandle, "Name" );
    int noteField = DBFGetFieldIndex( dbfhandle, "Note" );
    int mapColorField = DBFGetFieldIndex( dbfhandle, "mapcolor13" );

    GeoDataDocument *document = new GeoDataDocument;
    document->setDocumentRole( role );

    if ( mapColorField != -1 ) {
        GeoDataSchema schema;
        schema.setId(QStringLiteral("default"));
        GeoDataSimpleField simpleField;
        simpleField.setName(QStringLiteral("mapcolor13"));
        simpleField.setType( GeoDataSimpleField::Double );
        schema.addSimpleField( simpleField );
        document->addSchema( schema );
    }

    for ( int i=0; i< entities; ++i ) {
        GeoDataPlacemark  *placemark = 0;
        placemark = new GeoDataPlacemark;
        document->append( placemark );

        SHPObject *shape = SHPReadObject( handle, i );
        if (nameField != -1) {
            const char* info = DBFReadStringAttribute( dbfhandle, i, nameField );
            // TODO: defaults to utf-8 encoding, but could be also something else, optionally noted in a .cpg file
            placemark->setName( info );
            mDebug() << "name " << placemark->name();
        }
        if (noteField != -1) {
            const char* note = DBFReadStringAttribute( dbfhandle, i, noteField );
            // TODO: defaults to utf-8 encoding, see comment for name
            placemark->setDescription( note );
            mDebug() << "desc " << placemark->description();
        }

        double mapColor = DBFReadDoubleAttribute( dbfhandle, i, mapColorField );
        if ( mapColor ) {
            GeoDataStyle::Ptr style(new GeoDataStyle);
            if ( mapColor >= 0 && mapColor <=255 ) {
                quint8 colorIndex = quint8( mapColor );
                style->polyStyle().setColorIndex( colorIndex );
            }
            else {
                quint8 colorIndex = 0;     // mapColor is undefined in this case
                style->polyStyle().setColorIndex( colorIndex );
            }
            placemark->setStyle( style );
        }

        switch ( shapeType ) {
            case SHPT_POINT: {
                GeoDataPoint *point = new GeoDataPoint( *shape->padfX, *shape->padfY, 0, GeoDataCoordinates::Degree );
                placemark->setGeometry( point );
                mDebug() << "point " << placemark->name();
                break;
            }

            case SHPT_MULTIPOINT: {
                GeoDataMultiGeometry *geom = new GeoDataMultiGeometry;
                for( int j=0; j<shape->nVertices; ++j ) {
                    geom->append( new GeoDataPoint( GeoDataCoordinates(
                                  shape->padfX[j], shape->padfY[j],
                                  0, GeoDataCoordinates::Degree ) ) );
                }
                placemark->setGeometry( geom );
                mDebug() << "multipoint " << placemark->name();
                break;
            }

            case SHPT_ARC: {
                if ( shape->nParts != 1 ) {
                    GeoDataMultiGeometry *geom = new GeoDataMultiGeometry;
                    for( int j=0; j<shape->nParts; ++j ) {
                        GeoDataLineString *line = new GeoDataLineString;
                        int itEnd = (j + 1 < shape->nParts) ? shape->panPartStart[j+1] : shape->nVertices;
                        for( int k=shape->panPartStart[j]; k<itEnd; ++k ) {
                            line->append( GeoDataCoordinates(
                                          shape->padfX[k], shape->padfY[k],
                                          0, GeoDataCoordinates::Degree ) );
                        }
                        geom->append( line );
                    }
                    placemark->setGeometry( geom );
                    mDebug() << "arc " << placemark->name() << " " << shape->nParts;

                } else {
                    GeoDataLineString *line = new GeoDataLineString;
                    for( int j=0; j<shape->nVertices; ++j ) {
                        line->append( GeoDataCoordinates(
                                      shape->padfX[j], shape->padfY[j],
                                      0, GeoDataCoordinates::Degree ) );
                    }
                    placemark->setGeometry( line );
                    mDebug() << "arc " << placemark->name() << " " << shape->nParts;
                }
                break;
            }

            case SHPT_POLYGON: {
                if ( shape->nParts != 1 ) {
                    bool isRingClockwise = false;
                    GeoDataMultiGeometry *multigeom = new GeoDataMultiGeometry;
                    GeoDataPolygon *poly = 0;
                    int polygonCount = 0;
                    for( int j=0; j<shape->nParts; ++j ) {
                        GeoDataLinearRing ring;
                        int itStart = shape->panPartStart[j];
                        int itEnd = (j + 1 < shape->nParts) ? shape->panPartStart[j+1] : shape->nVertices;
                        for( int k = itStart; k<itEnd; ++k ) {
                            ring.append( GeoDataCoordinates(
                                         shape->padfX[k], shape->padfY[k],
                                         0, GeoDataCoordinates::Degree ) );
                        }
                        isRingClockwise = ring.isClockwise();
                        if ( j == 0 || isRingClockwise ) {
                            poly = new GeoDataPolygon;
                            ++polygonCount;
                            poly->setOuterBoundary( ring );
                            if ( polygonCount > 1 ) {
                                multigeom->append( poly );
                            }
                        }
                        else {
                            poly->appendInnerBoundary( ring );
                        }
                    }
                    if ( polygonCount > 1 ) {
                        placemark->setGeometry( multigeom );
                    }
                    else {
                        placemark->setGeometry( poly );
                        delete multigeom;
                        multigeom = 0;
                    }
                    mDebug() << "donut " << placemark->name() << " " << shape->nParts;

                } else {
                    GeoDataPolygon *poly = new GeoDataPolygon;
                    GeoDataLinearRing ring;
                    for( int j=0; j<shape->nVertices; ++j ) {
                        ring.append( GeoDataCoordinates(
                                         shape->padfX[j], shape->padfY[j],
                                         0, GeoDataCoordinates::Degree ) );
                    }
                    poly->setOuterBoundary( ring );
                    placemark->setGeometry( poly );
                    mDebug() << "poly " << placemark->name() << " " << shape->nParts;
                }
                break;
            }
        }
    }

    SHPClose( handle );

    DBFClose( dbfhandle );

    if ( document->size() ) {
        document->setFileName( fileName );
        return document;
    } else {
        delete document;
        return nullptr;
    }
}
Exemplo n.º 7
0
int main (int argc, char *argv[]) {

  SHPHandle  inSHP, outSHP;
  DBFHandle  inDBF, outDBF;
  int        len; 
  int        i;
  char       **fieldNames;
  char       **strOrder = 0;
  struct DataStruct *index;
  int        width;
  int        decimals;
  SHPObject  *feat;
  void       *tuple;

  if (argc < 4) {
    printf("USAGE: shpsort <infile> <outfile> <field[;...]> [<(ASCENDING|DESCENDING)[;...]>]\n");
    exit(EXIT_FAILURE);
  }

  inSHP = SHPOpen (argv[1], "rb");
  if (!inSHP) {
    fputs("Couldn't open shapefile for reading!\n", stderr);
    exit(EXIT_FAILURE);
  }
  SHPGetInfo(inSHP, &nShapes, &shpType, NULL, NULL);

  /* If we can open the inSHP, open its DBF */
  inDBF = DBFOpen (argv[1], "rb");
  if (!inDBF) {
    fputs("Couldn't open dbf file for reading!\n", stderr);
    exit(EXIT_FAILURE);
  }

  /* Parse fields and validate existence */
  fieldNames = split(argv[3], ";");
  if (!fieldNames) {
    fputs("ERROR: parsing field names!\n", stderr);
    exit(EXIT_FAILURE);
  }
  for (nFields = 0; fieldNames[nFields] ; nFields++) {
    continue;
  }

  fldIdx = malloc(sizeof *fldIdx * nFields);
  if (!fldIdx) {
    fputs("malloc failed!\n", stderr);
    exit(EXIT_FAILURE);
  }
  for (i = 0; i < nFields; i++) {
    len = (int)strlen(fieldNames[i]);
    while(len > 0) {
      --len;
      fieldNames[i][len] = (char)toupper((unsigned char)fieldNames[i][len]); 
    }
    fldIdx[i] = DBFGetFieldIndex(inDBF, fieldNames[i]);
    if (fldIdx[i] < 0) {
      /* try "SHAPE" */
      if (strcmp(fieldNames[i], "SHAPE") == 0) {
	fldIdx[i] = -1;
      }
      else if (strcmp(fieldNames[i], "FID") == 0) {
	fldIdx[i] = -2;
      }
      else {
	fprintf(stderr, "ERROR: field '%s' not found!\n", fieldNames[i]);
	exit(EXIT_FAILURE);
      }
    }
  }


  /* set up field type array */
  fldType = malloc(sizeof *fldType * nFields);
  if (!fldType) {
    fputs("malloc failed!\n", stderr);
    exit(EXIT_FAILURE);
  }
  for (i = 0; i < nFields; i++) {
    if (fldIdx[i] < 0) {
      fldType[i] = fldIdx[i];
    }
    else {
      fldType[i] = DBFGetFieldInfo(inDBF, fldIdx[i], NULL, &width, &decimals);
      if (fldType[i] == FTInvalid) {
	fputs("Unrecognized field type in dBASE file!\n", stderr);
	exit(EXIT_FAILURE);
      }
    }
  }


  /* set up field order array */
  fldOrder = malloc(sizeof *fldOrder * nFields);
  if (!fldOrder) {
    fputs("malloc failed!\n", stderr);
    exit(EXIT_FAILURE);
  }
  for (i = 0; i < nFields; i++) {
    /* default to ascending order */
    fldOrder[i] = ASCENDING;
  }
  if (argc > 4) {
    strOrder = split(argv[4], ";");
    if (!strOrder) {
      fputs("ERROR: parsing fields ordering!\n", stderr);
      exit(EXIT_FAILURE);
    }
    for (i = 0; i < nFields && strOrder[i]; i++) {
      if (strcmp(strOrder[i], "DESCENDING") == 0) {
	fldOrder[i] = DESCENDING;
      }
    }
  }

  /* build the index */
  index = build_index (inSHP, inDBF);

  /* Create output shapefile */
  outSHP = SHPCreate(argv[2], shpType);
  if (!outSHP) {
    fprintf(stderr, "%s:%d: couldn't create output shapefile!\n",
	    __FILE__, __LINE__);
    exit(EXIT_FAILURE);
  }
  
  /* Create output dbf */
  outDBF = DBFCloneEmpty(inDBF, argv[2]);
  if (!outDBF) {
    fprintf(stderr, "%s:%d: couldn't create output dBASE file!\n",
	    __FILE__, __LINE__);
    exit(EXIT_FAILURE);
  }

  /* Copy projection file, if any */
  copy_related(argv[1], argv[2], ".shp", ".prj");

  /* Copy metadata file, if any */
  copy_related(argv[1], argv[2], ".shp", ".shp.xml");

  /* Write out sorted results */
  for (i = 0; i < nShapes; i++) {
    feat = SHPReadObject(inSHP, index[i].record);
    if (SHPWriteObject(outSHP, -1, feat) < 0) {
      fprintf(stderr, "%s:%d: error writing shapefile!\n", __FILE__, __LINE__);
      exit(EXIT_FAILURE);
    }
    tuple = (void *) DBFReadTuple(inDBF, index[i].record);
    if (DBFWriteTuple(outDBF, i, tuple) < 0) {
      fprintf(stderr, "%s:%d: error writing dBASE file!\n", __FILE__, __LINE__);
      exit(EXIT_FAILURE);
    }
  }
  SHPClose(inSHP);
  SHPClose(outSHP);
  DBFClose(inDBF);
  DBFClose(outDBF);

  return EXIT_SUCCESS;

}
Exemplo n.º 8
0
/**
 * 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);
}  
Exemplo n.º 9
0
bool writeAdminRegionsToDatabase(QString const &a0_dbf,
                                 QString const &a1_dbf,
                                 Kompex::SQLiteStatement * pStmt)
{
    // because shapefiles are evil
    QTextCodec * codec = QTextCodec::codecForName("windows-1252");

    // populate the admin0 temp table
    {
        DBFHandle a0_hDBF = DBFOpen(a0_dbf.toLocal8Bit().data(),"rb");
        if(a0_hDBF == NULL)   {
            qDebug() << "ERROR: Could not open admin0 dbf file";
            return -1;
        }

        size_t a0_numRecords = DBFGetRecordCount(a0_hDBF);
        if(a0_numRecords == 0)   {
            qDebug() << "ERROR: admin0 dbf file has no records!";
            return -1;
        }

        size_t a0_idx_adm_name  = DBFGetFieldIndex(a0_hDBF,"name");
        size_t a0_idx_adm_a3    = DBFGetFieldIndex(a0_hDBF,"adm0_a3");
        size_t a0_idx_sov_name  = DBFGetFieldIndex(a0_hDBF,"sovereignt");
        size_t a0_idx_sov_a3    = DBFGetFieldIndex(a0_hDBF,"sov_a3");
        size_t a0_idx_type      = DBFGetFieldIndex(a0_hDBF,"type");
        size_t a0_idx_note      = DBFGetFieldIndex(a0_hDBF,"note_adm0");

        // create a temporary table we can use to lookup
        // the admin0 data we want for each admin1 entry
        pStmt->SqlStatement("CREATE TABLE IF NOT EXISTS temp("
                            "id INTEGER PRIMARY KEY NOT NULL UNIQUE,"
                            "adm_a3 TEXT NOT NULL UNIQUE,"
                            "sov_a3 TEXT NOT NULL,"
                            "adm_name TEXT,"
                            "sov_name TEXT,"
                            "type TEXT,"
                            "note TEXT);");

        pStmt->BeginTransaction();
        for(size_t i=0; i < a0_numRecords; i++)   {
            QString s0 = QString::number(i,10);
            QString s1(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_adm_a3)));
            QString s2(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_sov_a3)));
            QString s3(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_adm_name)));
            QString s4(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_sov_name)));
            QString s5(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_type)));
            QString s6(codec->toUnicode(DBFReadStringAttribute(a0_hDBF, i, a0_idx_note)));

            QString stmt("INSERT INTO temp("
                         "id,"
                         "adm_a3,"
                         "sov_a3,"
                         "adm_name,"
                         "sov_name,"
                         "type,"
                         "note) VALUES(" +
                         s0 + "," +
                         "\"" + s1 + "\","
                         "\"" + s2 + "\","
                         "\"" + s3 + "\","
                         "\"" + s4 + "\","
                         "\"" + s5 + "\","
                         "\"" + s6 + "\");");

            pStmt->SqlStatement(stmt.toStdString());
        }
        pStmt->CommitTransaction();
        DBFClose(a0_hDBF);
    }

    // populate the admin1 table
    {
        DBFHandle a1_hDBF = DBFOpen(a1_dbf.toLocal8Bit().data(),"rb");
        if(a1_hDBF == NULL)   {
            qDebug() << "ERROR: Could not open admin1 dbf file";
            return false;
        }

        size_t a1_numRecords = DBFGetRecordCount(a1_hDBF);
        if(a1_numRecords == 0)   {
            qDebug() << "ERROR: admin1 dbf file has no records!";
            return false;
        }

        // open admin1 translation csv if it exists
        QStringList listAdmin1Subs;
        QString pathSubs = a1_dbf;
        pathSubs.chop(4);
        pathSubs.append("_translations.dat");
        bool admin1_csv_sub = getAdmin1TranslationSubs(pathSubs,listAdmin1Subs);
        if(admin1_csv_sub)   {
            if(listAdmin1Subs.size() == a1_numRecords)   {
                qDebug() << "INFO: Using translation substitute file: "<< pathSubs;
            }
            else   {
                qDebug() << "WARN: Translation file has wrong number "
                         "of entries: " << listAdmin1Subs.size();
                admin1_csv_sub = false;
            }
        }

        size_t a1_idx_adm_name  = DBFGetFieldIndex(a1_hDBF,"name");
        size_t a1_idx_adm_a3    = DBFGetFieldIndex(a1_hDBF,"sr_adm0_a3");
        size_t a1_idx_sov_a3    = DBFGetFieldIndex(a1_hDBF,"sr_sov_a3");
        size_t a1_idx_fclass    = DBFGetFieldIndex(a1_hDBF,"featurecla");
        size_t a1_idx_adminname = DBFGetFieldIndex(a1_hDBF,"admin");

        QStringList listSqlSaveSov;
        QStringList listSqlSaveAdmin0;
        QStringList listSqlSaveAdmin1;

        for(size_t i=0; i < a1_numRecords; i++)   {
            // get the name of this admin1 entry
            QString admin1_idx = QString::number(i,10);
            QString admin1_name(codec->toUnicode(DBFReadStringAttribute(a1_hDBF, i, a1_idx_adm_name)));

            // if the adm1 fclass is an aggregation, minor island or
            // remainder, we grab the name from another field which
            // doesn't contain a bunch of additional metadata
            QString fclass(codec->toUnicode(DBFReadStringAttribute(a1_hDBF, i, a1_idx_fclass)));
            if(fclass.contains("aggregation") ||
                    fclass.contains("minor island") ||
                    fclass.contains("remainder"))
            {
                admin1_name = QString(codec->toUnicode(DBFReadStringAttribute(
                        a1_hDBF, i, a1_idx_adminname)));
            }
            else   {
                // if there's no special feature class than we check
                // to see if there's a translation substitute available
                if(admin1_csv_sub && (listAdmin1Subs[i].size() > 0))   {
                    admin1_name = listAdmin1Subs[i];
                }
            }

            // get the adm_a3,sov_a3 code for this admin1 entry
            QString adm_a3(codec->toUnicode(DBFReadStringAttribute(a1_hDBF, i, a1_idx_adm_a3)));
            QString sov_a3(codec->toUnicode(DBFReadStringAttribute(a1_hDBF, i, a1_idx_sov_a3)));

            // check if the adm_a3 code exists in the temp database
            QString stmt("SELECT * FROM temp WHERE adm_a3=\""+ adm_a3 + "\";");
            pStmt->Sql(stmt.toStdString());

            if(pStmt->FetchRow())   {
                // save admin0 info
                QString admin0_idx  = QString::number(pStmt->GetColumnInt("id"),10);
                QString admin0_type = QString::fromStdString(pStmt->GetColumnString("type"));
                QString admin0_note = QString::fromStdString(pStmt->GetColumnString("note"));
                pStmt->FreeQuery();

                // save admin1 info; we currently derive the
                // disputed field from admin0 type and note fields
                QString admin1_disputed = "0";
                if(admin0_type.contains("Disputed") ||
                        admin0_note.contains("Disputed"))   {
                    admin1_disputed = "1";
                }

                stmt = QString("INSERT INTO admin1(id,name,disputed,admin0,sov) VALUES(" +
                               admin1_idx + ",\"" +
                               admin1_name + "\"," +
                               admin1_disputed + "," +
                               admin0_idx + "," +
                               admin0_idx + ");");
                listSqlSaveAdmin1.push_back(stmt);
            }
            else   {
                pStmt->FreeQuery();

                // if there isn't a matching adm_a3 code in the temp
                // database try to get the sovereign state instead
                stmt = QString("SELECT * FROM temp WHERE sov_a3=\""+ sov_a3 + "\";");
                pStmt->Sql(stmt.toStdString());

                if(pStmt->FetchRow())   {
                    QString sov_idx     = QString::number(pStmt->GetColumnInt("id"));
                    pStmt->FreeQuery();

                    // since there's no true corresponding entry for
                    // the admin1 region through the adm_a3 code, we
                    // can't test for disputed regions
                    QString admin1_disputed = "0";

                    // to indicate that no admin0 region data exists
                    // for this entry, we use an index of value -1
                    QString admin0_idx = "-1";

                    stmt = QString("INSERT INTO admin1(id,name,disputed,admin0,sov) VALUES(" +
                                   admin1_idx + ",\"" +
                                   admin1_name + "\"," +
                                   admin1_disputed + "," +
                                   admin0_idx + "," +
                                   sov_idx + ");");
                    listSqlSaveAdmin1.push_back(stmt);
                }
                else   {
                    // fail without a matching adm_a3 or sov_a3
                    pStmt->FreeQuery();
                    return false;
                }
            }
        }

        // populate the admin0 and sov tables
        {
            QString stmt("SELECT * FROM temp;");
            pStmt->Sql(stmt.toStdString());

            while(pStmt->FetchRow())   {
                QString idx         = QString::number(pStmt->GetColumnInt("id"),10);
                QString admin0_name = QString::fromStdString(pStmt->GetColumnString("adm_name"));
                QString sov_name    = QString::fromStdString(pStmt->GetColumnString("sov_name"));

                stmt = QString("INSERT INTO sov(id,name) VALUES("+
                               idx + ",\"" +
                               sov_name + "\");");
                listSqlSaveSov.push_back(stmt);

                stmt = QString("INSERT INTO admin0(id,name) VALUES("+
                               idx + ",\"" +
                               admin0_name + "\");");
                listSqlSaveAdmin0.push_back(stmt);
            }
            pStmt->FreeQuery();
        }

        // write prepared statements
        pStmt->BeginTransaction();
        for(int i=0; i < listSqlSaveSov.size(); i++)   {
            pStmt->SqlStatement(listSqlSaveSov[i].toUtf8().data());
        }
        pStmt->CommitTransaction();

        pStmt->BeginTransaction();
        for(int i=0; i < listSqlSaveAdmin0.size(); i++)   {
            pStmt->SqlStatement(listSqlSaveAdmin0[i].toUtf8().data());
        }
        pStmt->CommitTransaction();

        pStmt->BeginTransaction();
        for(int i=0; i < listSqlSaveAdmin1.size(); i++)   {
            pStmt->SqlStatement(listSqlSaveAdmin1[i].toUtf8().data());
        }
        pStmt->CommitTransaction();
    }

    // delete temp table
    pStmt->SqlStatement("DROP TABLE temp;");

    return true;
}
Exemplo n.º 10
0
bool vtVegLayer::OnLoad()
{
	vtSpeciesList *plants = g_bld->GetSpeciesList();
	if (plants->NumSpecies() == 0)
	{
		DisplayAndLog(_("You must specify a species file (plant list) to use when working with vegetation files."));
		return false;
	}

	wxString fname = GetLayerFilename();
	wxString ext = fname.Right(3);

	wxString dbfname = fname.Left(fname.Length() - 4);
	dbfname += _T(".dbf");

	if (!ext.CmpNoCase(_T(".vf")))
	{
		// read VF file
		SetVegType(VLT_Instances);
		GetPIA()->SetSpeciesList(plants);
		if (GetPIA()->ReadVF(fname.mb_str(wxConvUTF8)))
		{
			m_pSet->SetFilename((const char *)fname.mb_str(wxConvUTF8));
			return true;
		}
		else
		{
			delete m_pSet;
			m_pSet = NULL;
			m_VLType = VLT_None;
			return false;
		}
	}
	else if (!ext.CmpNoCase(_T("shp")))
	{
		// SHPOpen doesn't yet support utf-8 or wide filenames, so convert
		vtString fname_local = UTF8ToLocal(fname.mb_str(wxConvUTF8));

		// Study this SHP file, look at what it might be
		int		nElems, nShapeType;
		SHPHandle hSHP = SHPOpen(fname_local, "rb");
		if (hSHP == NULL)
			return false;
		SHPGetInfo(hSHP, &nElems, &nShapeType, NULL, NULL);
		SHPClose(hSHP);
		if (nShapeType == SHPT_POINT)
			SetVegType(VLT_Instances);
		else if (nShapeType == SHPT_POLYGON)
		{
			// DBFOpen doesn't yet support utf-8 or wide filenames, so convert
			vtString fname_localdbf = UTF8ToLocal(dbfname.mb_str(wxConvUTF8));

			DBFHandle db = DBFOpen(fname_localdbf, "rb");
			if (db == NULL)
				return false;

			m_field_density = DBFGetFieldIndex(db, "Density");
			m_field_biotype = DBFGetFieldIndex(db, "Biotype");
			DBFClose(db);

			if (m_field_density != -1)
				SetVegType(VLT_Density);
			else if (m_field_biotype != -1)
				SetVegType(VLT_BioMap);
			else
				return false;
		}
		// OK, read the rest of the file
		return m_pSet->LoadFromSHP(fname.mb_str(wxConvUTF8));
	}

	// don't know this file
	return false;
}
Exemplo n.º 11
0
int main( int argc, char ** argv )
{
    SHPHandle	iSHP;
    DBFHandle   iDBF;

    SHPHandle	jSHP;
    DBFHandle   jDBF;

    int         i, j, k;
    int         iEntities, jEntities;
    int         iRecord,   jRecord;

    int         scanAhead;

/* -------------------------------------------------------------------- */
/*      Display a usage message.                                        */
/* -------------------------------------------------------------------- */
    if( argc != 3 )
    {
	printf( "shpdiff original_shapefile comparison_shapefile\n" );
	exit( 1 );
    }

/* -------------------------------------------------------------------- */
/*      Open the passed shapefile parts                                 */
/* -------------------------------------------------------------------- */
    iSHP = SHPOpen( argv[1], "rb" );
    if( iSHP == NULL )
    {
	printf( "Unable to find shapefile \"%s\"\n", argv[1] );
	exit( 1 );
    }
    iDBF = DBFOpen( argv[1], "rb" );
    if( iDBF == NULL )
    {
	printf( "Unable to find shapefile \"%s\"\n", argv[1] );
	exit( 1 );
    }
    if( DBFGetFieldCount(iDBF) == 0 )
    {
        printf( "There are no fields in table %s!\n", argv[1] );
        exit( 3 );
    }


    jSHP = SHPOpen( argv[2], "rb" );
    if( jSHP == NULL )
    {
	printf( "Unable to find shapefile \"%s\"\n", argv[2] );
        exit( 1 );
    }
    jDBF = DBFOpen( argv[2], "rb" );
    if( jDBF == NULL )
    {
	printf( "Unable to find shapefile \"%s\"\n", argv[2] );
        exit( 1 );
    }
    if( DBFGetFieldCount(jDBF) == 0 )
    {
        printf( "There are no fields in table %s!\n", argv[2] );
        exit( 3 );
    }


/* -------------------------------------------------------------------- */
/*      Print out some useful data about each shapefile                 */
/* -------------------------------------------------------------------- */
    printf("Original ");
    printHeader( iDBF, iSHP );
    printf("Comparison ");
    printHeader( jDBF, jSHP );
    printf("\n");


/* -------------------------------------------------------------------- */
/*      Guess which column headering might best identify each record    */
/* -------------------------------------------------------------------- */
    identifyKey = DBFGetFieldIndex( iDBF, "NAME" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "STREET" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "TOWN" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "ID" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "STATION" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "LINE" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = DBFGetFieldIndex( iDBF, "TRAILNAME" );
    if( identifyKey >= 0 )
        goto gotkey;
    identifyKey = -1;
gotkey:

/* -------------------------------------------------------------------- */
/*      Match up column indexes between the shapefiles                  */     
/* -------------------------------------------------------------------- */
{
int     i, temp;
int     nWidth, nDecimals;
char    szTitle[12];

    if(identifyKey)
    {
        DBFGetFieldInfo( iDBF, identifyKey, szTitle, &nWidth, &nDecimals );
        printf("NOTE: Using column %s to identify records\n", szTitle);
    }

    for( i = 0; i < DBFGetFieldCount(iDBF); i++ )
    {
        DBFGetFieldInfo( iDBF, i, szTitle, &nWidth, &nDecimals );
        columnMatchArray[i] = DBFGetFieldIndex( jDBF, szTitle );
        if( columnMatchArray[i] < 0 )
        {
                printf("WARNING: Column %s deleted from original\n", szTitle);
        }
    }
    for( i = 0; i < DBFGetFieldCount(jDBF); i++ )
    {
        DBFGetFieldInfo( jDBF, i, szTitle, &nWidth, &nDecimals );
        if( DBFGetFieldIndex( iDBF, szTitle ) < 0 )
        {
                printf("WARNING: Column \"%s\" was added\n", szTitle);
        }
    }

    // Eliminate certain columns from the comparison
    temp = DBFGetFieldIndex( jDBF, "LENGTH" );
    if( temp >= 0 )
    {
        columnMatchArray[temp] = -1;
        printf("WARNING: Ingoring column \"%s\"\n", "LENGTH");
    }
    temp = DBFGetFieldIndex( jDBF, "FNODE_" );
    if( temp >= 0 )
    {
        columnMatchArray[temp] = -1;
        printf("WARNING: Ingoring column \"%s\"\n", "FNODE");
    }
    temp = DBFGetFieldIndex( jDBF, "TNODE_" );
    if( temp >= 0 )
    {
        columnMatchArray[temp] = -1;
        printf("WARNING: Ingoring column \"%s\"\n", "TNODE_");
    }
    temp = DBFGetFieldIndex( jDBF, "AREA" );
    if( temp >= 0 )
    {
        columnMatchArray[temp] = -1;
        printf("WARNING: Ingoring column \"%s\"\n", "AREA");
    }
}


/* -------------------------------------------------------------------- */
/*      Main loop                                                       */
/* -------------------------------------------------------------------- */
    scanAhead= SCAN_AHEAD;
    iRecord = 0;
    jRecord = 0;
    iEntities = DBFGetRecordCount(iDBF);
    jEntities = DBFGetRecordCount(jDBF);

    while( (iRecord < iEntities) || (jRecord < jEntities) )
    {
        int shpDiff;
        int dbfDiff;
        int keyDiff;

        //printf("iRecord %d jRecord %d\n", iRecord, jRecord);


        /* Print out any extra records at the end of either file */
        if( iRecord == iEntities )
        {
            while( jRecord < jEntities )
            {
                printf("\nNew record %d found\n", jRecord);
                printf("-------------------------------");
                printDBF(jDBF, jRecord);
                jRecord++;
            }
            goto end;
        }

        if( jRecord == jEntities )
        {
            while( iRecord < iEntities )
            {
                printf("\nRecord %d: deleted from original\n", iRecord);
                printf("--------------------------------");
                printDBF(iDBF, iRecord);
                iRecord++;
            }
            goto end;
        }

        shpDiff = compareSHP   (iSHP, iRecord, jSHP, jRecord, false);
        dbfDiff = compareDBF   (iDBF, iRecord, jDBF, jRecord, false);
        keyDiff = compareDBFkey(iDBF, iRecord, jDBF, jRecord, false);
        //printf("Compare iRecord=%d jRecord=%d: shpDiff=%d dbfDiff=%d keyDiff=%d\n",
        //        iRecord, jRecord, shpDiff, dbfDiff, keyDiff);

        /* If everything is the same, skip ahead */
        if( !shpDiff && !dbfDiff && !keyDiff )
        {
            iRecord++;
            jRecord++;
            goto end;
        }

        /* If the primary key record is different, 
         * and the shape has also changed, scan ahead for a better match */
        if ( keyDiff )
        {
            for( i=1; (i<scanAhead) && (iRecord+i < iEntities); i++ )
            {
                shpDiff = compareSHP   (iSHP, iRecord+i, jSHP, jRecord, false);
                dbfDiff = compareDBF   (iDBF, iRecord+i, jDBF, jRecord, false);
                keyDiff = compareDBFkey(iDBF, iRecord+i, jDBF, jRecord, false);
                //printf("Scan iRecord=%d jRecord=%d: shpDiff=%d dbfDiff=%d keyDiff=%d\n",
                //    iRecord+i, jRecord, shpDiff, dbfDiff, keyDiff);

                if ( !shpDiff || !dbfDiff )
                {
                    for( j=0; j<i; j++ )
                    {
                        printf("\nRecord %d: deleted from original\n", iRecord);
                        printf("--------------------------------");
                        printDBF(iDBF, iRecord);
                        iRecord++;
                    }
                    goto end;
                }
            }

            /* We can't find any match, call it a "new" record */
            printf("\nNew record %d found\n", jRecord);
            printf("-------------------------------");
            printDBF(jDBF, jRecord);
            jRecord++;
            goto end;
        }

        /* Either the shape or the primary key match exactly, show a change record */
        printf("\nRecord %d:", iRecord);
        if( identifyKey )
            printf(" (%s) ", DBFReadStringAttribute( iDBF, iRecord, identifyKey ));
        if( shpDiff )
            printf("shape change\n");
        else
            printf("\n");
        if( dbfDiff )
        {
            compareDBF(iDBF, iRecord, jDBF, jRecord, true);
        }
        iRecord++;
        jRecord++;

        end:;
    }

/* -------------------------------------------------------------------- */
/*      Cleanup                                                         */
/* -------------------------------------------------------------------- */
    SHPClose( iSHP );
    DBFClose( iDBF );
    SHPClose( jSHP );
    DBFClose( jDBF );

#ifdef USE_DBMALLOC
    malloc_dump(2);
#endif

    exit( 0 );
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
	shapefiles = g_list_reverse(shapefiles);

    xmlXPathFreeContext(xpath);
    xmlFreeDoc(doc);
}

static gboolean
create_field(char* name, DBFHandle base, DBFHandle new)
{
	int field;
	char fieldName[12];
	int fieldWidth;
	int fieldDecimals;
	DBFFieldType fieldType;

	field = DBFGetFieldIndex(base, name);
	if (field < 0)
	{
		g_critical("Invalid shapefile field name: %s", name);
		return FALSE;
	}
	fieldType = DBFGetFieldInfo(base, field, fieldName, &fieldWidth, &fieldDecimals);
	DBFAddField(new, fieldName, fieldType, fieldWidth, fieldDecimals);

	return TRUE;
}

static gboolean
create_required_fields(DarxenShapefile* shapefile, DBFHandle base, DBFHandle new)
{
	if (shapefile->textLabels)
Exemplo n.º 14
0
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;

};
Exemplo n.º 15
0
bool _curv_load_shp(const char * filename, const char * curvname) {

	SHPHandle hSHP;
	DBFHandle hDBF;
	
	hSHP = SHPOpen(filename, "rb");
	if( hSHP == NULL ) {
		writelog(LOG_ERROR, "Unable to open:%s", filename );
		return false;
	}

	int shpType;
	int Entities;
	SHPGetInfo(hSHP, &Entities, &shpType, NULL, NULL);

	if (shpType != SHPT_ARC) {
		SHPClose( hSHP );
		writelog(LOG_ERROR, "%s : Wrong shape type! Should be SHTP_ARC.", filename);
		return false;
	}

	hDBF = DBFOpen(filename, "rb");
	if( hDBF == NULL ) {
		SHPClose(hSHP);
		writelog(LOG_ERROR, "Unable to open DBF for %s", filename );
		return false;
	}

	int name_field = DBFGetFieldIndex( hDBF, "NAME" );
	int dbf_records = DBFGetRecordCount( hDBF );

	Entities = MIN(dbf_records, Entities);

	int i, j;
	for (i = 0; i < Entities; i++) {
		SHPObject * shpObject = SHPReadObject( hSHP, i );

		if (shpObject->nParts != 1) {
			SHPDestroyObject(shpObject);
			continue;
		}
			
		const char * name = NULL;
		if (name_field != -1)
			name = DBFReadStringAttribute( hDBF, i, name_field );

		if (curvname != NULL) {
			if ( StringMatch(curvname, name) == false )
				continue;
		}

		writelog(LOG_MESSAGE,"loading curve \"%s\" from ESRI shape file %s",
			name?name:"noname",filename);

		vec * X = create_vec(shpObject->nVertices,0,0);
		vec * Y = create_vec(shpObject->nVertices,0,0);
		
		for (j = 0; j < shpObject->nVertices; j++) {
			(*X)(j) = *(shpObject->padfX + j);
			(*Y)(j) = *(shpObject->padfY + j);
		}
		
		d_curv * res = create_curv(X, Y, name);

		surfit_curvs->push_back(res);
	}

	DBFClose( hDBF );
	SHPClose( hSHP );

	return true;
};
Exemplo n.º 16
0
void dibSHP::procesFile(Document_Interface *doc)
{
    int num_ent, st;
    double min_bound[4], max_bound[4];

    currDoc = doc;

    QFileInfo fi = QFileInfo(fileedit->text());
    if (fi.suffix() != "shp") {
        QMessageBox::critical ( this, "Shapefile", QString(tr("The file %1 not have extension .shp")).arg(fileedit->text()) );
        return;
    }

    if (!fi.exists() ) {
        QMessageBox::critical ( this, "Shapefile", QString(tr("The file %1 not exist")).arg(fileedit->text()) );
        return;
    }

    QString file = fi.canonicalFilePath ();

    SHPHandle sh = SHPOpen( file.toLocal8Bit(), "rb" );
    SHPGetInfo( sh, &num_ent, &st, min_bound, max_bound );
    DBFHandle dh = DBFOpen( file.toLocal8Bit(), "rb" );

    if (radiolay1->isChecked()) {
        layerF = -1;
        attdata.layer = currDoc->getCurrentLayer();
    } else {
        layerF = DBFGetFieldIndex( dh, (layerdata->currentText()).toLatin1().data() );
        layerT = DBFGetFieldInfo( dh, layerF, NULL, NULL, NULL );
    }
    if (radiocol1->isChecked())
        colorF = -1;
    else {
        colorF = DBFGetFieldIndex( dh, (colordata->currentText()).toLatin1().data() );
        colorT = DBFGetFieldInfo( dh, colorF, NULL, NULL, NULL );
    }
    if (radioltype1->isChecked())
        ltypeF = -1;
    else {
        ltypeF = DBFGetFieldIndex( dh, (ltypedata->currentText()).toLatin1().data() );
        ltypeT = DBFGetFieldInfo( dh, ltypeF, NULL, NULL, NULL );
    }
    if (radiolwidth1->isChecked())
        lwidthF = -1;
    else {
        lwidthF = DBFGetFieldIndex( dh, (lwidthdata->currentText()).toLatin1().data() );
        lwidthT = DBFGetFieldInfo( dh, lwidthF, NULL, NULL, NULL );
    }
    if (radiopoint1->isChecked())
        pointF = -1;
    else {
        pointF = DBFGetFieldIndex( dh, (pointdata->currentText()).toLatin1().data() );
        pointT = DBFGetFieldInfo( dh, pointF, NULL, NULL, NULL );
    }

    currlayer =currDoc->getCurrentLayer();
    for( int i = 0; i < num_ent; i++ ) {
        sobject= NULL;
        sobject = SHPReadObject( sh, i );
        if (sobject) {
            switch (sobject->nSHPType) {
            case SHPT_NULL:
                break;
            case SHPT_POINT:
            case SHPT_POINTM: //2d point with measure
            case SHPT_POINTZ: //3d point
                readPoint(dh, i);
                break;
            case SHPT_MULTIPOINT:
            case SHPT_MULTIPOINTM:
            case SHPT_MULTIPOINTZ:
                break;
            case SHPT_ARC:
            case SHPT_ARCM:
            case SHPT_ARCZ:
                readPolyline(dh, i);
                break;
            case SHPT_POLYGON:
            case SHPT_POLYGONM:
            case SHPT_POLYGONZ:
                readPolylineC(dh, i);
            case SHPT_MULTIPATCH:
                readMultiPolyline(dh, i);
            default:
                break;
            }
            SHPDestroyObject(sobject);
        }
    }

    SHPClose( sh );
    DBFClose( dh );
    currDoc->setLayer(currlayer);
}
Exemplo n.º 17
0
/**
 * Works when tree tops are being found in a partition of the original image because padding
 * isn't done.
 */
int checkPixelPart(float **gridded, float **orig, int i, int j, int wnd_size, int wnd_sqrd,
				double * mpsData, double ulEasting, double ulNorthing, SHPHandle hshp, DBFHandle hdbf)
{  
	int ii, jj, half, count = 0, maxi, maxj, nrecords;
	float max, height;
	
	height = gridded[i][j];
	half   = (wnd_size - 1)/2;
	
	for(ii = i - half; ii <= i + half; ii++)
	for(jj = j - half; jj <= j + half; jj++)
		if(gridded[ii][jj] < height)
			count++;
	
	if(count < wnd_sqrd-1)
	{	// not the highest tree in the window
		return 1;
	}
	
	//find the highest point in the original data set
	maxi = i-1, maxj = j-1;
	max  = orig[i-1][j-1];
	
	for(jj = j - 1; jj <= j + 1; jj++)
	for(ii = i - 1; ii <= i + 1; ii++)
		if(orig[ii][jj] > max)
		{
			max  = orig[ii][jj];
			maxi = ii;
			maxj = jj;
		}
		
	//
 	//Write point to shape file.
 	//
	SHPObject * shape;
	double * xpts, * ypts, * zpts;
	
	xpts = (double *) malloc(sizeof(double));
	ypts = (double *) malloc(sizeof(double));
	zpts = (double *) malloc(sizeof(double));
	
	xpts[0] = ulEasting + maxj * mpsData[0];
	ypts[0] = ulNorthing - maxi * mpsData[1];
	zpts[0] = (double)max;
	
	shape = SHPCreateSimpleObject(SHPT_POINT, 1, xpts, ypts, zpts);
	if(!shape){
		PyErr_SetString(PyExc_Exception, "SHPCreateSimpleObject failed.");
		return 0;
	}
	
	SHPWriteObject(hshp, -1, shape);
	SHPGetInfo(hshp, &nrecords, NULL, NULL, NULL);
	DBFWriteDoubleAttribute(
		hdbf, 
		nrecords-1, 
		DBFGetFieldIndex(hdbf, "Height"),
		(double)max
	);
	//DBFWriteNULLAttribute(
	//	hdbf, 
	//	nrecords-1, 
	//	DBFGetFieldIndex(hdbf, "TC Index")
	//);
	
	SHPDestroyObject(shape);
	free(xpts);free(ypts);
	
	return 1;
}
Exemplo n.º 18
0
d_points * _pnts_load_shp(const char * filename, const char * pntsname, const char * param) {

	SHPHandle hSHP;
	DBFHandle hDBF;
	
	hSHP = SHPOpen(filename, "rb");
	if( hSHP == NULL ) {
		writelog(LOG_ERROR, "Unable to open:%s", filename );
		return NULL;
	}

	int shpType;
	int Entities;
	SHPGetInfo(hSHP, &Entities, &shpType, NULL, NULL);

	if (shpType != SHPT_POINT) {
		SHPClose( hSHP );
		writelog(LOG_ERROR, "%s : Wrong shape type!", filename);
		return NULL;
	}

	hDBF = DBFOpen(filename, "rb");
	if( hDBF == NULL ) {
		SHPClose(hSHP);
		writelog(LOG_ERROR, "Unable to open DBF for %s", filename );
		return NULL;
	}

	int name_field = DBFGetFieldIndex( hDBF, "NAME" );
	if (name_field == -1)
		writelog(LOG_WARNING,"can't find field named \"NAME\"");

	int val_field = DBFGetFieldIndex( hDBF, param );
	
	if (val_field == -1) 
		writelog(LOG_WARNING, "Cannot find parameter \"%s\" in DBF file", param);
		
	int dbf_records = DBFGetRecordCount( hDBF );

	Entities = MIN(dbf_records, Entities);

	vec * X = create_vec(Entities, 0, 0);
	vec * Y = create_vec(Entities, 0, 0);
	
	int i;
	for (i = 0; i < Entities; i++) {
		SHPObject * shpObject = SHPReadObject( hSHP, i );
		if (shpObject == NULL)
			continue;

		const char * name = NULL;
		if (name_field != -1) {
			name = DBFReadStringAttribute( hDBF, i, name_field );
			if (pntsname != NULL) {
				if ( StringMatch(pntsname, name) == false )
					continue;
			}
		}

		(*X)(i) = *(shpObject->padfX);
		(*Y)(i) = *(shpObject->padfY);
		SHPDestroyObject(shpObject);
	}

	vec * Z = create_vec(Entities, 0, 0);
	for (i = 0; i < Entities; i++) {
		if (val_field != -1)
			(*Z)(i) = DBFReadDoubleAttribute( hDBF, i, val_field );
		else
			(*Z)(i) = 0;
	}

	DBFClose( hDBF );
	SHPClose( hSHP );

	char * fname = get_name(filename);
	d_points * res = create_points(X, Y, Z, fname);
	sstuff_free_char(fname);
	return res;

};
Exemplo n.º 19
0
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;
};
Exemplo n.º 20
0
int main(int argc, char *argv[])
{
    QCoreApplication myApp(argc, argv);

    // check input args
    QStringList inputArgs = myApp.arguments();

    if(inputArgs.size() < 2)   {
        qDebug() << "Error: No dbf directory: ";
        qDebug() << "Pass the dbf directory as an argument: ";
        qDebug() << "./dbf2sqlite /my/dbfdir";
        return -1;
    }

    // filter shapefile types
    QStringList dbfFilterList;
    dbfFilterList << "*.dbf";

    // check for all files
    QDir dbfDir = inputArgs[1];
    QStringList dbfDirList = dbfDir.entryList(dbfFilterList,
                                              QDir::Files);

    // get all file paths
    QString fileDbf;
    for(int i=0; i < dbfDirList.size(); i++)   {
        if(dbfDirList[i].contains(".dbf"))   {
            fileDbf = dbfDir.absoluteFilePath(dbfDirList[i]);
        }
    }

    // open the database file
    DBFHandle hDBF = DBFOpen(fileDbf.toLocal8Bit().data(),"rb");
    if(hDBF == NULL)   {
        qDebug() << "Error: Could not open dbf file";
        return -1;
    }

    // set fields to keep based on data type
    QStringList listFieldsToKeep;
    QString dbFileName;

    if(ADMIN0)   {
        dbFileName = "admin0.sqlite";
        listFieldsToKeep
                << "ADMIN"          // administrative name of country
                << "ADM0_A3";       // 3 letter abbreviatesion of admin name
    }

    if(ADMIN1)   {
        dbFileName = "admin1.sqlite";
        listFieldsToKeep
                << "OBJECTID"
                << "NAME_1"         // Admin1 region name
                << "VARNAME_1"      // Admin1 alt name (not very reliable)
                << "NL_NAME_1"      // Admin1 region name in national language (not reliable)
                << "Postal";        // 2 Letter Postal Code (not reliable)
    }

    // get number of fields in db
    size_t numRecords = 0;
    numRecords = DBFGetRecordCount(hDBF);

    if(numRecords > 0)
    {   qDebug() << "Info: DBF file has" << numRecords << "records";   }
    else
    {   qDebug() << "Error: DBF file has no records!";   return -1;   }

    // create sqlite database
    qDebug() << "Info: Creating SQLite Database...";
    Kompex::SQLiteDatabase * pDatabase =
            new Kompex::SQLiteDatabase(dbFileName.toStdString(),
                SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,0);

    Kompex::SQLiteStatement * pStmt =
            new Kompex::SQLiteStatement(pDatabase);

    // create database schema (flat)
    if(ADMIN1)   {
        qDebug() << "Info: Creating database schema for ADMIN1 profile";

        pStmt->SqlStatement("CREATE TABLE IF NOT EXISTS data("
                            "regionid INTEGER PRIMARY KEY NOT NULL UNIQUE,"
                            "name TEXT NOT NULL,"
                            "code TEXT);");

        // regionid <-> internel shape/record id [integer]
        size_t idx_objectid = DBFGetFieldIndex(hDBF,"OBJECTID");

        // name <-> NAME_1 [text]
        size_t idx_name = DBFGetFieldIndex(hDBF,"NAME_1");

        // code <-> Postal [text]
        size_t idx_code = DBFGetFieldIndex(hDBF,"Postal");

        qDebug() << "Info: Writing records to database...";
        pStmt->BeginTransaction();

        for(size_t i=0; i < numRecords; i++)
        {
            QString record_id = QString::number(i+1);
            QString record_name(DBFReadStringAttribute(hDBF,i,idx_name));
            QString record_code(DBFReadStringAttribute(hDBF,i,idx_code));

            QString inStmt = "INSERT INTO data(regionid,name,code) VALUES(\"" +
                    record_id + "\",\"" +record_name + "\",\"" + record_code + "\");";

            pStmt->SqlStatement(inStmt.toUtf8().data());

//            qDebug() << record_name;

            if(i % 1000 == 0)   {
                qDebug() << "Info: Wrote" << i+1 << "/" << numRecords << "records";
            }
        }

        pStmt->CommitTransaction();
        qDebug() << "Info: Done!";
    }

    // close dbf file
    DBFClose(hDBF);

    // clean up database
    delete pStmt;
    delete pDatabase;

    return 0;
}
Exemplo n.º 21
0
OGRErr OGRShapeLayer::CreateField( OGRFieldDefn *poFieldDefn, int bApproxOK )

{
    CPLAssert( NULL != poFieldDefn );
    
    int         iNewField;

    if( !bUpdateAccess )
    {
        CPLError( CE_Failure, CPLE_NotSupported,
                  "Can't create fields on a read-only shapefile layer.\n");
        return OGRERR_FAILURE;

    }

/* -------------------------------------------------------------------- */
/*      Normalize field name                                            */
/* -------------------------------------------------------------------- */
        
    char szNewFieldName[10 + 1];
    char * pszTmp = NULL;
    int nRenameNum = 1;

    size_t nNameSize = strlen( poFieldDefn->GetNameRef() );
    pszTmp = CPLScanString( poFieldDefn->GetNameRef(),
                                     MIN( nNameSize, 10) , TRUE, TRUE);
    strncpy(szNewFieldName, pszTmp, 10);
    szNewFieldName[10] = '\0';

    if( !bApproxOK &&
        ( DBFGetFieldIndex( hDBF, szNewFieldName ) >= 0 ||
          !EQUAL(poFieldDefn->GetNameRef(),szNewFieldName) ) )
    {
        CPLError( CE_Failure, CPLE_NotSupported,
                  "Failed to add field named '%s'",
                  poFieldDefn->GetNameRef() );
                  
        CPLFree( pszTmp );
        return OGRERR_FAILURE;
    }

    while( DBFGetFieldIndex( hDBF, szNewFieldName ) >= 0 && nRenameNum < 10 )
        sprintf( szNewFieldName, "%.8s_%.1d", pszTmp, nRenameNum++ );
    while( DBFGetFieldIndex( hDBF, szNewFieldName ) >= 0 && nRenameNum < 100 )
        sprintf( szNewFieldName, "%.8s%.2d", pszTmp, nRenameNum++ );

    CPLFree( pszTmp );
    pszTmp = NULL;
    
    if( DBFGetFieldIndex( hDBF, szNewFieldName ) >= 0 )
    {
        CPLError( CE_Failure, CPLE_NotSupported,
                  "Too many field names like '%s' when truncated to 10 letters "
                  "for Shapefile format.",
                  poFieldDefn->GetNameRef() );//One hundred similar field names!!?
    }

    if( !EQUAL(poFieldDefn->GetNameRef(),szNewFieldName) )
        CPLError( CE_Warning, CPLE_NotSupported,
                  "Normalized/laundered field name: '%s' to '%s'", 
                  poFieldDefn->GetNameRef(),
                  szNewFieldName );
                  
    // Set field name with normalized value
    OGRFieldDefn oModFieldDefn(poFieldDefn);
    oModFieldDefn.SetName(szNewFieldName);

/* -------------------------------------------------------------------- */
/*      Add field to layer                                              */
/* -------------------------------------------------------------------- */

    if( oModFieldDefn.GetType() == OFTInteger )
    {
        if( oModFieldDefn.GetWidth() == 0 )
            iNewField =
                DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTInteger, 10,0);
        else
            iNewField = DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTInteger,
                                     oModFieldDefn.GetWidth(), 0 );

        if( iNewField != -1 )
            poFeatureDefn->AddFieldDefn( &oModFieldDefn );
    }
    else if( oModFieldDefn.GetType() == OFTReal )
    {
        if( oModFieldDefn.GetWidth() == 0 )
            iNewField =
                DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTDouble, 24, 15 );
        else
            iNewField =
                DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTDouble,
                             oModFieldDefn.GetWidth(), oModFieldDefn.GetPrecision() );

        if( iNewField != -1 )
            poFeatureDefn->AddFieldDefn( &oModFieldDefn );
    }
    else if( oModFieldDefn.GetType() == OFTString )
    {
        if( oModFieldDefn.GetWidth() < 1 )
            iNewField =
                DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTString, 80, 0 );
        else
            iNewField = DBFAddField( hDBF, oModFieldDefn.GetNameRef(), FTString, 
                                     oModFieldDefn.GetWidth(), 0 );

        if( iNewField != -1 )
            poFeatureDefn->AddFieldDefn( &oModFieldDefn );
    }
    else if( oModFieldDefn.GetType() == OFTDate )
    {
        iNewField =
            DBFAddNativeFieldType( hDBF, oModFieldDefn.GetNameRef(), 'D', 8, 0 );

        if( iNewField != -1 )
            poFeatureDefn->AddFieldDefn( &oModFieldDefn );
    }
    else if( oModFieldDefn.GetType() == OFTDateTime )
    {
        CPLError( CE_Warning, CPLE_NotSupported,
                  "Field %s create as date field, though DateTime requested.\n",
                  oModFieldDefn.GetNameRef() );

        iNewField =
            DBFAddNativeFieldType( hDBF, oModFieldDefn.GetNameRef(), 'D', 8, 0 );

        if( iNewField != -1 )
        {
            oModFieldDefn.SetType( OFTDate );
            poFeatureDefn->AddFieldDefn( &oModFieldDefn );
        }
    }
    else
    {
        CPLError( CE_Failure, CPLE_NotSupported,
                  "Can't create fields of type %s on shapefile layers.\n",
                  OGRFieldDefn::GetFieldTypeName(oModFieldDefn.GetType()) );

        return OGRERR_FAILURE;
    }

    if( iNewField != -1 )
    {
        return OGRERR_NONE;
    }
    else        
    {
        CPLError( CE_Failure, CPLE_AppDefined,
                  "Can't create field %s in Shape DBF file, reason unknown.\n",
                  oModFieldDefn.GetNameRef() );

        return OGRERR_FAILURE;
    }
}
Exemplo n.º 22
0
/**
 * Create Delaunay 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.
 */
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;
  char boolWriteShape;
  int nShapes = 0;
  double padfMinBound[4];
  double padfMaxBound[4];
  int nDcidIndex = -1;
  char *pDCID;
  /**
   * Vectors to calculate plane parameters
   */
  double vector0[3];
  double vector1[3];
  /**
   * Plane parameters
   */
  double a,b,c,d;
  /**
   * Slope of the plane
   */
  double slope;
  /**
   * Elevation field (if provided)
   */
  int nElevationField = -1; 
 
  strcpy(vertex_line_name, "");
  num_vertices = 0;
  
  /* parameter check */
  if((((argc != 3)||
    ((!str_is_shp(argv[1])||(!str_is_shp(argv[2]))))))&&((argc != 4)||
    ((!str_is_shp(argv[1])||(!str_is_shp(argv[2])))))) {
    printf("shptriangle 0.1.0 (c) 2005,2006 Steffen Macke\n");
    printf("usage: shptriangle input_shapefile delaunay_shapefile [elevationfield]\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);
  }
  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(4 == argc) {
    nElevationField = DBFGetFieldIndex(hPointDBF, argv[3]);
    if(-1 == nElevationField) {
      printf("WARNING: Could not find elevation field '%s'.\n", argv[3]);
    }
  }
  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, "%d 2 0 0\n", nEntities);
  for(i=0; i<nEntities;i++) {
    psCShape = SHPReadObject(hPointSHP, i);
    fprintf(hTextFile, "%d %f %f\n", i+1, psCShape->dfXMin, psCShape->dfYMin);
    node_x[i] = psCShape->dfXMin;
    node_y[i] = psCShape->dfYMin;
    if(nElevationField > -1) {
      node_z[i] = DBFReadDoubleAttribute(hPointDBF, i, nElevationField);
    } else {
      node_z[i] = 0.0;
    }
  }
 
  fclose(hTextFile);
  SHPClose(hPointSHP);
  DBFClose(hPointDBF);
  system("triangle.exe -I shptriangle");
  
  hTextFile = fopen("shptriangle.ele", "rt");
  if(hTextFile == NULL) {
    printf("FATAL ERROR: Cannot open input file:%s\n", "shptriangle.ele");
    exit(1);
  }
  if(fgets(line, MAXLINE, hTextFile) == NULL) {
    printf("FATAL ERROR: Reading first line of shptriangle.ele\n");
    fclose(hTextFile);
    exit(1);
  }
  nPolygons = atoi(line);
  textpointer = strchr(line, ' ');
  num_vertices = atoi(textpointer);
  if(num_vertices != 3) {
    printf("FATAL ERROR: Wrong node count in first line of shptriangle.ele\n");
    fclose(hTextFile);
    exit(1);
  }
  //printf("%s\n", 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);
  //printf("%d polygons\n", nPolygons);
  
  hVoronoiSHP = SHPCreate(argv[2], SHPT_POLYGONZ);
  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);
  DBFAddField(hVoronoiDBF, "slope", FTDouble, 16, 8);
  for(i=0; i < nPolygons; i++) {
    //printf("Polygon %d\n", i);
    if(fgets(line, MAXLINE, hTextFile) == NULL) {
      printf("FATAL ERROR: shptriangle.ele does not contain enough polygons.\n");
      SHPClose(hVoronoiSHP);
      DBFClose(hVoronoiDBF);
      DBFClose(hPointDBF);
      fclose(hTextFile);
      exit(1);
    }
    nNodes = 0;
    textpointer = line;
    textpointer = strchr(strpbrk(line, "1234567890"), ' ');
    boolWriteShape = 1;
    for(j=0; j < num_vertices; j++) {
      textpointer = strpbrk(strchr(textpointer+1, ' '), "1234567890");
      nNodes++;
      nNodeRef = atoi(textpointer);
      if((nNodeRef < 0)||(nNodeRef > nEntities)) {
        printf("FATAL ERROR: shptriangle.ele contains illegal node reference.\n");
        SHPClose(hVoronoiSHP);
        DBFClose(hVoronoiDBF);
	DBFClose(hPointDBF);
        fclose(hTextFile);
        exit(1);
      }
      //printf("Node reference %d\n", nNodeRef);
      polygon_x[nNodes-1] = node_x[nNodeRef-1];
      polygon_y[nNodes-1] = node_y[nNodeRef-1];
      polygon_z[nNodes-1] = node_z[nNodeRef-1];
    }
    if(boolWriteShape == 1) {
      nNodes++;
      polygon_x[nNodes-1] = polygon_x[0];
      polygon_y[nNodes-1] = polygon_y[0];
      polygon_z[nNodes-1] = polygon_z[0];
      //printf("Polygon %d with %d nodes\n", i, nNodes);
      psCShape = SHPCreateSimpleObject( SHPT_POLYGONZ, nNodes, polygon_x, 
        polygon_y, polygon_z );
      SHPWriteObject(hVoronoiSHP, -1, psCShape);
      SHPDestroyObject(psCShape);
      DBFWriteStringAttribute(hVoronoiDBF, nShapes, 0, "");
      /**
       * Calculate slope.
       * Plane equation 0 = a*x + b*y + c*z + d
       * Sea level plane 0 = 0*x + 0*y + 1*z - 0 
       */
      vector0[0] = polygon_x[1] - polygon_x[0];
      vector0[1] = polygon_y[1] - polygon_y[0];
      vector0[2] = polygon_z[1] - polygon_z[0];
      
      vector1[0] = polygon_x[2] - polygon_x[0];
      vector1[1] = polygon_y[2] - polygon_y[0];
      vector1[2] = polygon_z[2] - polygon_z[0];

      /**
       * Use cross product to find plane equation. 
       */
      a = vector0[1] * vector1[2] - vector0[2] * vector1[1];
      b = -(vector0[0] * vector1[2] - vector0[2] * vector1[0]);
      c = vector0[0] * vector1[1] - vector0[1] * vector1[0];
      d = -(a * polygon_x[0] + b * polygon_y[0] + c * polygon_z[0]);
      /**
       * Calculate dihedral angle between sea level plane and triangle plane
       */
      slope = acos(c/(sqrt(a*a+b*b+c*c)))/3.141592654*180;
      DBFWriteDoubleAttribute(hVoronoiDBF, nShapes, 1, slope);
      nShapes++;
    }
 }
 SHPClose(hVoronoiSHP);
 DBFClose(hVoronoiDBF);
 DBFClose(hPointDBF);
 fclose(hTextFile);
}