예제 #1
0
bool ShapelibProxy::getTypeAndCount(const ShapelibHandle &handle, std::string &errorMessage, 
                                    ArcProxyLib::FeatureType &featureType, int &count)
{
   int type;
   SHPGetInfo(handle.getShpHandle(), &count, &type, NULL, NULL);

   featureType = ArcProxyLib::UNKNOWN;

   switch (type)
   {
   case SHPT_POINT:  // fall through
   case SHPT_POINTZ:
      featureType = ArcProxyLib::POINT;
      break;
   case SHPT_MULTIPOINT: // fall through
   case SHPT_MULTIPOINTZ:
      featureType = ArcProxyLib::MULTIPOINT;
      break;
   case SHPT_ARC: // fall through
   case SHPT_ARCZ:
      featureType = ArcProxyLib::POLYLINE;
      break;
   case SHPT_POLYGON: // fall through
   case SHPT_POLYGONZ:
      featureType = ArcProxyLib::POLYGON;
      break;
   default:
      errorMessage = "Unknown shape type";
      return false;
   }

   return true;

}
예제 #2
0
파일: dialog.cpp 프로젝트: jotr/qt-test
void loadMapData(std::string path, QPolygonF* poly)
{
    SHPHandle shp = SHPOpen(path.c_str(), "rb");
    if (shp != 0) {
        qDebug() << "Loaded map: " << path.c_str();
    } else {
        qDebug() << "Could not load map: " << path.c_str();
        return;
    }
    int entities, type;
    double minBound[4], maxBound[4];
    SHPGetInfo(shp, &entities, &type, minBound, maxBound);
//    qDebug() << "Type: " << type << " Entities: " << entities;

    SHPObject* o = SHPReadObject(shp, 0);

    int parts = o->nParts;

//    qDebug() << "Parts: " << parts;

    int currentPart = 0;
    int start = o->panPartStart[currentPart];
    int end = parts == 1 ? o->nVertices : o->panPartStart[currentPart + 1];

//    qDebug() << "Start: " << start << " End: " << end << " Vertices: " << o->nVertices;

    for(int i = start; i < end; i++) {
        double x = o->padfX[i];
        double y = o->padfY[i];
        *poly << QPointF(x, y);
    }
}
예제 #3
0
bool vtUtilityMap::ImportPolesFromSHP(const char *fname)
{
	SHPHandle hSHP;
	int		nEntities, nShapeType;
	DPoint2 point;

	// SHPOpen doesn't yet support utf-8 or wide filenames, so convert
	vtString fname_local = UTF8ToLocal(fname);

	hSHP = SHPOpen(fname_local, "rb");
	if (!hSHP)
		return false;

	SHPGetInfo(hSHP, &nEntities, &nShapeType, NULL, NULL);
	if (nShapeType != SHPT_POINT)
		return false;

	for (int i = 0; i < nEntities; i++)
	{
		SHPObject *psShape = SHPReadObject(hSHP, i);
		point.x = psShape->padfX[0];
		point.y = psShape->padfY[0];
		vtPole *pole = new vtPole;
		pole->m_p = point;
		m_Poles.Append(pole);
		SHPDestroyObject(psShape);
	}
	SHPClose(hSHP);
	return true;
}
예제 #4
0
//CAREFUL:  note how adding things to the tree can change the root
// Must not ever use cache a value of the root pointer if there's any
// chance that the tree needs to be expanded!
void build_rtree (struct Node **root, SHPHandle sHP) {
    int nEntities;
    intptr_t i;
    SHPObject	*psCShape;
    struct Rect bbox_shape;
    SHPGetInfo(sHP, &nEntities, NULL, NULL, NULL);
    for( i = 0; i < nEntities; i++ ) {
        psCShape = SHPReadObject ( sHP, i );
     	if (psCShape != NULL) {
            bbox_shape.boundary[0]=(RectReal) psCShape->dfXMin;
            bbox_shape.boundary[1]=(RectReal) psCShape->dfYMin;
            bbox_shape.boundary[2]=(RectReal) psCShape->dfXMax;
            bbox_shape.boundary[3]=(RectReal) psCShape->dfYMax;
            SHPDestroyObject ( psCShape );
            // Only insert the rect if it will not fail the assertion in 
            // Xastir_RTreeInsertRect --- this will cause us to ignore any shapes that
            // have invalid bboxes (or that return invalid bboxes from shapelib
            // for whatever reason
            if (bbox_shape.boundary[0] <= bbox_shape.boundary[2] &&
                    bbox_shape.boundary[1] <= bbox_shape.boundary[3]) {
                Xastir_RTreeInsertRect(&bbox_shape, (void *)(i+1), root, 0);
            }
        }
    }
}
예제 #5
0
    void parse(const std::string& path, Visitor& visitor) const
    {
        SHPHandle shpFile = SHPOpen(path.c_str(), "rb");
        if (shpFile == NULL)
            throw std::domain_error("Cannot open shp file.");

        int shapeType, entityCount;
        double adfMinBound[4], adfMaxBound[4];
        SHPGetInfo(shpFile, &entityCount, &shapeType, adfMinBound, adfMaxBound);

        DBFHandle dbfFile = DBFOpen(path.c_str(), "rb");
        if (dbfFile == NULL)
            throw std::domain_error("Cannot open dbf file.");

        if (DBFGetFieldCount(dbfFile) == 0)
            throw std::domain_error("There are no fields in dbf table.");

        if (entityCount != DBFGetRecordCount(dbfFile))
            throw std::domain_error("dbf file has different entity count.");

        for (int k = 0; k < entityCount; k++)
        {
            SHPObject* shape = SHPReadObject(shpFile, k);
            if (shape == NULL)
                throw std::domain_error("Unable to read shape:" + to_string(k));

            Tags tags = parseTags(dbfFile, k);
            visitShape(*shape, tags, visitor);

            SHPDestroyObject(shape);
        }

        DBFClose(dbfFile);
        SHPClose(shpFile);
    }
