void object::test<11>
()
{
// Coincident vertext at -753.167968418005 93709.4279185742
//POLYGON ((-753.167968418005 93754.0955183194,-816.392328351464 93754.0955183194,-816.392328351464 93709.4279185742,-753.167968418005 93709.4279185742,-753.167968418005 93754.0955183194))
std::string const
outer("01030000800100000005000000bd70d3ff578987c09e373e87a1e3f6400000000000000000a9f60b7d238389c09e373e87a1e3f6400000000000000000a9f60b7d238389c09625c1d8d6e0f6400000000000000000bd70d3ff578987c09625c1d8d6e0f6400000000000000000bd70d3ff578987c09e373e87a1e3f6400000000000000000");
//POLYGON ((-753.167968418005 93747.6909727677,-799.641978447015 93747.6909727677,-799.641978447015 93709.4279185742,-753.167968418005 93709.4279185742,-753.167968418005 93747.6909727677))
std::string const
inner("01030000800100000005000000bd70d3ff578987c0f875390e3be3f6400000000000000000579598c522fd88c0f875390e3be3f6400000000000000000579598c522fd88c09625c1d8d6e0f6400000000000000000bd70d3ff578987c09625c1d8d6e0f6400000000000000000bd70d3ff578987c0f875390e3be3f6400000000000000000");
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10);
geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
geom1_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sOuter));
std::istringstream sInner(inner);
geom2_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sInner));
ensure(nullptr != geom1_);
ensure(nullptr != geom2_);
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContains(prepGeom1_, geom2_);
ensure_equals(ret, 1);
ret = GEOSPreparedContainsProperly(prepGeom1_, geom2_);
ensure_equals(ret, 0);
GEOSGeom_destroy(geom1_);
GEOSGeom_destroy(geom2_);
GEOSPreparedGeom_destroy(prepGeom1_);
}
// A contains B if FLOATING PM is used with extended precision
{
geos::geom::PrecisionModel pm;
geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
geom1_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sOuter));
std::istringstream sInner(inner);
geom2_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sInner));
ensure(nullptr != geom1_);
ensure(nullptr != geom2_);
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContains(prepGeom1_, geom2_);
ensure_equals(ret, 1);
ret = GEOSPreparedContainsProperly(prepGeom1_, geom2_);
ensure_equals(ret, 0);
}
}
void object::test<10>
()
{
// Coincident vertives of both polygons at
// -700.67089999181 93743.4218587986, -713.450135807349 93754.1677576647,
std::string const
outer("01030000800100000009000000af9dd0005ee585c0f802efbff6e2f6400000000000000000955acde0994b86c039a922afa2e3f64000000000000000002af6fb4f5d1887c07adb1c4071e3f6400000000000000000e5962b388d4f87c0bd3aeda7bae2f640000000000000000087c61344030887c07d585e6ff6e1f6400000000000000000fc8a31b5166186c0230588b20ae1f640000000000000000034733daf050186c0ed9f3ac98ae1f6400000000000000000f190aef659b385c0df2876538ce2f6400000000000000000af9dd0005ee585c0f802efbff6e2f6400000000000000000");
std::string const
inner("0103000080010000000a000000ac21f88bbaff86c05f45d8c7b4e2f6400000000000000000467f1177ebf386c05de1971187e2f6400000000000000000fcf677888fc886c04e855a544be2f6400000000000000000c61226e540b686c0c0662d1fe7e1f640000000000000000042dc1bece8a486c09b85529f8ae1f6400000000000000000891047cde55e86c038cfa59c4ee1f6400000000000000000ae9dd0005ee585c0fa02efbff6e2f6400000000000000000975acde0994b86c038a922afa2e3f6400000000000000000287e339b09f986c01b1a083a10e3f6400000000000000000ac21f88bbaff86c05f45d8c7b4e2f6400000000000000000");
// A contains B if precision is limited to 1e+10
{
geos::geom::PrecisionModel pm(1e+10); // NOTE: higher precision fails this test case
geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
geom1_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sOuter));
std::istringstream sInner(inner);
geom2_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sInner));
ensure(nullptr != geom1_);
ensure(nullptr != geom2_);
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContains(prepGeom1_, geom2_);
ensure_equals(ret, 1);
ret = GEOSPreparedContainsProperly(prepGeom1_, geom2_);
ensure_equals(ret, 0);
GEOSGeom_destroy(geom1_);
GEOSGeom_destroy(geom2_);
GEOSPreparedGeom_destroy(prepGeom1_);
}
// A does NOT contain B if precision is extended to 1e+11 or beyond
{
geos::geom::PrecisionModel pm(1e+11);
geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
std::istringstream sOuter(outer);
geom1_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sOuter));
std::istringstream sInner(inner);
geom2_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sInner));
ensure(nullptr != geom1_);
ensure(nullptr != geom2_);
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContains(prepGeom1_, geom2_);
ensure_equals(ret, 0);
ret = GEOSPreparedContainsProperly(prepGeom1_, geom2_);
ensure_equals(ret, 0);
}
}
void object::test<1>
()
{
geom1_ = GEOSGeomFromWKT("POLYGON EMPTY");
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
}
void object::test<2>
()
{
geom1_ = GEOSGeomFromWKT("POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))");
geom2_ = GEOSGeomFromWKT("POLYGON((2 2, 2 3, 3 3, 3 2, 2 2))");
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContainsProperly(prepGeom1_, geom2_);
ensure_equals(ret, 1);
}
void object::test<6>
()
{
geom1_ = GEOSGeomFromWKT("POLYGON((0 0, 0 10, 10 11, 10 0, 0 0))");
geom2_ = GEOSGeomFromWKT("POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))");
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedContains(prepGeom1_, geom2_);
ensure_equals(ret, 1);
}
void object::test<4>
()
{
geom1_ = GEOSGeomFromWKT("LINESTRING(0 0, 10 10)");
geom2_ = GEOSGeomFromWKT("LINESTRING(0 10, 10 0)");
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedIntersects(prepGeom1_, geom2_);
ensure_equals(ret, 1);
}
void object::test<9>
()
{
// POINT located on the 3rd vertex of LINESTRING
// POINT(-23.1094689600055 50.5223376452201)
std::string point("01010000009c266328061c37c056d8bff5db424940");
// LINESTRING(-23.122057005539 50.5201976774794,-23.1153476966995 50.5133404815199,-23.1094689600055 50.5223376452201,-23.1094689600055 50.5169177629559,-23.0961967920942 50.5330464848094,-23.0887991006034 50.5258515213185,-23.0852302622362 50.5264582238409)
std::string
line("0102000000070000009909bf203f1f37c05c1d66d6954249404afe386d871d37c0a7eb1124b54149409c266328061c37c056d8bff5db42494098266328061c37c0034f7b5c2a42494060065c5aa01837c08ac001de3a4449408401b189bb1637c0b04e471a4f43494014ef84a6d11537c0b20dabfb62434940");
geom1_ = GEOSGeomFromHEX_buf(reinterpret_cast<const unsigned char*>(line.data()), line.size());
geom2_ = GEOSGeomFromHEX_buf(reinterpret_cast<const unsigned char*>(point.data()), point.size());
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedIntersects(prepGeom1_, geom2_);
ensure_equals(ret, 1);
}
int main(void) {
GEOSWKTReader *reader;
GEOSGeometry *mp;
GEOSGeometry *p;
const GEOSPreparedGeometry *prep_mp;
unsigned long int i;
unsigned long int count = 1e6;
initGEOS(NULL, NULL);
reader = GEOSWKTReader_create();
mp = GEOSWKTReader_read(reader,
"MULTIPOLYGON(((0 0, 10 0, 10 10, 0 10, 0 0)))");
p = GEOSWKTReader_read(reader,
"POLYGON((2 2, 6 2, 6 6, 2 6, 2 2))");
assert(GEOSisValid(mp));
assert(GEOSisValid(p));
prep_mp = GEOSPrepare(mp);
for (i=0; i<count; i++) {
if ( !(i%100) ) printf("%lu iterations\n", i);
/* does not leak */
/* GEOSContains(mp, p); */
/* leaks */
GEOSPreparedContains(prep_mp, p);
}
printf("%lu iterations (END)\n", i);
return 0;
}
void object::test<8>
()
{
geos::geom::PrecisionModel pm(1e+13);
geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);
geos::io::WKBReader reader(*factory);
// POINT located between 3rd and 4th vertex of LINESTRING
// POINT(-23.1094689600055080 50.5195368635957180)
std::string point("01010000009a266328061c37c0e21a172f80424940");
// LINESTRING(-23.122057005539 50.5201976774794,-23.1153476966995 50.5133404815199,-23.1094689600055150 50.5223376452201340,-23.1094689600055010 50.5169177629559480,-23.0961967920942 50.5330464848094,-23.0887991006034 50.5258515213185,-23.0852302622362 50.5264582238409)
std::string
line("0102000000070000009909bf203f1f37c05c1d66d6954249404afe386d871d37c0a7eb1124b54149409c266328061c37c056d8bff5db42494098266328061c37c0034f7b5c2a42494060065c5aa01837c08ac001de3a4449408401b189bb1637c0b04e471a4f43494014ef84a6d11537c0b20dabfb62434940");
std::stringstream sPoint(point);
geom2_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sPoint));
std::stringstream sLine(line);
geom1_ = reinterpret_cast<GEOSGeometry*>(reader.readHEX(sLine));
prepGeom1_ = GEOSPrepare(geom1_);
ensure(nullptr != prepGeom1_);
int ret = GEOSPreparedIntersects(prepGeom1_, geom2_);
ensure_equals(ret, 1);
}
/*
** GetPrepGeomCache
**
** Pull the current prepared geometry from the cache or make
** one if there is not one available. Only prepare geometry
** if we are seeing a key for the second time. That way rapidly
** cycling keys don't cause too much preparing.
*/
PrepGeomCache*
GetPrepGeomCache(FunctionCallInfoData *fcinfo, GSERIALIZED *pg_geom1, GSERIALIZED *pg_geom2)
{
MemoryContext old_context;
PrepGeomCache* cache = fcinfo->flinfo->fn_extra;
int copy_keys = 1;
size_t pg_geom1_size = 0;
size_t pg_geom2_size = 0;
/* Make sure this isn't someone else's cache object. */
if ( cache && cache->type != 2 ) cache = NULL;
if (!PrepGeomHash)
CreatePrepGeomHash();
if ( pg_geom1 )
pg_geom1_size = VARSIZE(pg_geom1) + VARHDRSZ;
if ( pg_geom2 )
pg_geom2_size = VARSIZE(pg_geom2) + VARHDRSZ;
if ( cache == NULL)
{
/*
** Cache requested, but the cache isn't set up yet.
** Set it up, but don't prepare the geometry yet.
** That way if the next call is a cache miss we haven't
** wasted time preparing a geometry we don't need.
*/
PrepGeomHashEntry pghe;
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
cache = palloc(sizeof(PrepGeomCache));
MemoryContextSwitchTo(old_context);
cache->type = 2;
cache->prepared_geom = 0;
cache->geom = 0;
cache->argnum = 0;
cache->pg_geom1 = 0;
cache->pg_geom2 = 0;
cache->pg_geom1_size = 0;
cache->pg_geom2_size = 0;
cache->context = MemoryContextCreate(T_AllocSetContext, 8192,
&PreparedCacheContextMethods,
fcinfo->flinfo->fn_mcxt,
"PostGIS Prepared Geometry Context");
POSTGIS_DEBUGF(3, "GetPrepGeomCache: creating cache: %p", cache);
pghe.context = cache->context;
pghe.geom = 0;
pghe.prepared_geom = 0;
AddPrepGeomHashEntry( pghe );
fcinfo->flinfo->fn_extra = cache;
POSTGIS_DEBUGF(3, "GetPrepGeomCache: adding context to hash: %p", cache);
}
else if ( pg_geom1 &&
cache->argnum != 2 &&
cache->pg_geom1_size == pg_geom1_size &&
memcmp(cache->pg_geom1, pg_geom1, pg_geom1_size) == 0)
{
if ( !cache->prepared_geom )
{
/*
** Cache hit, but we haven't prepared our geometry yet.
** Prepare it.
*/
PrepGeomHashEntry* pghe;
cache->geom = POSTGIS2GEOS( pg_geom1 );
cache->prepared_geom = GEOSPrepare( cache->geom );
cache->argnum = 1;
POSTGIS_DEBUG(3, "GetPrepGeomCache: preparing obj in argument 1");
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = cache->geom;
pghe->prepared_geom = cache->prepared_geom;
POSTGIS_DEBUG(3, "GetPrepGeomCache: storing references to prepared obj in argument 1");
}
else
{
/*
** Cache hit, and we're good to go. Do nothing.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: cache hit, argument 1");
}
/* We don't need new keys until we have a cache miss */
copy_keys = 0;
}
else if ( pg_geom2 &&
cache->argnum != 1 &&
cache->pg_geom2_size == pg_geom2_size &&
memcmp(cache->pg_geom2, pg_geom2, pg_geom2_size) == 0)
{
if ( !cache->prepared_geom )
{
/*
** Cache hit on arg2, but we haven't prepared our geometry yet.
** Prepare it.
*/
PrepGeomHashEntry* pghe;
cache->geom = POSTGIS2GEOS( pg_geom2 );
cache->prepared_geom = GEOSPrepare( cache->geom );
cache->argnum = 2;
POSTGIS_DEBUG(3, "GetPrepGeomCache: preparing obj in argument 2");
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = cache->geom;
pghe->prepared_geom = cache->prepared_geom;
POSTGIS_DEBUG(3, "GetPrepGeomCache: storing references to prepared obj in argument 2");
}
else
{
/*
** Cache hit, and we're good to go. Do nothing.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: cache hit, argument 2");
}
/* We don't need new keys until we have a cache miss */
copy_keys = 0;
}
else if ( cache->prepared_geom )
{
/*
** No cache hits, so this must be a miss.
** Destroy the GEOS objects, empty the cache.
*/
PrepGeomHashEntry* pghe;
pghe = GetPrepGeomHashEntry(cache->context);
pghe->geom = 0;
pghe->prepared_geom = 0;
POSTGIS_DEBUGF(3, "GetPrepGeomCache: cache miss, argument %d", cache->argnum);
GEOSPreparedGeom_destroy( cache->prepared_geom );
GEOSGeom_destroy( (GEOSGeometry *)cache->geom );
cache->prepared_geom = 0;
cache->geom = 0;
cache->argnum = 0;
}
if ( copy_keys && pg_geom1 )
{
/*
** If this is a new key (cache miss) we flip into the function
** manager memory context and make a copy. We can't just store a pointer
** because this copy will be pfree'd at the end of this function
** call.
*/
POSTGIS_DEBUG(3, "GetPrepGeomCache: copying pg_geom1 into cache");
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
if ( cache->pg_geom1 )
pfree(cache->pg_geom1);
cache->pg_geom1 = palloc(pg_geom1_size);
MemoryContextSwitchTo(old_context);
memcpy(cache->pg_geom1, pg_geom1, pg_geom1_size);
cache->pg_geom1_size = pg_geom1_size;
}
if ( copy_keys && pg_geom2 )
{
POSTGIS_DEBUG(3, "GetPrepGeomCache: copying pg_geom2 into cache");
old_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
if ( cache->pg_geom2 )
pfree(cache->pg_geom2);
cache->pg_geom2 = palloc(pg_geom2_size);
MemoryContextSwitchTo(old_context);
memcpy(cache->pg_geom2, pg_geom2, pg_geom2_size);
cache->pg_geom2_size = pg_geom2_size;
}
return cache;
}
int main(int argc, const char **argv) {
/* initialize apr_getopt_t */
apr_getopt_t *opt;
const char *configfile=NULL;
#ifndef USE_FORK
apr_thread_t **threads;
apr_threadattr_t *thread_attrs;
#endif
const char *tileset_name=NULL;
const char *tileset_transfer_name=NULL;
const char *grid_name = NULL;
int *zooms = NULL;//[2];
double *extent = NULL;//[4];
int optch;
int rv,n;
const char *old = NULL;
const char *optarg;
apr_table_t *argdimensions;
char *dimkey=NULL, *dimvalue=NULL,*key, *last, *optargcpy=NULL;
int keyidx;
int *metasizes = NULL;//[2];
int metax=-1,metay=-1;
#ifdef USE_CLIPPERS
const char *ogr_where = NULL;
const char *ogr_layer = NULL;
const char *ogr_sql = NULL;
const char *ogr_datasource = NULL;
#endif
apr_initialize();
(void) signal(SIGINT,handle_sig_int);
apr_pool_create(&ctx.pool,NULL);
mapcache_context_init(&ctx);
ctx.process_pool = ctx.pool;
#ifndef USE_FORK
apr_thread_mutex_create((apr_thread_mutex_t**)&ctx.threadlock,APR_THREAD_MUTEX_DEFAULT,ctx.pool);
#else
ctx.threadlock = NULL;
#endif
cfg = mapcache_configuration_create(ctx.pool);
ctx.config = cfg;
ctx.log= mapcache_context_seeding_log;
apr_getopt_init(&opt, ctx.pool, argc, argv);
seededtiles=seededtilestot=queuedtilestot=0;
mapcache_gettimeofday(&starttime,NULL);
lastlogtime=starttime;
argdimensions = apr_table_make(ctx.pool,3);
/* parse the all options based on opt_option[] */
while ((rv = apr_getopt_long(opt, seed_options, &optch, &optarg)) == APR_SUCCESS) {
switch (optch) {
case 'h':
return usage(argv[0],NULL);
break;
case 'f':
force = 1;
break;
case 'q':
quiet = 1;
break;
case 'v':
verbose = 1;
break;
case 'c':
configfile = optarg;
break;
case 'g':
grid_name = optarg;
break;
case 't':
tileset_name = optarg;
break;
case 'x':
tileset_transfer_name = optarg;
break;
case 'm':
if(!strcmp(optarg,"delete")) {
mode = MAPCACHE_CMD_DELETE;
} else if(!strcmp(optarg,"transfer")){
mode = MAPCACHE_CMD_TRANSFER;
} else if(strcmp(optarg,"seed")){
return usage(argv[0],"invalid mode, expecting \"seed\", \"delete\" or \"transfer\"");
} else {
mode = MAPCACHE_CMD_SEED;
}
break;
case 'n':
nthreads = (int)strtol(optarg, NULL, 10);
break;
case 'e':
if ( MAPCACHE_SUCCESS != mapcache_util_extract_double_list(&ctx, (char*)optarg, ",", &extent, &n) ||
n != 4 || extent[0] >= extent[2] || extent[1] >= extent[3] ) {
return usage(argv[0], "failed to parse extent, expecting comma separated 4 doubles");
}
break;
case 'z':
if ( MAPCACHE_SUCCESS != mapcache_util_extract_int_list(&ctx, (char*)optarg, ",", &zooms, &n) ||
n != 2 || zooms[0] > zooms[1]) {
return usage(argv[0], "failed to parse zooms, expecting comma separated 2 ints");
} else {
minzoom = zooms[0];
maxzoom = zooms[1];
}
break;
case 'M':
if ( MAPCACHE_SUCCESS != mapcache_util_extract_int_list(&ctx, (char*)optarg, ",", &metasizes, &n) ||
n != 2 || metasizes[0] <= 0 || metasizes[1] <=0) {
return usage(argv[0], "failed to parse metasize, expecting comma separated 2 positive ints (e.g. -M 8,8");
} else {
metax = metasizes[0];
metay = metasizes[1];
}
break;
case 'o':
old = optarg;
break;
case 'D':
optargcpy = apr_pstrdup(ctx.pool,optarg);
keyidx = 0;
for (key = apr_strtok(optargcpy, "=", &last); key != NULL;
key = apr_strtok(NULL, "=", &last)) {
if(keyidx == 0) {
dimkey = key;
} else {
dimvalue = key;
}
keyidx++;
}
if(keyidx!=2 || !dimkey || !dimvalue || !*dimkey || !*dimvalue) {
return usage(argv[0], "failed to parse dimension, expecting DIMNAME=DIMVALUE");
}
apr_table_set(argdimensions,dimkey,dimvalue);
break;
#ifdef USE_CLIPPERS
case 'd':
ogr_datasource = optarg;
break;
case 's':
ogr_sql = optarg;
break;
case 'l':
ogr_layer = optarg;
break;
case 'w':
ogr_where = optarg;
break;
#endif
}
}
if (rv != APR_EOF) {
return usage(argv[0],"bad options");
}
if( ! configfile ) {
return usage(argv[0],"config not specified");
} else {
mapcache_configuration_parse(&ctx,configfile,cfg,0);
if(ctx.get_error(&ctx))
return usage(argv[0],ctx.get_error_message(&ctx));
mapcache_configuration_post_config(&ctx,cfg);
if(ctx.get_error(&ctx))
return usage(argv[0],ctx.get_error_message(&ctx));
}
#ifdef USE_CLIPPERS
if(extent && ogr_datasource) {
return usage(argv[0], "cannot specify both extent and ogr-datasource");
}
if( ogr_sql && ( ogr_where || ogr_layer )) {
return usage(argv[0], "ogr-where or ogr_layer cannot be used in conjunction with ogr-sql");
}
if(ogr_datasource) {
OGRDataSourceH hDS = NULL;
OGRLayerH layer = NULL;
OGRRegisterAll();
hDS = OGROpen( ogr_datasource, FALSE, NULL );
if( hDS == NULL )
{
printf( "OGR Open failed\n" );
exit( 1 );
}
if(ogr_sql) {
layer = OGR_DS_ExecuteSQL( hDS, ogr_sql, NULL, NULL);
if(!layer) {
return usage(argv[0],"aborting");
}
} else {
int nLayers = OGR_DS_GetLayerCount(hDS);
if(nLayers>1 && !ogr_layer) {
return usage(argv[0],"ogr datastore contains more than one layer. please specify which one to use with --ogr-layer");
} else {
if(ogr_layer) {
layer = OGR_DS_GetLayerByName(hDS,ogr_layer);
} else {
layer = OGR_DS_GetLayer(hDS,0);
}
if(!layer) {
return usage(argv[0],"aborting");
}
if(ogr_where) {
if(OGRERR_NONE != OGR_L_SetAttributeFilter(layer, ogr_where)) {
return usage(argv[0],"aborting");
}
}
}
}
if((nClippers=OGR_L_GetFeatureCount(layer, TRUE)) == 0) {
return usage(argv[0],"no features in provided ogr parameters, cannot continue");
}
initGEOS(notice, log_and_exit);
clippers = (const GEOSPreparedGeometry**)malloc(nClippers*sizeof(GEOSPreparedGeometry*));
OGRFeatureH hFeature;
GEOSWKTReader *geoswktreader = GEOSWKTReader_create();
OGR_L_ResetReading(layer);
extent = apr_pcalloc(ctx.pool,4*sizeof(double));
int f=0;
while( (hFeature = OGR_L_GetNextFeature(layer)) != NULL ) {
OGRGeometryH geom = OGR_F_GetGeometryRef(hFeature);
if(!geom || !OGR_G_IsValid(geom)) continue;
char *wkt;
OGR_G_ExportToWkt(geom,&wkt);
GEOSGeometry *geosgeom = GEOSWKTReader_read(geoswktreader,wkt);
free(wkt);
clippers[f] = GEOSPrepare(geosgeom);
//GEOSGeom_destroy(geosgeom);
OGREnvelope ogr_extent;
OGR_G_GetEnvelope (geom, &ogr_extent);
if(f == 0) {
extent[0] = ogr_extent.MinX;
extent[1] = ogr_extent.MinY;
extent[2] = ogr_extent.MaxX;
extent[3] = ogr_extent.MaxY;
} else {
extent[0] = MAPCACHE_MIN(ogr_extent.MinX, extent[0]);
extent[1] = MAPCACHE_MIN(ogr_extent.MinY, extent[1]);
extent[2] = MAPCACHE_MAX(ogr_extent.MaxX, extent[2]);
extent[3] = MAPCACHE_MAX(ogr_extent.MaxY, extent[3]);
}
OGR_F_Destroy( hFeature );
f++;
}
nClippers = f;
}
#endif
if( ! tileset_name ) {
return usage(argv[0],"tileset not specified");
} else {
tileset = mapcache_configuration_get_tileset(cfg,tileset_name);
if(!tileset) {
return usage(argv[0], "tileset not found in configuration");
}
if( ! grid_name ) {
grid_link = APR_ARRAY_IDX(tileset->grid_links,0,mapcache_grid_link*);
} else {
Geometry::Geometry(GEOSGeometry* geom)
{
geos_geom_ = geom;
if (geos_geom_ != NULL)
geos_pg_ = GEOSPrepare(geos_geom_);
}
Geometry::Geometry(const char* wkt)
{
this->FromWKT(wkt);
if (geos_geom_ != NULL)
geos_pg_ = GEOSPrepare(geos_geom_);
}