void Model_Sonic::readPolygons(ParserContext &ctx) {
ctx.nsbmd->seek(ctx.offsetPolygons);
Infos polygons;
const uint8 polygonCount = readInfoOffset(ctx, polygons, ctx.offsetPolygons);
ctx.polygons.resize(polygonCount);
for (uint i = 0; i < polygonCount; i++)
readPolygon(ctx, ctx.polygons[i], polygons[i]);
}
GridPointDataList * PolygonReader::read( const GEOSGeom location, InterpolationType interpolation, FileId dataId )
{
std::vector <GridPointData> points;
gridPointsInPolygon( points, location );
GridPointDataList * list = 0;
if ( points.size() > 0 )
list = readPolygon( points, dataId );
else {
list = GridPointDataListNew(0);
}
return list;
}
int
main (int argc, char **argv)
{
int c,
verbose = 0,
errflg = 0;
char *dbinname=malloc(1024);
char *dboutname=malloc(1024);
Point *poly;
double lat,lon;
char *subset_expr=NULL;
char *name=malloc(100);
long nregions, nvertices;
Tbl *sortkeys;
Dbptr dbin,dbout,dbi,dbo,dbs;
long i,from,to,nv;
long vertex;
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "s:vV")) != -1) {
switch (c) {
case 's':
subset_expr=optarg;
break;
case 'v':
verbose++ ;
break;
case 'V':
usage ();
break;
case '?':
errflg++;
break ;
}
}
if ((errflg) || argc < 3)
usage ();
dbinname = argv[optind++];
dboutname= argv[optind++];
if (dbopen(dbinname,"r",&dbin)) {
elog_die(1,"cannot open database %s",dbinname);
}
dbi=dblookup(dbin,0,"polygon",0,0);
if (subset_expr) {
dbi=dbsubset(dbi,subset_expr,NULL);
}
sortkeys=newtbl(1);
pushtbl(sortkeys,"pname");
dbs=dbsort(dbi,sortkeys,0,"sorted");
dbquery(dbs,dbRECORD_COUNT,&nregions);
if (nregions <1) {
elog_die(0,"table regions seems to be empty (or not present)");
}
if (verbose) elog_notify(0,"creating database descriptor %s",dboutname);
if (dbcreate(dboutname,"places1.2",0,0,0)) {
elog_die(1,"cannot create database %s",dboutname);
}
dbopen(dboutname,"r+",&dbout);
dbo=dblookup(dbout,0,"regions",0,0);
for (i=0; i< nregions; i++) {
dbs.record=i;
dbgetv(dbs,0,"pname",name,NULL );
nvertices=readPolygon(dbs,&poly);
for (nv=0;nv < nvertices;nv++) {
lat=poly[nv].lat;
lon=poly[nv].lon;
dbaddv(dbo,0,
"regname",name,
"vertex",nv,
"lat",lat,"lon",lon,
NULL );
}
free(poly);
}
dbclose(dbo);
/*
*/
return 0;
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Point *polygon;
int nrec;
int single_record;
double NaN;
double *lat;
double *lon;
int nvertices;
int nsaved,closed;
int i,j;
double *lat_pr, *lon_pr;
Expression *expr;
int maxneeded;
int sumpoints;
int *nanindices;
char closedstr[2];
NaN=mxGetNaN();
if ( nrhs != 1 ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( ! get_dbptr( prhs[0], &db ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( nlhs != 2 ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
}
if (dbquery( db, dbRECORD_COUNT, &nrec) < 0) {
antelope_mex_clear_register( 1 );
mexErrMsgTxt("readpolygon: dbquery(recordcount) failed\n");
}
if (nrec <= 0 ) {
mexErrMsgTxt("readpolygon: no rows in database view\n");
}
if (db.record == dbALL) {
if (nrec == 1) {
single_record= 1;
db.record=0;
dbgetv(db,0,"npoints",&sumpoints,0);
maxneeded= (nrec*2) + sumpoints;
} else {
single_record=0;
db.record=0;
dbex_compile(db,"sum(npoints)",&expr,dbINTEGER);
dbex_eval(db,expr,0,&sumpoints);
dbex_free(expr);
maxneeded= (nrec*2) + sumpoints;
nanindices=mxCalloc(nrec,sizeof(int));
}
} else {
if (db.record >= 0) {
single_record= 1;
dbgetv(db,0,"npoints",&sumpoints,"closed",&closedstr,0);
maxneeded= (nrec*2) + sumpoints;
} else {
mexErrMsgTxt("readpolygon: unspecified subset?!?\n");
}
}
nsaved= 0;
nvertices= readPolygon(db,&polygon);
lat= mxCalloc(maxneeded+1, sizeof(double));
lon= mxCalloc(maxneeded+1, sizeof(double));
for (j= 0; j < nvertices; j++) {
lat[j]= polygon[j].lat;
lon[j]= polygon[j].lon;
}
nsaved += nvertices;
free(polygon);
/* eventually close polygon*/
if (strncmp(closedstr,"y",1)==0) {
if ( (lat[nvertices-1] != lat[0]) || (lon[nvertices-1] != lon[0]) ) {
nsaved++;
lat[nsaved-1]= lat[0];
lon[nsaved-1]= lon[0];
}
}
if ( (single_record == 0) && (nrec > 1) ) {
for (i= 1; i < nrec; i++) {
db.record=i;
dbgetv(db,0,"closed",&closedstr,0);
nvertices= readPolygon(db,&polygon);
/* separate (sub)polygons by NaN */
lat[nsaved + 1]=NaN;
lon[nsaved + 1]=NaN;
nanindices[i-1]= nsaved+1;
nsaved++;
for (j= 0; j < nvertices; j++) {
lat[j+nsaved]= polygon[j].lat;
lon[j+nsaved]= polygon[j].lon;
}
nsaved += nvertices;
/* eventually close polygon*/
if (strncmp(closedstr,"y",1)==0) {
if ( (lat[nvertices-1] != lat[0]) || (lon[nvertices-1] != lon[0]) ) {
lat[nsaved]= lat[nsaved-nvertices];
lon[nsaved]= lon[nsaved-nvertices];
nsaved++;
}
}
free(polygon);
}
}
plhs[0] = mxCreateDoubleMatrix(nsaved,1,mxREAL);
lat_pr=(double *)mxGetPr(plhs[0]);
memcpy(lat_pr, lat, nsaved*sizeof(double));
plhs[1] = mxCreateDoubleMatrix(nsaved,1,mxREAL);
lon_pr=(double *)mxGetPr(plhs[1]);
memcpy(lon_pr, lon, nsaved*sizeof(double));
/* NaN does NOT pass the memcpy */
if (single_record == 0) {
for (i=0; i < nrec-1; i++) {
lat_pr[nanindices[i]-1]=NaN;
lon_pr[nanindices[i]-1]=NaN;
}
mxFree(nanindices);
}
mxFree(lat);
mxFree(lon);
}
int main(int argc, char* argv[])
{
std::srand(std::time(0));
RaiiSdlMain sdlMain;
Graphics graphics(width, height);
Physics physics(physWidth, physHeight);
std::vector<Circle> circles;
std::vector<b2Body*> boxes;
std::vector<Flyer> flyers;
for (int i(0); i<NUM_OF_CIRCLES; ++i)
{
int r = std::rand() % 50 + 30;
int x = width / 2;
int y = height / 4;
//circles.push_back(Circle{x, y, r, std::rand() % 30 - 15, std::rand() % 30 - 15, (std::rand() % 0xffffff) << 8});
boxes.push_back(physics.addBox(Vector(physWidth / 2 + std::rand() % physWidth / 2 - physWidth / 4, physHeight / 2 + std::rand() % physHeight / 2 - physHeight / 4), 1, 1));
boxes.back()->ApplyForceToCenter(Vector(std::rand() % 1000 - 500, std::rand() % 1000 - 500));
}
for (int i(1); i < argc; ++i)
{
boxes.push_back(physics.addComplexPolygon(Vector(physWidth / 2 + std::rand() % physWidth / 2 - physWidth / 4, physHeight / 2 + std::rand() % physHeight / 2 - physHeight / 4), readPolygon(argv[i])));
flyers.push_back(Flyer());
boxes.back()->SetUserData(&flyers.back());
}
SDL_AddTimer(TIMER_INTERVAL, timerTick, 0);
bool exit(false);
bool forwardEngine(false);
bool turnEngine(false);
SDL_Event event;
while (!exit && 1 == SDL_WaitEvent(&event))
{
ScopedPrinter printer("while (!exit && 1 == SDL_WaitEvent(&event))");
switch (event.type)
{
case SDL_QUIT:
{
exit = true;
break;
}
case SDL_USEREVENT:
{
if (forwardEngine)
{
//boxes.back()->ApplyForceToCenter(rotate(EngineForce, boxes.back()->GetAngle()));
boxes.back()->ApplyForce(EngineForce, boxes.back()->GetPosition() + rotate(Vector(1.5f, 0.5f), boxes.back()->GetAngle()));
}
if (turnEngine)
{
boxes.back()->ApplyTorque(1.0f);
}
ScopedPrinter printer("case SDL_USEREVENT:");
draw(graphics, circles, boxes);
graphics.show();
move(boxes);
physics.step();
timerEventInQueue = false;
break;
}
case SDL_KEYDOWN:
{
switch (event.key.keysym.sym)
{
case SDLK_UP:
{
forwardEngine = true;
break;
}
case SDLK_LEFT:
{
turnEngine = true;
break;
}
default: break;
}
break;
}
case SDL_KEYUP:
{
switch (event.key.keysym.sym)
{
case SDLK_UP:
{
forwardEngine = false;
break;
}
case SDLK_LEFT:
{
turnEngine = false;
break;
}
default: break;
}
break;
}
}
}
}
Dbptr inWhichPolygons(Dbptr db,Point P) {
Point *poly;
long i;
long nrec;
Dbptr dbr= dblookup(db,0,"polygon",0,0);
double lat,lon;
Dbptr dbs;
long npoints;
char expr[STRSZ];
char temp[STRSZ];
long pid;
int first;
int found=0;
char name[STRSZ];
lat= P.lat;
lon= P.lon;
dbs=dblookup(db,0,"polygon",0,0);
/*
Nice idea, but breaks too many programs (older versions of the polygon-schema)
sprintf(expr,"closed=~/y/ && north >= %f && south <= %f && east >= %f && west <= %f",
*/
sprintf(expr,"north >= %f && south <= %f && east >= %f && west <= %f",
lat,lat,lon,lon);
dbs=dbsubset(dbs,expr,0);
dbquery(dbs, dbRECORD_COUNT,&nrec);
if (nrec < 1) {
/*
elog_log(0,"inWhichPolygons: initial check of Bounding Box returns 0!");
*/
dbr=dbinvalid();
return dbr;
}
first=1;
for (i= 0; i< nrec; i++) {
dbs.record=i;
dbgetv(dbs,0,"pname",&name,NULL );
if ((npoints=readPolygon(dbs,&poly))>0) {
if (isGeographicallyInside(P,poly,npoints)) {
found=1;
dbgetv(dbs,0,"pid",&pid,NULL );
if (first) {
sprintf(expr,"pid==%ld",pid);
first=0;
} else {
sprintf(temp,"|| pid==%ld",pid);
strcat(expr,temp);
}
}
free(poly);
}
}
/*dbr=dblist2subset(dbs,list);*/
if (found) {
dbr=dbsubset(dbs,expr,0);
} else {
dbr=dbinvalid();
}
dbfree(dbs);
return dbr;
}
int
main(int argc, char **argv)
{
int c, verbose = 0, errflg = 0;
char *dbname= NULL;
Point *poly;
long nvertices;
Dbptr db;
long i;
long nrecs;
char *subset_expr=NULL;
char pname[STRSZ], closed[STRSZ];
elog_init(argc, argv);
for (argc--, argv++; argc > 1; argc--, argv++) {
if (!strcmp(*argv, "-subset")) {
argc--;
argv++;
if (argc < 1) {
elog_complain(0, "Need -subset argument.\n");
usage();
exit(1);
}
subset_expr = *argv;
} else if (!strcmp(*argv, "-v")) {
verbose++;
} else if (**argv != '-') {
break;
} else {
elog_complain(0, "Unrecognized argument '%s'.\n",
*argv); usage(); exit(1);
usage();
exit(1);
}
}
if (argc < 1) {
complain(0, "Need db argument.\n");
usage();
exit(1);
}
dbname = *argv;
argc--;
argv++;
dbopen_database(dbname, "r", &db);
if (db.table <0) {
db=dblookup(db,0,"polygon",0,0);
}
if (subset_expr) {
db=dbsubset(db,subset_expr,0);
}
dbquery(db, dbRECORD_COUNT, &nrecs);
printf("records:%ld \n",nrecs);
for (db.record = 0; db.record < nrecs; db.record++) {
nvertices = readPolygon(db, &poly);
if (nvertices > 0) {
dbgetv(db, 0, "pname", &pname, "closed", &closed, NULL );
printf(">\n");
for (i = 0; i < nvertices; i++) {
printf("%.4f %.4f\n", poly[i].lon, poly[i].lat);
}
if (yesno(closed) == -1 &&
((poly[0].lat != poly[nvertices - 1].lat) ||
(poly[0].lon != poly[nvertices - 1].lon))) {
printf("%.4f %.4f\n", poly[0].lon, poly[0].lat);
}
}
}
dbclose(db);
return (0);
}
void BSPFile::read( io::InputStream* in )
{
ChunkInputStream input(in);
String rootname;
// read main chunk
String name;
long end;
input.beginChunk( &name, &end );
if ( name != "bsptree" )
throw IOException( Format("BSP data {0} must begin with bsptree chunk", in->toString()) );
// read version
int ver = input.readInt();
if ( ver != BSP_FILE_VERSION )
throw IOException( Format("BSP data {0} invalid version (was {1}, should have been {2})", in->toString(), ver, BSP_FILE_VERSION) );
// read node count
int nodes = input.readInt();
m_tree->setNodeAllocationUnit( nodes );
// read total number of polys in all nodes, reserve space for them to avoid allocations
int nodepolys = input.readInt();
m_tree->nodePolygonData.setSize( nodepolys );
m_tree->nodePolygonData.clear();
// read vertices
{
String name;
long end;
input.beginChunk( &name, &end );
if ( name != "vertices" )
throw IOException( Format("BSP data {0} vertices chunk must follow BSP file version", in->toString()) );
int nvertices = input.readInt();
m_tree->vertexData.setSize( nvertices );
for ( int i = 0 ; i < nvertices ; ++i )
{
float v[3];
input.readFloatArray( v, 3 );
m_tree->vertexData[i] = Vector3(v[0],v[1],v[2]);
}
input.endChunk( end );
}
// read polygons
{
String name;
long end;
input.beginChunk( &name, &end );
if ( name != "polygons" )
throw IOException( Format("BSP data {0} polygon chunk must follow vertices chunk", in->toString()) );
int npolys = input.readInt();
m_tree->setPolygonAllocationUnit( npolys );
m_tree->edgePlaneData.setSize( 3*npolys ); // reserve space for edges
m_tree->edgePlaneData.clear();
m_tree->indexData.setSize( 3*npolys ); // reserve space for indices
m_tree->indexData.clear();
for ( int i = 0 ; i < npolys ; ++i )
readPolygon( &input );
input.endChunk( end );
}
// read node tree
readNode( &input );
// end main chunk
input.endChunk( end );
}
bool Shape::load(const std::string& filename) {
GDALAllRegister();
GDALDataset* poDS;
poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poDS == NULL) return false;
// 初期化
shapeObjects.clear();
minBound.x = std::numeric_limits<float>::max();
minBound.y = std::numeric_limits<float>::max();
minBound.z = std::numeric_limits<float>::max();
maxBound.x = -std::numeric_limits<float>::max();
maxBound.y = -std::numeric_limits<float>::max();
maxBound.z = -std::numeric_limits<float>::max();
int nLayers = poDS->GetLayerCount();
int i = 0;
for (int n = 0; n < nLayers; ++n) {
OGRLayer* poLayer = poDS->GetLayer(n);
shapeType = poLayer->GetGeomType();
shapeObjects.resize(shapeObjects.size() + poLayer->GetFeatureCount());
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// 属性の名前を読み込む
std::vector<std::string> fieldNames;
for (int j = 0; j < poFeature->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFeature->GetFieldDefnRef(j);
fieldNames.push_back(poFieldDefn->GetNameRef());
}
// 属性の値を読み込む
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
for (int j = 0; j < poFDefn->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFDefn->GetFieldDefn(j);
if (poFieldDefn->GetType() == OFTInteger) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTInteger64) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTReal) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsDouble(j));
}
else if (poFieldDefn->GetType() == OFTString) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
else {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
}
// このshapeのベクトルデータを読み込む
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry != NULL) {
if (wkbFlatten(poGeometry->getGeometryType()) == wkbPoint) {
shapeObjects[i].parts.resize(1);
shapeObjects[i].parts[0].points.resize(1);
OGRPoint* poPoint = (OGRPoint*)poGeometry;
shapeObjects[i].parts[0].points[0].x = poPoint->getX();
shapeObjects[i].parts[0].points[0].y = poPoint->getY();
updateBounds(poPoint);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) {
OGRLineString* poLineString = (OGRLineString*)poGeometry;
readLineString(poLineString, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) {
OGRPolygon* poPolygon = (OGRPolygon*)poGeometry;
readPolygon(poPolygon, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon) {
OGRMultiPolygon* poMultiPolygon = (OGRMultiPolygon*)poGeometry;
readMultiPolygon(poMultiPolygon, shapeObjects[i]);
}
else {
// not supported
}
}
// shapeObjectsのインデックスをインクリメント
i++;
// OGRが取得したメモリを開放
OGRFeature::DestroyFeature(poFeature);
}
}
GDALClose(poDS);
return true;
}