예제 #6
0
// ---------------------------------------------------------------------------
// 
// -----------
SHPObject* bSHPTable::vxs2shape(int o, ivertices* vxs){
int			count;
int			ptype;
double		bmin[4],bmax[4];
SHPObject*	obj;
	SHPGetInfo(_shp,&count,&ptype,bmin,bmax);

	if(ptype==SHPT_NULL){
		obj=SHPCreateSimpleObject(ptype,0,NULL,NULL,NULL);
	}
	else{
double*		x=(double*)malloc(ivs_n_vxs(vxs)*sizeof(double));
double*		y=(double*)malloc(ivs_n_vxs(vxs)*sizeof(double));
int			np=(ivs_n_parts(vxs)>1)?ivs_n_parts(vxs):0;
int*		p=(ivs_n_parts(vxs)>1)?(int*)malloc(ivs_n_parts(vxs)*sizeof(int)):NULL;
int*		pt=(ivs_n_parts(vxs)>1)?(int*)malloc(ivs_n_parts(vxs)*sizeof(int)):NULL;

dvertices*	dvxs=NULL;
		vxs_i2d(&dvxs,vxs,_reso);
		dvs_move(dvxs,_ox,_oy);
		transform_a2t(dvxs);

		if(p){
			memmove(p,vxs->offs,vxs->no*sizeof(int));
			memset(pt,SHPP_RING,vxs->no*sizeof(int));
		}
		for(int i=0;i<ivs_n_vxs(vxs);i++){
			x[i]=dvxs->vx.vx2[i].x;
			y[i]=dvxs->vx.vx2[i].y;
		}
		dvs_free(dvxs);
		obj=SHPCreateObject(ptype,o-1,np,p,pt,ivs_n_vxs(vxs),x,y,NULL,NULL);
	}
	return(obj);
}
int count_shape_points(char *shape_name)
{
    int entidades;
    SHPHandle arquivo_shp;
    arquivo_shp=SHPOpen(shape_name, "r");
    SHPGetInfo(arquivo_shp,&entidades,NULL,NULL,NULL);
    return entidades;
}
예제 #8
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;
	}	
}
예제 #9
0
// ---------------------------------------------------------------------------
// 
// -----------
int	bSHPTable::CountRecords(){
	if(!_shp){
		return(0);
	}
int		count;
int		ptype;
double	bmin[4],bmax[4];
	SHPGetInfo(_shp,&count,&ptype,bmin,bmax);
	return(count);
}
예제 #10
0
파일: shape.c 프로젝트: peko/tttm2
shapes_v
shape_load_globe(const char* filename) {

    shapes_v globe;
    kv_init(globe);

    double  adfMinBound[4],
            adfMaxBound[4];

    // Read file
    SHPHandle hSHP = SHPOpen( filename, "rb" );
    if(hSHP == NULL) goto end_loading;

    // Print shape bounds
    int country_count, shapes_vype;
    SHPGetInfo( hSHP, &country_count, &shapes_vype, adfMinBound, adfMaxBound );
    
    fprintf(stderr, "Load %d countries\n", country_count);
    // Iterate through countries
    for(int i = 0; i < country_count; i++ ) {
                        
        SHPObject *shp = SHPReadObject(hSHP, i);
        if(shp == NULL) goto end_loading;

        if(shp->nParts == 0) continue;

        // first part starts at point 0
        if(shp->panPartStart[0] != 0) goto end_loading;

        // collect parts of country
        uint32_t parts = shp->nParts;
        for (uint32_t j=0; j<parts; j++) {
            // start index
            uint32_t s = shp->panPartStart[j];
            // end index - start of next minus one, or end
            uint32_t e = (j+1 < parts) ?
                shp->panPartStart[j+1]:
                shp->nVertices;
            shape_v shape;
            kv_init(shape);
            // collect points of part
            for(uint32_t i=s; i<e; i++){
                point_t p = (point_t){shp->padfX[i], shp->padfY[i]};
                kv_push(point_t, shape, p);
            }
            kv_push(shape_v, globe, shape);
        }
        SHPDestroyObject( shp );
    }
    SHPClose( hSHP );

end_loading:
    return globe;
}
예제 #11
0
static int shapelib_len(lua_State *ls)
{
    SHPHandle shp = checkshphandle(ls);

    int entcount;
    SHPGetInfo(shp, &entcount, 0, 0, 0);

    lua_pushnumber(ls, entcount);

    return 1;
} 
예제 #12
0
bool vtUtilityMap::ImportLinesFromSHP(const char *fname)
{
	SHPHandle hSHP;
	int		nEntities, nShapeType;
	int		i, j, verts;

	// SHPOpen doesn't yet support utf-8 or wide filenames, so convert
	vtString fname_local = UTF8ToLocal(fname);

	hSHP = SHPOpen(fname_local, "rb");
	if (!hSHP)
		return false;

	SHPGetInfo(hSHP, &nEntities, &nShapeType, NULL, NULL);
	if (nShapeType != SHPT_ARC)
		return false;

	for (i = 0; i < nEntities; i++)
	{
		SHPObject *psShape = SHPReadObject(hSHP, i);

		verts = psShape->nVertices;
		vtLine *line = new vtLine;
		line->SetSize(verts);

		// Store each SHP Poly Coord in Line
		for (j = 0; j < verts; j++)
		{
			line->GetAt(j).x = psShape->padfX[j];
			line->GetAt(j).y = psShape->padfY[j];
		}
		SHPDestroyObject(psShape);

		// Guess source and destination poles by using location
		line->m_src = ClosestPole(line->GetAt(0));
		line->m_dst = ClosestPole(line->GetAt(verts-1));

		// avoid degenerate lines
		if (line->m_src == line->m_dst)
		{
			delete line;
			continue;
		}

		// tweak start and end of line to match poles
		line->SetAt(0, line->m_src->m_p);
		line->SetAt(verts-1, line->m_dst->m_p);

		m_Lines.Append(line);
	}
	SHPClose(hSHP);
	return true;
}
예제 #13
0
    shape_reader(std::string const& name)
    {
        m_shp = ::SHPOpen((name + ".shp").c_str(), "rb");
        m_dbf = ::DBFOpen((name + ".dbf").c_str(), "rb");

        if (m_shp == NULL || m_dbf == NULL)
        {
            throw shapelib_file_open_exception(name);
        }

        double adfMinBound[4], adfMaxBound[4];
        SHPGetInfo(m_shp, &m_count, &m_shape_type, adfMinBound, adfMaxBound );

    }
예제 #14
0
int GetSHPType(const char *filename)
{
	// SHPOpen doesn't yet support utf-8 or wide filenames, so convert
	vtString fname_local = UTF8ToLocal(filename);

	SHPHandle hSHP = SHPOpen(fname_local, "rb");
	if (hSHP == NULL)
		return SHPT_NULL;

	int nEntities, nShapeType;

	SHPGetInfo(hSHP, &nEntities, &nShapeType, NULL, NULL);
	SHPClose(hSHP);
	return nShapeType;
}
예제 #15
0
// ---------------------------------------------------------------------------
// Constructeur
// ------------
bSHPTable	::bSHPTable(	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_("bSHPTable::bSHPTable",false);
int			ptype=db2shp(*status);
	
char	fpath[1024];
	
	sprintf(fpath,"%s%s",path,name);
//_tm_(fpath);
	_shp=SHPOpen(fpath,"rb+");
	if(!_shp){
//_te_("SHPOpen failed for rb+");
		_shp=SHPOpen(fpath,"rb");
	}
//_tm_("SHPOpen passed");
	if(_shp){
int		count;
double	bmin[4],bmax[4];
//_tm_("SHPGetInfo");
		SHPGetInfo(_shp,&count,&ptype,bmin,bmax);
//_tm_(count+" objects of "+ptype+" kind");
		*status=shp2db(ptype);
		return;
	}
//_te_("SHPOpen failed for rb");

	if(!create){
		*status=-1;
_te_(fpath+" : table not found");
		return;
	}
	_shp=SHPCreate(fpath,ptype);
	if(!_shp){
_te_(fpath+" : creation failed");
		*status=-1;
		return;
	}
	*status=0;
}
예제 #16
0
파일: Rshapeinfo.c 프로젝트: cran/maptools
SEXP Rshapeinfo1(SEXP shpname)

{
    SEXP res, nms;
    SHPHandle	hSHP;
    int    nShapeType, nEntities, i, pc=0;
    double  adfMinBound[4], adfMaxBound[4];
    PROTECT(res = NEW_LIST(5)); pc++;
    PROTECT(nms = NEW_CHARACTER(5)); pc++;
    SET_STRING_ELT(nms, 0, COPY_TO_USER_STRING("fname"));
    SET_STRING_ELT(nms, 1, COPY_TO_USER_STRING("type"));
    SET_STRING_ELT(nms, 2, COPY_TO_USER_STRING("entities"));
    SET_STRING_ELT(nms, 3, COPY_TO_USER_STRING("minbounds"));
    SET_STRING_ELT(nms, 4, COPY_TO_USER_STRING("maxbounds"));
    setAttrib(res, R_NamesSymbol, nms);
    SET_VECTOR_ELT(res, 0, NEW_CHARACTER(1));
    SET_VECTOR_ELT(res, 1, NEW_INTEGER(1));
    SET_VECTOR_ELT(res, 2, NEW_INTEGER(1));
    SET_VECTOR_ELT(res, 3, NEW_NUMERIC(4));
    SET_VECTOR_ELT(res, 4, NEW_NUMERIC(4));
    SET_STRING_ELT(VECTOR_ELT(res, 0), 0, STRING_ELT(shpname, 0));
    
/*      const char 	*pszPlus; */
/* -------------------------------------------------------------------- */
/*      Open the passed shapefile.                                      */
/* -------------------------------------------------------------------- */
    hSHP = SHPOpen(CHAR(STRING_ELT(shpname, 0)), "rb" );

    if( hSHP == NULL ) error("Error opening SHP file");

/* -------------------------------------------------------------------- */
/*      Print out the file bounds.                                      */
/* -------------------------------------------------------------------- */
    SHPGetInfo( hSHP, &nEntities, &nShapeType, adfMinBound, adfMaxBound ); 
    INTEGER_POINTER(VECTOR_ELT(res, 1))[0] = nShapeType;
    INTEGER_POINTER(VECTOR_ELT(res, 2))[0] = nEntities;
    for (i=0; i<4; i++) { 
        NUMERIC_POINTER(VECTOR_ELT(res, 3))[i] = adfMinBound[i];
        NUMERIC_POINTER(VECTOR_ELT(res, 4))[i] = adfMaxBound[i];
    }

    SHPClose( hSHP );   
    UNPROTECT(pc);
    return(res);
}
예제 #17
0
static int shapelib_getinfo(lua_State *ls)
{
    SHPHandle shp = checkshphandle(ls);

    int entcount;
    int shptype; 
    double min[4];
    double max[4];

    SHPGetInfo(shp, &entcount, &shptype, min, max);

    lua_pushnumber(ls, entcount);
    lua_pushnumber(ls, shptype);
    for (int i = 0; i < 4; ++i) lua_pushnumber(ls, min[i]);
    for (int i = 0; i < 4; ++i) lua_pushnumber(ls, max[i]);

    return 10;
}
예제 #18
0
OGRErr OGRShapeLayer::GetExtent (OGREnvelope *psExtent, int bForce)

{
    UNREFERENCED_PARAM( bForce );

    double adMin[4], adMax[4];

    if( hSHP == NULL )
        return OGRERR_FAILURE;

    SHPGetInfo(hSHP, NULL, NULL, adMin, adMax);

    psExtent->MinX = adMin[0];
    psExtent->MinY = adMin[1];
    psExtent->MaxX = adMax[0];
    psExtent->MaxY = adMax[1];

    return OGRERR_NONE;
}
예제 #19
0
//  Function to read outlets from a shapefile
int readoutlets(char *outletsfile, int *noutlets, double*& x, double*& y)
{
	SHPHandle shp;
	shp = SHPOpen(outletsfile, "rb");
	if (shp != 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;
		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];
		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];
				nxy++;
			}
			SHPDestroyObject(shape);
		}
		*noutlets=nxy;
		SHPClose(shp);
		return 0;
	}
	else { 
		fprintf(stderr, "Error opening outlets shapefile %s.\n", outletsfile);
		fflush(stderr);
		return 1;
	}	
}
예제 #20
0
파일: Rshapeinfo.c 프로젝트: cran/maptools
void Rshapeinfo(char **shpnm, int *Shapetype, int *Entities, double
		*MinBound, double *MaxBound)

{
    SHPHandle	hSHP;
    int    nShapeType, nEntities, i;
    double  adfMinBound[4], adfMaxBound[4];
/*      const char 	*pszPlus; */
/* -------------------------------------------------------------------- */
/*      Open the passed shapefile.                                      */
/* -------------------------------------------------------------------- */
    hSHP = SHPOpen( shpnm[0] , "rb" );

    if( hSHP == NULL )
    {
/*	REprintf( "Unable to open:%s\n", shpnm[0] );
	exit( 1 ); */
	error("No such file");
    }

/* -------------------------------------------------------------------- */
/*      Print out the file bounds.                                      */
/* -------------------------------------------------------------------- */
      SHPGetInfo( hSHP, &nEntities, &nShapeType, adfMinBound, adfMaxBound ); 
    
      *Entities = nEntities; 
      *Shapetype = nShapeType;
      for (i=0;i<4;i++){ 
        MinBound[i]=adfMinBound[i];
        MaxBound[i]=adfMaxBound[i];
    }

/*    Rprintf ("Info for %s\n", shpnm[0]);
    Rprintf("Shapefile Type: %s(%d)   # of Shapes: %ld\n\n",
            SHPTypeName( nShapeType ), nShapeType, nEntities );
    Rprintf("File Bounds: (%15.10lg,%15.10lg)\n\t(%15.10lg,%15.10lg)\n",
	    MinBound[0], MinBound[1], MaxBound[0], MaxBound[1] );*/
    

    SHPClose( hSHP );   
    return;
}
예제 #21
0
///////////////////////////////////////////////////////////////////////////////
// Liefert Objekttyp des Layers
OBJECTTYPE CArcViewLayer::GetType() 
{
OBJECTTYPE rgType = OBJECTTYPE_Unknown;

#if defined(_DEBUG)
int iCnt = 0;
int nShapeType = 0;

	SHPGetInfo (m_hSHP, &iCnt, &nShapeType, NULL, NULL);
	_ASSERTE(m_nShapeType == nShapeType);
#endif // defined(_DEBUG)

	switch (m_nShapeType) {
	case SHPT_POINT:
	case SHPT_POINTM:
	case SHPT_POINTZ:
		rgType = OBJECTTYPE_Point;
		break;

	case SHPT_MULTIPOINT:
	case SHPT_MULTIPOINTM:
	case SHPT_MULTIPOINTZ:
		break;

	case SHPT_ARC:
	case SHPT_ARCM:
	case SHPT_ARCZ:
		rgType = OBJECTTYPE_Line;
		break;

	case SHPT_POLYGON:
	case SHPT_POLYGONZ:
	case SHPT_POLYGONM:
		rgType = OBJECTTYPE_Area;
		break;
	}

	_ASSERTE(OBJECTTYPE_Unknown != rgType || iCnt == 0);
	return rgType;
}
예제 #22
0
int isshape(char *inFile)
{
    char *ext = findExt(inFile);
    if (ext && strcmp_case(ext,".shp")!=0) {
        return FALSE;
    }

    char *dbaseFile, *basename;
    int isShape = 0;
    int nEntities, pointType;
    DBFHandle dbase;
    SHPHandle shape;

    dbaseFile = (char *)MALLOC(sizeof(char)*(strlen(inFile)+5));
    basename = get_basename(inFile);
    sprintf(dbaseFile, "%s.dbf", basename);
    dbase = DBFOpen(dbaseFile, "r+b");
    shape = SHPOpen(inFile, "r+b");
    if (dbase != NULL && shape != NULL) {
        SHPGetInfo(shape, &nEntities, &pointType, NULL, NULL);
        if (nEntities >= 1 &&
            (pointType == SHPT_POLYGON   ||
             pointType == SHPT_POINT     ||
             pointType == SHPT_ARC       ||
             pointType == SHPT_MULTIPOINT )
        )
        {
            isShape = 1;
        }
    }
    if (shape) SHPClose(shape);
    if (dbase) DBFClose(dbase);
    FREE(basename);
    FREE(dbaseFile);

    return isShape;
}
예제 #23
0
/* -------------------------------------------------------------------- */
void printHeader(DBFHandle xDBF, SHPHandle xSHP)
{
double 	adfMinBound[4], adfMaxBound[4];
int     xEntities;
int     xShapeType;
int     nWidth, nDecimals;
int     i;
char    szTitle[12];

        SHPGetInfo( xSHP, &xEntities, &xShapeType, adfMinBound, adfMaxBound );
        printf( "Shapefile Type: %s, %d shapes ",
            SHPTypeName( xShapeType ), xEntities );

        printf( "%d database records\n", DBFGetRecordCount(xDBF) );
        if( bVerbose ) 
        {
            for( i = 0; i < DBFGetFieldCount(xDBF); i++ )
            {
                DBFFieldType        eType;
                const char          *pszTypeName;

                eType = DBFGetFieldInfo( xDBF, i, szTitle, &nWidth, &nDecimals );
                if( eType == FTString )
                    pszTypeName = "String";
                else if( eType == FTInteger )
                    pszTypeName = "Integer";
                else if( eType == FTDouble )
                    pszTypeName = "Double";
                else if( eType == FTInvalid )
                    pszTypeName = "Invalid";

                printf( "Field %d: Type=%s, Title=`%s', Width=%d, Decimals=%d\n",
                        i, pszTypeName, szTitle, nWidth, nDecimals );
            }
        }
}
예제 #24
0
파일: shpinfo.c 프로젝트: dranch/Xastir
int main( int argc, char ** argv )

{
    SHPHandle	hSHP;
//    SHPHandle   cSHP;
    int		nShapeType, nEntities;
//    int     nVertices, nParts, *panParts, i, iPart;
    double	adfBndsMin[4], adfBndsMax[4];
//    double  *padVertices;
//    const char 	*pszPlus;
//    int		cShapeType, cEntities, cVertices, cParts, *cpanParts, ci, cPart;
//    double	*cpadVertices, cadBounds[4];
//    const char 	*cpszPlus;
    char	sType [15]= "";
/* -------------------------------------------------------------------- */
/*      Display a usage message.                                        */
/* -------------------------------------------------------------------- */
    if( argc != 2 )
    {
	printf( "shpinfo shp_file\n" );
	exit( 1 );
    }

/* -------------------------------------------------------------------- */
/*      Open the passed shapefile.                                      */
/* -------------------------------------------------------------------- */
    hSHP = SHPOpen( argv[1], "rb" );

    if( hSHP == NULL )
    {
	printf( "Unable to open:%s\n", argv[1] );
	exit( 1 );
    }

    SHPGetInfo( hSHP, &nEntities, &nShapeType, adfBndsMin, adfBndsMax );
    
    switch ( nShapeType ) {
       case SHPT_POINT:
		strcpy(sType,"Point");
		break;

       case SHPT_ARC:
		strcpy(sType,"Polyline");
		break;

       case SHPT_POLYGON:
		strcpy(sType,"Polygon");
		break;

       case SHPT_MULTIPOINT:
		strcpy(sType,"MultiPoint");
		break;
        }

/* -------------------------------------------------------------------- */
   printf ("Info for %s\n",argv[1]);
   printf ("%s(%d), %d Records in file\n",sType,nShapeType,nEntities);

/* -------------------------------------------------------------------- */
/*      Print out the file bounds.                                      */
/* -------------------------------------------------------------------- */
    printf( "File Bounds: (%15.10lg,%15.10lg)\n\t(%15.10lg,%15.10lg)\n",
	    adfBndsMin[0], adfBndsMin[1], adfBndsMax[0], adfBndsMax[1] );



    SHPClose( hSHP );
    return(0);
}
예제 #25
0
SHPCreateTree( SHPHandle hSHP, int nDimension, int nMaxDepth,
               double *padfBoundsMin, double *padfBoundsMax )

{
    SHPTree	*psTree;

    if( padfBoundsMin == NULL && hSHP == NULL )
        return NULL;

/* -------------------------------------------------------------------- */
/*      Allocate the tree object                                        */
/* -------------------------------------------------------------------- */
    psTree = (SHPTree *) malloc(sizeof(SHPTree));

    psTree->hSHP = hSHP;
    psTree->nMaxDepth = nMaxDepth;
    psTree->nDimension = nDimension;

/* -------------------------------------------------------------------- */
/*      If no max depth was defined, try to select a reasonable one     */
/*      that implies approximately 8 shapes per node.                   */
/* -------------------------------------------------------------------- */
    if( psTree->nMaxDepth == 0 && hSHP != NULL )
    {
        int	nMaxNodeCount = 1;
        int	nShapeCount;

        SHPGetInfo( hSHP, &nShapeCount, NULL, NULL, NULL );
        while( nMaxNodeCount*4 < nShapeCount )
        {
            psTree->nMaxDepth += 1;
            nMaxNodeCount = nMaxNodeCount * 2;
        }
    }

/* -------------------------------------------------------------------- */
/*      Allocate the root node.                                         */
/* -------------------------------------------------------------------- */
    psTree->psRoot = SHPTreeNodeCreate( padfBoundsMin, padfBoundsMax );

/* -------------------------------------------------------------------- */
/*      Assign the bounds to the root node.  If none are passed in,     */
/*      use the bounds of the provided file otherwise the create        */
/*      function will have already set the bounds.                      */
/* -------------------------------------------------------------------- */
    if( padfBoundsMin == NULL )
    {
        SHPGetInfo( hSHP, NULL, NULL,
                    psTree->psRoot->adfBoundsMin, 
                    psTree->psRoot->adfBoundsMax );
    }

/* -------------------------------------------------------------------- */
/*      If we have a file, insert all it's shapes into the tree.        */
/* -------------------------------------------------------------------- */
    if( hSHP != NULL )
    {
        int	iShape, nShapeCount;
        
        SHPGetInfo( hSHP, &nShapeCount, NULL, NULL, NULL );

        for( iShape = 0; iShape < nShapeCount; iShape++ )
        {
            SHPObject	*psShape;
            
            psShape = SHPReadObject( hSHP, iShape );
            SHPTreeAddShapeId( psTree, psShape );
            SHPDestroyObject( psShape );
        }
    }        

    return psTree;
}
예제 #26
0
파일: shape.c 프로젝트: peko/tttm2
countries_v
shape_load_countries(const char* filename) {

    countries_v countries;
    kv_init(countries);

    double  adfMinBound[4],
            adfMaxBound[4];

    // Read file
    SHPHandle hSHP = SHPOpen( filename, "rb" );
    if(hSHP == NULL) goto end_loading;

    // Print shape bounds
    int country_count, shapes_vype;
    SHPGetInfo( hSHP, &country_count, &shapes_vype, adfMinBound, adfMaxBound );
    
    fprintf(stderr, "Load %d countries\n", country_count);
    // Iterate through countries
    for(int i = 0; i < country_count; i++ ) {
                        
        SHPObject *shp = SHPReadObject(hSHP, i);
        if(shp == NULL) goto end_loading;

        if(shp->nParts == 0) continue;

        // first part starts at point 0
        if(shp->panPartStart[0] != 0) goto end_loading;

        // collect parts of country
        shapes_v shapes;
        kv_init(shapes);
        shapes.min = (point_t){shp->dfXMin, shp->dfYMin};
        shapes.max = (point_t){shp->dfXMax, shp->dfYMax};

        uint32_t parts = shp->nParts;
        double k = 0.0;
        for (uint32_t j=0; j<parts; j++) {
            // start index
            uint32_t s = shp->panPartStart[j];
            // end index - start of next minus one, or end
            uint32_t e = (j+1 < parts) ?
                shp->panPartStart[j+1]:
                shp->nVertices;
            shape_v shape;
            kv_init(shape);
            // collect points of part
            for(uint32_t i=s; i<e; i++){
                point_t p = (point_t){shp->padfX[i], shp->padfY[i]};
                kv_push(point_t, shape, p);
                // cumulitive average for center
                if(k>=1.0) {
                    shapes.center.x = (k-1.0)/k*shapes.center.x + p.x/k;
                    shapes.center.y = (k-1.0)/k*shapes.center.y + p.y/k;
                }else {
                    shapes.center.x = p.x;
                    shapes.center.y = p.y;
                }
                k+=1.0;
            }
            kv_push(shape_v, shapes, shape);
        }
        SHPDestroyObject( shp );
        kv_push(shapes_v, countries, shapes);
    }
    SHPClose( hSHP );

end_loading:
    return countries;
}
예제 #27
0
파일: shptree.c 프로젝트: carlosvKC/iRp2
    SHPCreateTree( SHPHandle hSHP, int nDimension, int nMaxDepth,
                   double *padfBoundsMin, double *padfBoundsMax )

{
    SHPTree	*psTree;

    if( padfBoundsMin == NULL && hSHP == NULL )
        return NULL;

/* -------------------------------------------------------------------- */
/*      Allocate the tree object                                        */
/* -------------------------------------------------------------------- */
    psTree = (SHPTree *) malloc(sizeof(SHPTree));
    if( NULL == psTree )
    {
        return NULL;
    }

    psTree->hSHP = hSHP;
    psTree->nMaxDepth = nMaxDepth;
    psTree->nDimension = nDimension;
    psTree->nTotalCount = 0;

/* -------------------------------------------------------------------- */
/*      If no max depth was defined, try to select a reasonable one     */
/*      that implies approximately 8 shapes per node.                   */
/* -------------------------------------------------------------------- */
    if( psTree->nMaxDepth == 0 && hSHP != NULL )
    {
        int	nMaxNodeCount = 1;
        int	nShapeCount;

        SHPGetInfo( hSHP, &nShapeCount, NULL, NULL, NULL );
        while( nMaxNodeCount*4 < nShapeCount )
        {
            psTree->nMaxDepth += 1;
            nMaxNodeCount = nMaxNodeCount * 2;
        }

#ifdef USE_CPL
        CPLDebug( "Shape",
                  "Estimated spatial index tree depth: %d",
                  psTree->nMaxDepth );
#endif

        /* NOTE: Due to problems with memory allocation for deep trees,
         * automatically estimated depth is limited up to 12 levels.
         * See Ticket #1594 for detailed discussion.
         */
        if( psTree->nMaxDepth > MAX_DEFAULT_TREE_DEPTH )
        {
            psTree->nMaxDepth = MAX_DEFAULT_TREE_DEPTH;

#ifdef USE_CPL
            CPLDebug( "Shape",
                      "Falling back to max number of allowed index tree levels (%d).",
                      MAX_DEFAULT_TREE_DEPTH );
#endif
        }
    }

/* -------------------------------------------------------------------- */
/*      Allocate the root node.                                         */
/* -------------------------------------------------------------------- */
    psTree->psRoot = SHPTreeNodeCreate( padfBoundsMin, padfBoundsMax );
    if( NULL == psTree->psRoot )
    {
        return NULL;
    }

/* -------------------------------------------------------------------- */
/*      Assign the bounds to the root node.  If none are passed in,     */
/*      use the bounds of the provided file otherwise the create        */
/*      function will have already set the bounds.                      */
/* -------------------------------------------------------------------- */
    assert( NULL != psTree );
    assert( NULL != psTree->psRoot );
	
    if( padfBoundsMin == NULL )
    {
        SHPGetInfo( hSHP, NULL, NULL,
                    psTree->psRoot->adfBoundsMin, 
                    psTree->psRoot->adfBoundsMax );
    }

/* -------------------------------------------------------------------- */
/*      If we have a file, insert all it's shapes into the tree.        */
/* -------------------------------------------------------------------- */
    if( hSHP != NULL )
    {
        int	iShape, nShapeCount;
        
        SHPGetInfo( hSHP, &nShapeCount, NULL, NULL, NULL );

        for( iShape = 0; iShape < nShapeCount; iShape++ )
        {
            SHPObject	*psShape;
            
            psShape = SHPReadObject( hSHP, iShape );
            if( psShape != NULL )
            {
                SHPTreeAddShapeId( psTree, psShape );
                SHPDestroyObject( psShape );
            }
        }
    }        

    return psTree;
}
예제 #28
0
int main( int argc, char ** argv )

{
    SHPHandle	hSHP;
    int		nShapeType, nEntities, i, iPart, bValidate = 0,nInvalidCount=0;
    int         bHeaderOnly = 0;
    const char 	*pszPlus;
    double 	adfMinBound[4], adfMaxBound[4];

    if( argc > 1 && strcmp(argv[1],"-validate") == 0 )
    {
        bValidate = 1;
        argv++;
        argc--;
    }

    if( argc > 1 && strcmp(argv[1],"-ho") == 0 )
    {
        bHeaderOnly = 1;
        argv++;
        argc--;
    }

/* -------------------------------------------------------------------- */
/*      Display a usage message.                                        */
/* -------------------------------------------------------------------- */
    if( argc != 2 )
    {
        printf( "shpdump [-validate] [-ho] shp_file\n" );
        exit( 1 );
    }

/* -------------------------------------------------------------------- */
/*      Open the passed shapefile.                                      */
/* -------------------------------------------------------------------- */
    hSHP = SHPOpen( argv[1], "rb" );

    if( hSHP == NULL )
    {
        printf( "Unable to open:%s\n", argv[1] );
        exit( 1 );
    }

/* -------------------------------------------------------------------- */
/*      Print out the file bounds.                                      */
/* -------------------------------------------------------------------- */
    SHPGetInfo( hSHP, &nEntities, &nShapeType, adfMinBound, adfMaxBound );

    printf( "Shapefile Type: %s   # of Shapes: %d\n\n",
            SHPTypeName( nShapeType ), nEntities );
    
    printf( "File Bounds: (%.15g,%.15g,%.15g,%.15g)\n"
            "         to  (%.15g,%.15g,%.15g,%.15g)\n",
            adfMinBound[0], 
            adfMinBound[1], 
            adfMinBound[2], 
            adfMinBound[3], 
            adfMaxBound[0], 
            adfMaxBound[1], 
            adfMaxBound[2], 
            adfMaxBound[3] );

/* -------------------------------------------------------------------- */
/*	Skim over the list of shapes, printing all the vertices.	*/
/* -------------------------------------------------------------------- */
    for( i = 0; i < nEntities && !bHeaderOnly; i++ )
    {
        int		j;
        SHPObject	*psShape;

        psShape = SHPReadObject( hSHP, i );

        if( psShape == NULL )
        {
            fprintf( stderr,
                     "Unable to read shape %d, terminating object reading.\n",
                    i );
            break;
        }

        if( psShape->bMeasureIsUsed )
            printf( "\nShape:%d (%s)  nVertices=%d, nParts=%d\n"
                    "  Bounds:(%.15g,%.15g, %.15g, %.15g)\n"
                    "      to (%.15g,%.15g, %.15g, %.15g)\n",
                    i, SHPTypeName(psShape->nSHPType),
                    psShape->nVertices, psShape->nParts,
                    psShape->dfXMin, psShape->dfYMin,
                    psShape->dfZMin, psShape->dfMMin,
                    psShape->dfXMax, psShape->dfYMax,
                    psShape->dfZMax, psShape->dfMMax );
        else
            printf( "\nShape:%d (%s)  nVertices=%d, nParts=%d\n"
                    "  Bounds:(%.15g,%.15g, %.15g)\n"
                    "      to (%.15g,%.15g, %.15g)\n",
                    i, SHPTypeName(psShape->nSHPType),
                    psShape->nVertices, psShape->nParts,
                    psShape->dfXMin, psShape->dfYMin,
                    psShape->dfZMin,
                    psShape->dfXMax, psShape->dfYMax,
                    psShape->dfZMax );

        if( psShape->nParts > 0 && psShape->panPartStart[0] != 0 )
        {
            fprintf( stderr, "panPartStart[0] = %d, not zero as expected.\n",
                     psShape->panPartStart[0] );
        }

        for( j = 0, iPart = 1; j < psShape->nVertices; j++ )
        {
            const char	*pszPartType = "";

            if( j == 0 && psShape->nParts > 0 )
                pszPartType = SHPPartTypeName( psShape->panPartType[0] );
            
            if( iPart < psShape->nParts
                && psShape->panPartStart[iPart] == j )
            {
                pszPartType = SHPPartTypeName( psShape->panPartType[iPart] );
                iPart++;
                pszPlus = "+";
            }
            else
                pszPlus = " ";

            if( psShape->bMeasureIsUsed )
                printf("   %s (%.15g,%.15g, %.15g, %.15g) %s \n",
                       pszPlus,
                       psShape->padfX[j],
                       psShape->padfY[j],
                       psShape->padfZ[j],
                       psShape->padfM[j],
                       pszPartType );
            else
                printf("   %s (%.15g,%.15g, %.15g) %s \n",
                       pszPlus,
                       psShape->padfX[j],
                       psShape->padfY[j],
                       psShape->padfZ[j],
                       pszPartType );
        }

        if( bValidate )
        {
            int nAltered = SHPRewindObject( hSHP, psShape );

            if( nAltered > 0 )
            {
                printf( "  %d rings wound in the wrong direction.\n",
                        nAltered );
                nInvalidCount++;
            }
        }
        
        SHPDestroyObject( psShape );
    }

    SHPClose( hSHP );

    if( bValidate )
    {
        printf( "%d object has invalid ring orderings.\n", nInvalidCount );
    }

#ifdef USE_DBMALLOC
    malloc_dump(2);
#endif

    exit( 0 );
}
예제 #29
0
int main( int argc, char ** argv )

{
    SHPHandle	old_SHP, new_SHP;
    DBFHandle   old_DBF, new_DBF;
    int		nShapeType, nEntities, nVertices, nParts, *panParts, i, iPart;
    double	*padVertices, adBounds[4];
    const char 	*pszPlus;
    DBFFieldType  idfld_type;
    int		idfld, nflds;
    char	kv[257] = "";
    char	idfldName[120] = "";
    char	fldName[120] = "";
    char	shpFileName[120] = "";
    char	dbfFileName[120] = "";
    char	*DBFRow = NULL;
    int		Cpan[2] = { 0,0 };
    int		byRing = 1;
    PT		oCentrd, ringCentrd;
    SHPObject	*psCShape, *cent_pt;
    double	oArea = 0.0, oLen = 0.0;

    if( argc < 2 )
    {
	printf( "shpdata shp_file \n" );
	exit( 1 );
    }
    
    old_SHP = SHPOpen (argv[1], "rb" );
    old_DBF = DBFOpen (argv[1], "rb");
    if( old_SHP == NULL || old_DBF == NULL )
    {
	printf( "Unable to open old files:%s\n", argv[1] );
	exit( 1 );
    }

    SHPGetInfo( old_SHP, &nEntities, &nShapeType, NULL, NULL );
    for( i = 0; i < nEntities; i++ )
    {
	int		res ;

	psCShape = SHPReadObject( old_SHP, i );

        if ( byRing == 1 ) {
          int 	   ring, prevStart, ringDir;
	  double   ringArea;

          prevStart = psCShape->nVertices;
          for ( ring = (psCShape->nParts - 1); ring >= 0; ring-- ) {
	    SHPObject 	*psO;
	    int		j, numVtx, rStart;
            
            rStart = psCShape->panPartStart[ring];
            if ( ring == (psCShape->nParts -1) )
              { numVtx = psCShape->nVertices - rStart; }
             else
              { numVtx = psCShape->panPartStart[ring+1] - rStart; }
              
            printf ("(shpdata) Ring(%d) (%d for %d) \n", ring, rStart, numVtx);              
	    psO = SHPClone ( psCShape, ring,  ring + 1 );

            ringDir = SHPRingDir_2d ( psO, 0 );
            ringArea = RingArea_2d (psO->nVertices,(double*) psO->padfX,
            	 (double*) psO->padfY);
            RingCentroid_2d ( psO->nVertices, (double*) psO->padfX, 
     		(double*) psO->padfY, &ringCentrd, &ringArea);  

            	 
            printf ("(shpdata)  Ring %d, %f Area %d dir \n", 
           	ring, ringArea, ringDir );

	    SHPDestroyObject ( psO );
            printf ("(shpdata) End Ring \n");
           }  /* (ring) [0,nParts  */

          }  /* by ring   */

	   oArea = SHPArea_2d ( psCShape );
	   oLen = SHPLength_2d ( psCShape ); 
	   oCentrd = SHPCentrd_2d ( psCShape );
           printf ("(shpdata) Part (%d) %f Area  %f length, C (%f,%f)\n",
           	 i, oArea, oLen, oCentrd.x, oCentrd.y );
    }

    SHPClose( old_SHP );

    DBFClose( old_DBF );

    printf ("\n");
}
예제 #30
0
int main(){
  int entityCount;
  int shapeType;
  double padfMinBound[4];
  double padfMaxBound[4];
  int i;
  int use_gal = 1;
  int use_dist = 0;
  //For josh
  //char sf_name[] = "/home/joshua/FultonCoData/Fultoncombinednd_10.shp";
  //for sumanth
  //char sf_name[] = "/home/sumanth/Documents/eDemocracy/Files/Fultoncombinednd.shp";
  //for alice
 char sf_name[]= "/home/altheacynara/Documents/saltLakeData/tl_2008_49035_tabblock.shp";
  // char sf_name[]="/home/altheacynara/Documents/fultonData/Fultoncombinednd.shp";
  //Eventually, this won't be hardcoded

  SHPHandle handle = SHPOpen(sf_name, "rb");


  int fn_len = strlen(sf_name);
  char svg_filename[fn_len];
  char gal_filename[fn_len];
  char dst_filename[fn_len];
  FILE *svg;
  strcpy(svg_filename, sf_name);
  strcpy(gal_filename, sf_name);
  strcpy(dst_filename, sf_name);
  svg_filename[fn_len-2] = 'v';
  svg_filename[fn_len-1] = 'g';
  gal_filename[fn_len-3] = 'G';
  gal_filename[fn_len-2] = 'A';
  gal_filename[fn_len-1] = 'L';
  dst_filename[fn_len-3] = 'd';
  dst_filename[fn_len-2] = 's';
  dst_filename[fn_len-1] = 't';
  //I know, the above isn't really robust enough.
  //Should be improved upon when the file name is no longer hardcoded

  SHPGetInfo(handle, &entityCount, &shapeType, padfMinBound, padfMaxBound);
 
  SHPObject **shapeList = malloc(entityCount*sizeof(SHPObject *));
  //neighborList neighbors[entityCount];
  struct neighbor_list *NLIST;
  double xCentList[entityCount];
  double yCentList[entityCount];
  double areaList[entityCount];
  //populate the shapeList
  for(i=0; i<entityCount; i++){
    shapeList[i] = SHPReadObject(handle,i);
  }
  printf("Shapelist populated.\n");
  //delete file if it exists
  remove(svg_filename);
  //set up the SVG file pointer
  svg = fopen(svg_filename, "a+");
  printf("SVG file opened for writing.\n");
  //write header
  svg_header(svg);
  printf("SVG header printed.\n");
  //Call colorArrange:
  int ndists=5;
  int *colorArray = malloc(entityCount*sizeof(int));
  colorArrange(colorArray,entityCount,ndists, dst_filename);

  //write individual polygons
  for(i=0; i<entityCount; i++){
    svg_polygon(*shapeList[i], svg, use_dist, colorArray);
  }
  printf("Polygons all printed.\n");


  if(use_gal){
    FILE *gal;
    int block, num_neigh, nblocks, temp_neigh;
    int count=0;
    gal= fopen(gal_filename, "r");
    if(gal==NULL){
      printf("Error: Could not open GAL file.\n");
      return -1;
    }
    fscanf(gal, "%d", &nblocks);
    
    if(nblocks==entityCount){
       printf("GAL block count matches shapefile block count. Proceeding...\n");
    }else{
      printf("GAL block count does not match. Exiting...\n");
      exit(EXIT_FAILURE);
    }
	  
    NLIST = malloc(nblocks * sizeof(struct neighbor_list));
	  
    while(fscanf(gal, "%d %d", &block, &num_neigh) != EOF)
      {
	NLIST[block].num_neighbors = num_neigh;
	if(num_neigh != 0)
	  { 
	    count=0;
	    NLIST[block].neighbors = malloc(num_neigh * sizeof(int));
	    while(count < num_neigh)
	      {
		fscanf(gal, "%d", &temp_neigh);
		NLIST[block].neighbors[count] = temp_neigh;
		count++;
	      }
	  }
      }

    //Debugging: print the neighbor list of all blocks
    /*int i,j;
      for(i=0;i<nblocks;i++)
      {
      printf("%d %d\n", i, NLIST[i].num_neighbors);
      if(NLIST[i].num_neighbors > 0)
      for(j=0;j<NLIST[i].num_neighbors;j++)
      printf("%d ", NLIST[i].neighbors[j]);
      printf("\n");
      }*/

    //find centroids for every block
    for(i=0; i<entityCount; i++){
      int lastPoint;
      int status;
      SHPObject block = *shapeList[i];
      //Note that we're going to disregard holes, etc.
      if(block.nParts>1){
	lastPoint = block.panPartStart[1]-1;
      }else{
	lastPoint = block.nVertices-1;
      }
      status = polyCentroid(block.padfX, block.padfY, lastPoint, 
			    xCentList+i, yCentList+i, areaList+i);
    }
    printf("Centroids calculated.\n");

    //write paths from centroid to centroid
    fputs("\t</g>\n", svg);
    fputs("\t<g\n\t\tid=\"layer2\">\n", svg);
    for(i=0; i<entityCount; i++){
      svg_neighbors(*shapeList[i], NLIST[i], xCentList, yCentList, svg);
    }
    //svg_neighbors(*shapeList[20], NLIST[20], xCentList, yCentList, svg);
    printf("Contiguity paths drawn.\n");

    //this is the section that's screwing up
    //Free NLIST
    for(i=0; i<entityCount; i++)
      {
        printf("i is %d\n", i);
        printf("NLIST[i]\n");
        free(NLIST[i].neighbors);
        NLIST[i].neighbors = NULL;
      }
    free(NLIST);
    NLIST = NULL;
    fclose(gal);
    //end section that's screwing up
  }
  
  //write footer
  svg_footer(svg);
  printf("SVG footer printed.\n");
  for(i=0; i<entityCount; i++){
    SHPDestroyObject(shapeList[i]);
  }
  SHPClose(handle);
  fclose(svg);
  free(colorArray);
  return 0;
}