Attachment #177390 for bug #214819

View | Details | Raw Unified | Return to bug 214819 | Differences between
Collapse All | Expand All





geometry_builder::maybe_wkt_t geometry_builder::get_wkt_simple(const osmNode *nodes, int count, int polygon) const
{
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));

    try
    {

        maybe_wkt_t wkt(new geometry_builder::wkt_t());
        geom_ptr geom;
        if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {
            std::auto_ptr<LinearRing> shell(gf->createLinearRing(coords.release()));
            geom = geom_ptr(gf->createPolygon(shell.release(), new std::vector<Geometry *>));
            if (!geom->isValid()) {
                if (excludepoly) {
                    throw std::runtime_error("Excluding broken polygon.");

        } else {
            if (coords->getSize() < 2)
                throw std::runtime_error("Excluding degenerate line.");
            geom = geom_ptr(gf->createLineString(coords.release()));
            wkt->area = 0;
        }



geometry_builder::maybe_wkts_t geometry_builder::get_wkt_split(const osmNode *nodes, int count, int polygon, double split_at) const
{
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
    WKTWriter writer;
    //TODO: use count to get some kind of hint of how much we should reserve?
    maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);


        geom_ptr geom;
        if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {
            std::auto_ptr<LinearRing> shell(gf->createLinearRing(coords.release()));
            geom = geom_ptr(gf->createPolygon(shell.release(), new std::vector<Geometry *>));
            if (!geom->isValid()) {
                if (excludepoly) {
                    throw std::runtime_error("Excluding broken polygon.");


            double distance = 0;
            std::auto_ptr<CoordinateSequence> segment;
            segment = std::auto_ptr<CoordinateSequence>(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
            segment->add(coords->getAt(0));
            for(unsigned i=1; i<coords->getSize(); i++) {
                const Coordinate this_pt = coords->getAt(i);

                    const Coordinate interpolated(frac * (this_pt.x - prev_pt.x) + prev_pt.x,
                                                  frac * (this_pt.y - prev_pt.y) + prev_pt.y);
                    segment->add(interpolated);
                    geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));

                    //copy of an empty one should be cheapest
                    wkts->push_back(geometry_builder::wkt_t());

                    wkts->back().geom = writer.write(geom.get());
                    wkts->back().area = 0;

                    segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
                    segment->add(interpolated);
                  }
                  // reset the distance based on the final splitting point for


                // on the last iteration, close out the line.
                if (i == coords->getSize()-1) {
                    geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));

                    //copy of an empty one should be cheapest
                    wkts->push_back(geometry_builder::wkt_t());

                    wkts->back().geom = writer.write(geom.get());
                    wkts->back().area = 0;

                    segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
                }
            }
        }

}

int geometry_builder::parse_wkt(const char * wkt, struct osmNode *** xnodes, int ** xcount, int * polygon) {
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    WKTReader		reader(gf.get());
    std::string		wkt_string(wkt);
    Geometry *		geometry;
    const Geometry *	subgeometry;

geometry_builder::maybe_wkts_t geometry_builder::build_polygons(const osmNode * const * xnodes, const int *xcount, bool enable_multi, osmid_t osm_id) const
{
    std::auto_ptr<std::vector<Geometry*> > lines(new std::vector<Geometry*>);
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    geom_ptr geom;
    geos::geom::prep::PreparedGeometryFactory pgf;


    try
    {
        for (int c=0; xnodes[c]; c++) {
            std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
            for (int i = 0; i < xcount[c]; i++) {
                const osmNode *nodes = xnodes[c];
                Coordinate c;

                coords->add(c, 0);
            }
            if (coords->getSize() > 1) {
                geom = geom_ptr(gf->createLineString(coords.release()));
                lines->push_back(geom.release());
            }
        }

        //geom_ptr segment(0);
        geom_ptr mline (gf->createMultiLineString(lines.release()));
        //geom_ptr noded (segment->Union(mline.get()));
        LineMerger merger;
        //merger.add(noded.get());

            std::auto_ptr<LineString> pline ((*merged ) [i]);
            if (pline->getNumPoints() > 3 && pline->isClosed())
            {
                polys[totalpolys].polygon = gf->createPolygon(gf->createLinearRing(pline->getCoordinates()),0);
                polys[totalpolys].ring = gf->createLinearRing(pline->getCoordinates());
                polys[totalpolys].area = polys[totalpolys].polygon->getArea();
                polys[totalpolys].iscontained = 0;
                polys[totalpolys].containedbyid = 0;

                   }
                }

                Polygon* poly(gf->createPolygon(polys[i].ring, interior.release()));
                poly->normalize();
                polygons->push_back(poly);
            }

            // Make a multipolygon if required
            if ((toplevelpolygons > 1) && enable_multi)
            {
                geom_ptr multipoly(gf->createMultiPolygon(polygons.release()));
                if (!multipoly->isValid() && (excludepoly == 0)) {
                    multipoly = geom_ptr(multipoly->buffer(0));
                }

geometry_builder::maybe_wkt_t geometry_builder::build_multilines(const osmNode * const * xnodes, const int *xcount, osmid_t osm_id) const
{
    std::auto_ptr<std::vector<Geometry*> > lines(new std::vector<Geometry*>);
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    geom_ptr geom;

    maybe_wkt_t wkt(new geometry_builder::wkt_t());

    try
    {
        for (int c=0; xnodes[c]; c++) {
            std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
            for (int i = 0; i < xcount[c]; i++) {
                const osmNode *nodes = xnodes[c];
                Coordinate c;

                coords->add(c, 0);
            }
            if (coords->getSize() > 1) {
                geom = geom_ptr(gf->createLineString(coords.release()));
                lines->push_back(geom.release());
            }
        }

        //geom_ptr segment(0);
        geom_ptr mline (gf->createMultiLineString(lines.release()));
        //geom_ptr noded (segment->Union(mline.get()));

        WKTWriter writer;

                                                                             int enable_multi, double split_at, osmid_t osm_id) const
{
    std::auto_ptr<std::vector<Geometry*> > lines(new std::vector<Geometry*>);
    GeometryFactory::unique_ptr gf = GeometryFactory::create();
    geom_ptr geom;
    geos::geom::prep::PreparedGeometryFactory pgf;
    maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);

    try
    {
        for (int c=0; xnodes[c]; c++) {
            std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
            for (int i = 0; i < xcount[c]; i++) {
                const osmNode *nodes = xnodes[c];
                Coordinate c;

                coords->add(c, 0);
            }
            if (coords->getSize() > 1) {
                geom = geom_ptr(gf->createLineString(coords.release()));
                lines->push_back(geom.release());
            }
        }

        //geom_ptr segment(0);
        geom_ptr mline (gf->createMultiLineString(lines.release()));
        //geom_ptr noded (segment->Union(mline.get()));
        LineMerger merger;
        //merger.add(noded.get());

            std::auto_ptr<LineString> pline ((*merged ) [i]);
            if (make_polygon && pline->getNumPoints() > 3 && pline->isClosed())
            {
                polys[totalpolys].polygon = gf->createPolygon(gf->createLinearRing(pline->getCoordinates()),0);
                polys[totalpolys].ring = gf->createLinearRing(pline->getCoordinates());
                polys[totalpolys].area = polys[totalpolys].polygon->getArea();
                polys[totalpolys].iscontained = 0;
                polys[totalpolys].containedbyid = 0;

                        //std::cerr << "polygon(" << osm_id << ") is no good: points(" << pline->getNumPoints() << "), closed(" << pline->isClosed() << "). " << writer.write(pline.get()) << std::endl;
                double distance = 0;
                std::auto_ptr<CoordinateSequence> segment;
                segment = std::auto_ptr<CoordinateSequence>(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
                segment->add(pline->getCoordinateN(0));
                for(unsigned i=1; i<pline->getNumPoints(); i++) {
                    segment->add(pline->getCoordinateN(i));
                    distance += pline->getCoordinateN(i).distance(pline->getCoordinateN(i-1));
                    if ((distance >= split_at) || (i == pline->getNumPoints()-1)) {
                        geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));

                        //copy of an empty one should be cheapest
                        wkts->push_back(geometry_builder::wkt_t());

                        wkts->back().geom = writer.write(geom.get());
                        wkts->back().area = 0;

                        segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
                        distance=0;
                        segment->add(pline->getCoordinateN(i));
                    }

                   }
                }

                Polygon* poly(gf->createPolygon(polys[i].ring, interior.release()));
                poly->normalize();
                polygons->push_back(poly);
            }

            // Make a multipolygon if required
            if ((toplevelpolygons > 1) && enable_multi)
            {
                geom_ptr multipoly(gf->createMultiPolygon(polygons.release()));
                if (!multipoly->isValid() && (excludepoly == 0)) {
                    multipoly = geom_ptr(multipoly->buffer(0));
                }

Return to bug 214819

Lines 94-101 Link Here

(-)./geometry-builder.cpp (-39 / +39 lines)
94		94
95	geometry_builder::maybe_wkt_t geometry_builder::get_wkt_simple(const osmNode *nodes, int count, int polygon) const	95	geometry_builder::maybe_wkt_t geometry_builder::get_wkt_simple(const osmNode *nodes, int count, int polygon) const
96	{	96	{
97	GeometryFactory gf;	97	GeometryFactory::unique_ptr gf = GeometryFactory::create();
98	std::auto_ptr<CoordinateSequence> coords(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	98	std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
99		99
100	try	100	try
101	{	101	{
Lines 109-116 Link Here
109	maybe_wkt_t wkt(new geometry_builder::wkt_t());	109	maybe_wkt_t wkt(new geometry_builder::wkt_t());
110	geom_ptr geom;	110	geom_ptr geom;
111	if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {	111	if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {
112	std::auto_ptr<LinearRing> shell(gf.createLinearRing(coords.release()));	112	std::auto_ptr<LinearRing> shell(gf->createLinearRing(coords.release()));
113	geom = geom_ptr(gf.createPolygon(shell.release(), new std::vector<Geometry *>));	113	geom = geom_ptr(gf->createPolygon(shell.release(), new std::vector<Geometry *>));
114	if (!geom->isValid()) {	114	if (!geom->isValid()) {
115	if (excludepoly) {	115	if (excludepoly) {
116	throw std::runtime_error("Excluding broken polygon.");	116	throw std::runtime_error("Excluding broken polygon.");
Lines 123-129 Link Here
123	} else {	123	} else {
124	if (coords->getSize() < 2)	124	if (coords->getSize() < 2)
125	throw std::runtime_error("Excluding degenerate line.");	125	throw std::runtime_error("Excluding degenerate line.");
126	geom = geom_ptr(gf.createLineString(coords.release()));	126	geom = geom_ptr(gf->createLineString(coords.release()));
127	wkt->area = 0;	127	wkt->area = 0;
128	}	128	}
129		129
Lines 149-156 Link Here
149		149
150	geometry_builder::maybe_wkts_t geometry_builder::get_wkt_split(const osmNode *nodes, int count, int polygon, double split_at) const	150	geometry_builder::maybe_wkts_t geometry_builder::get_wkt_split(const osmNode *nodes, int count, int polygon, double split_at) const
151	{	151	{
152	GeometryFactory gf;	152	GeometryFactory::unique_ptr gf = GeometryFactory::create();
153	std::auto_ptr<CoordinateSequence> coords(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	153	std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
154	WKTWriter writer;	154	WKTWriter writer;
155	//TODO: use count to get some kind of hint of how much we should reserve?	155	//TODO: use count to get some kind of hint of how much we should reserve?
156	maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);	156	maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);
Lines 166-173 Link Here
166		166
167	geom_ptr geom;	167	geom_ptr geom;
168	if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {	168	if (polygon && (coords->getSize() >= 4) && (coords->getAt(coords->getSize() - 1).equals2D(coords->getAt(0)))) {
169	std::auto_ptr<LinearRing> shell(gf.createLinearRing(coords.release()));	169	std::auto_ptr<LinearRing> shell(gf->createLinearRing(coords.release()));
170	geom = geom_ptr(gf.createPolygon(shell.release(), new std::vector<Geometry *>));	170	geom = geom_ptr(gf->createPolygon(shell.release(), new std::vector<Geometry *>));
171	if (!geom->isValid()) {	171	if (!geom->isValid()) {
172	if (excludepoly) {	172	if (excludepoly) {
173	throw std::runtime_error("Excluding broken polygon.");	173	throw std::runtime_error("Excluding broken polygon.");
Lines 189-195 Link Here
189		189
190	double distance = 0;	190	double distance = 0;
191	std::auto_ptr<CoordinateSequence> segment;	191	std::auto_ptr<CoordinateSequence> segment;
192	segment = std::auto_ptr<CoordinateSequence>(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	192	segment = std::auto_ptr<CoordinateSequence>(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
193	segment->add(coords->getAt(0));	193	segment->add(coords->getAt(0));
194	for(unsigned i=1; i<coords->getSize(); i++) {	194	for(unsigned i=1; i<coords->getSize(); i++) {
195	const Coordinate this_pt = coords->getAt(i);	195	const Coordinate this_pt = coords->getAt(i);
Lines 208-214 Link Here
208	const Coordinate interpolated(frac * (this_pt.x - prev_pt.x) + prev_pt.x,	208	const Coordinate interpolated(frac * (this_pt.x - prev_pt.x) + prev_pt.x,
209	frac * (this_pt.y - prev_pt.y) + prev_pt.y);	209	frac * (this_pt.y - prev_pt.y) + prev_pt.y);
210	segment->add(interpolated);	210	segment->add(interpolated);
211	geom_ptr geom = geom_ptr(gf.createLineString(segment.release()));	211	geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));
212		212
213	//copy of an empty one should be cheapest	213	//copy of an empty one should be cheapest
214	wkts->push_back(geometry_builder::wkt_t());	214	wkts->push_back(geometry_builder::wkt_t());
Lines 216-222 Link Here
216	wkts->back().geom = writer.write(geom.get());	216	wkts->back().geom = writer.write(geom.get());
217	wkts->back().area = 0;	217	wkts->back().area = 0;
218		218
219	segment.reset(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	219	segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
220	segment->add(interpolated);	220	segment->add(interpolated);
221	}	221	}
222	// reset the distance based on the final splitting point for	222	// reset the distance based on the final splitting point for
Lines 234-240 Link Here
234		234
235	// on the last iteration, close out the line.	235	// on the last iteration, close out the line.
236	if (i == coords->getSize()-1) {	236	if (i == coords->getSize()-1) {
237	geom_ptr geom = geom_ptr(gf.createLineString(segment.release()));	237	geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));
238		238
239	//copy of an empty one should be cheapest	239	//copy of an empty one should be cheapest
240	wkts->push_back(geometry_builder::wkt_t());	240	wkts->push_back(geometry_builder::wkt_t());
Lines 242-248 Link Here
242	wkts->back().geom = writer.write(geom.get());	242	wkts->back().geom = writer.write(geom.get());
243	wkts->back().area = 0;	243	wkts->back().area = 0;
244		244
245	segment.reset(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	245	segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
246	}	246	}
247	}	247	}
248	}	248	}
Lines 264-271 Link Here
264	}	264	}
265		265
266	int geometry_builder::parse_wkt(const char * wkt, struct osmNode * xnodes, int xcount, int * polygon) {	266	int geometry_builder::parse_wkt(const char * wkt, struct osmNode * xnodes, int xcount, int * polygon) {
267	GeometryFactory gf;	267	GeometryFactory::unique_ptr gf = GeometryFactory::create();
268	WKTReader reader(&gf);	268	WKTReader reader(gf.get());
269	std::string wkt_string(wkt);	269	std::string wkt_string(wkt);
270	Geometry * geometry;	270	Geometry * geometry;
271	const Geometry * subgeometry;	271	const Geometry * subgeometry;
Lines 329-335 Link Here
329	geometry_builder::maybe_wkts_t geometry_builder::build_polygons(const osmNode * const * xnodes, const int *xcount, bool enable_multi, osmid_t osm_id) const	329	geometry_builder::maybe_wkts_t geometry_builder::build_polygons(const osmNode * const * xnodes, const int *xcount, bool enable_multi, osmid_t osm_id) const
330	{	330	{
331	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);	331	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);
332	GeometryFactory gf;	332	GeometryFactory::unique_ptr gf = GeometryFactory::create();
333	geom_ptr geom;	333	geom_ptr geom;
334	geos::geom::prep::PreparedGeometryFactory pgf;	334	geos::geom::prep::PreparedGeometryFactory pgf;
335		335
Lines 339-345 Link Here
339	try	339	try
340	{	340	{
341	for (int c=0; xnodes[c]; c++) {	341	for (int c=0; xnodes[c]; c++) {
342	std::auto_ptr<CoordinateSequence> coords(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	342	std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
343	for (int i = 0; i < xcount[c]; i++) {	343	for (int i = 0; i < xcount[c]; i++) {
344	const osmNode *nodes = xnodes[c];	344	const osmNode *nodes = xnodes[c];
345	Coordinate c;	345	Coordinate c;
Lines 348-360 Link Here
348	coords->add(c, 0);	348	coords->add(c, 0);
349	}	349	}
350	if (coords->getSize() > 1) {	350	if (coords->getSize() > 1) {
351	geom = geom_ptr(gf.createLineString(coords.release()));	351	geom = geom_ptr(gf->createLineString(coords.release()));
352	lines->push_back(geom.release());	352	lines->push_back(geom.release());
353	}	353	}
354	}	354	}
355		355
356	//geom_ptr segment(0);	356	//geom_ptr segment(0);
357	geom_ptr mline (gf.createMultiLineString(lines.release()));	357	geom_ptr mline (gf->createMultiLineString(lines.release()));
358	//geom_ptr noded (segment->Union(mline.get()));	358	//geom_ptr noded (segment->Union(mline.get()));
359	LineMerger merger;	359	LineMerger merger;
360	//merger.add(noded.get());	360	//merger.add(noded.get());
Lines 371-378 Link Here
371	std::auto_ptr<LineString> pline ((*merged ) [i]);	371	std::auto_ptr<LineString> pline ((*merged ) [i]);
372	if (pline->getNumPoints() > 3 && pline->isClosed())	372	if (pline->getNumPoints() > 3 && pline->isClosed())
373	{	373	{
374	polys[totalpolys].polygon = gf.createPolygon(gf.createLinearRing(pline->getCoordinates()),0);	374	polys[totalpolys].polygon = gf->createPolygon(gf->createLinearRing(pline->getCoordinates()),0);
375	polys[totalpolys].ring = gf.createLinearRing(pline->getCoordinates());	375	polys[totalpolys].ring = gf->createLinearRing(pline->getCoordinates());
376	polys[totalpolys].area = polys[totalpolys].polygon->getArea();	376	polys[totalpolys].area = polys[totalpolys].polygon->getArea();
377	polys[totalpolys].iscontained = 0;	377	polys[totalpolys].iscontained = 0;
378	polys[totalpolys].containedbyid = 0;	378	polys[totalpolys].containedbyid = 0;
Lines 460-466 Link Here
460	}	460	}
461	}	461	}
462		462
463	Polygon* poly(gf.createPolygon(polys[i].ring, interior.release()));	463	Polygon* poly(gf->createPolygon(polys[i].ring, interior.release()));
464	poly->normalize();	464	poly->normalize();
465	polygons->push_back(poly);	465	polygons->push_back(poly);
466	}	466	}
Lines 468-474 Link Here
468	// Make a multipolygon if required	468	// Make a multipolygon if required
469	if ((toplevelpolygons > 1) && enable_multi)	469	if ((toplevelpolygons > 1) && enable_multi)
470	{	470	{
471	geom_ptr multipoly(gf.createMultiPolygon(polygons.release()));	471	geom_ptr multipoly(gf->createMultiPolygon(polygons.release()));
472	if (!multipoly->isValid() && (excludepoly == 0)) {	472	if (!multipoly->isValid() && (excludepoly == 0)) {
473	multipoly = geom_ptr(multipoly->buffer(0));	473	multipoly = geom_ptr(multipoly->buffer(0));
474	}	474	}
Lines 526-532 Link Here
526	geometry_builder::maybe_wkt_t geometry_builder::build_multilines(const osmNode * const * xnodes, const int *xcount, osmid_t osm_id) const	526	geometry_builder::maybe_wkt_t geometry_builder::build_multilines(const osmNode * const * xnodes, const int *xcount, osmid_t osm_id) const
527	{	527	{
528	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);	528	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);
529	GeometryFactory gf;	529	GeometryFactory::unique_ptr gf = GeometryFactory::create();
530	geom_ptr geom;	530	geom_ptr geom;
531		531
532	maybe_wkt_t wkt(new geometry_builder::wkt_t());	532	maybe_wkt_t wkt(new geometry_builder::wkt_t());
Lines 534-540 Link Here
534	try	534	try
535	{	535	{
536	for (int c=0; xnodes[c]; c++) {	536	for (int c=0; xnodes[c]; c++) {
537	std::auto_ptr<CoordinateSequence> coords(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	537	std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
538	for (int i = 0; i < xcount[c]; i++) {	538	for (int i = 0; i < xcount[c]; i++) {
539	const osmNode *nodes = xnodes[c];	539	const osmNode *nodes = xnodes[c];
540	Coordinate c;	540	Coordinate c;
Lines 543-555 Link Here
543	coords->add(c, 0);	543	coords->add(c, 0);
544	}	544	}
545	if (coords->getSize() > 1) {	545	if (coords->getSize() > 1) {
546	geom = geom_ptr(gf.createLineString(coords.release()));	546	geom = geom_ptr(gf->createLineString(coords.release()));
547	lines->push_back(geom.release());	547	lines->push_back(geom.release());
548	}	548	}
549	}	549	}
550		550
551	//geom_ptr segment(0);	551	//geom_ptr segment(0);
552	geom_ptr mline (gf.createMultiLineString(lines.release()));	552	geom_ptr mline (gf->createMultiLineString(lines.release()));
553	//geom_ptr noded (segment->Union(mline.get()));	553	//geom_ptr noded (segment->Union(mline.get()));
554		554
555	WKTWriter writer;	555	WKTWriter writer;
Lines 571-577 Link Here
571	int enable_multi, double split_at, osmid_t osm_id) const	571	int enable_multi, double split_at, osmid_t osm_id) const
572	{	572	{
573	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);	573	std::auto_ptr<std::vector<Geometry> > lines(new std::vector<Geometry>);
574	GeometryFactory gf;	574	GeometryFactory::unique_ptr gf = GeometryFactory::create();
575	geom_ptr geom;	575	geom_ptr geom;
576	geos::geom::prep::PreparedGeometryFactory pgf;	576	geos::geom::prep::PreparedGeometryFactory pgf;
577	maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);	577	maybe_wkts_t wkts(new std::vector<geometry_builder::wkt_t>);
Lines 580-586 Link Here
580	try	580	try
581	{	581	{
582	for (int c=0; xnodes[c]; c++) {	582	for (int c=0; xnodes[c]; c++) {
583	std::auto_ptr<CoordinateSequence> coords(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	583	std::auto_ptr<CoordinateSequence> coords(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
584	for (int i = 0; i < xcount[c]; i++) {	584	for (int i = 0; i < xcount[c]; i++) {
585	const osmNode *nodes = xnodes[c];	585	const osmNode *nodes = xnodes[c];
586	Coordinate c;	586	Coordinate c;
Lines 589-601 Link Here
589	coords->add(c, 0);	589	coords->add(c, 0);
590	}	590	}
591	if (coords->getSize() > 1) {	591	if (coords->getSize() > 1) {
592	geom = geom_ptr(gf.createLineString(coords.release()));	592	geom = geom_ptr(gf->createLineString(coords.release()));
593	lines->push_back(geom.release());	593	lines->push_back(geom.release());
594	}	594	}
595	}	595	}
596		596
597	//geom_ptr segment(0);	597	//geom_ptr segment(0);
598	geom_ptr mline (gf.createMultiLineString(lines.release()));	598	geom_ptr mline (gf->createMultiLineString(lines.release()));
599	//geom_ptr noded (segment->Union(mline.get()));	599	//geom_ptr noded (segment->Union(mline.get()));
600	LineMerger merger;	600	LineMerger merger;
601	//merger.add(noded.get());	601	//merger.add(noded.get());
Lines 612-619 Link Here
612	std::auto_ptr<LineString> pline ((*merged ) [i]);	612	std::auto_ptr<LineString> pline ((*merged ) [i]);
613	if (make_polygon && pline->getNumPoints() > 3 && pline->isClosed())	613	if (make_polygon && pline->getNumPoints() > 3 && pline->isClosed())
614	{	614	{
615	polys[totalpolys].polygon = gf.createPolygon(gf.createLinearRing(pline->getCoordinates()),0);	615	polys[totalpolys].polygon = gf->createPolygon(gf->createLinearRing(pline->getCoordinates()),0);
616	polys[totalpolys].ring = gf.createLinearRing(pline->getCoordinates());	616	polys[totalpolys].ring = gf->createLinearRing(pline->getCoordinates());
617	polys[totalpolys].area = polys[totalpolys].polygon->getArea();	617	polys[totalpolys].area = polys[totalpolys].polygon->getArea();
618	polys[totalpolys].iscontained = 0;	618	polys[totalpolys].iscontained = 0;
619	polys[totalpolys].containedbyid = 0;	619	polys[totalpolys].containedbyid = 0;
Lines 629-641 Link Here
629	//std::cerr << "polygon(" << osm_id << ") is no good: points(" << pline->getNumPoints() << "), closed(" << pline->isClosed() << "). " << writer.write(pline.get()) << std::endl;	629	//std::cerr << "polygon(" << osm_id << ") is no good: points(" << pline->getNumPoints() << "), closed(" << pline->isClosed() << "). " << writer.write(pline.get()) << std::endl;
630	double distance = 0;	630	double distance = 0;
631	std::auto_ptr<CoordinateSequence> segment;	631	std::auto_ptr<CoordinateSequence> segment;
632	segment = std::auto_ptr<CoordinateSequence>(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	632	segment = std::auto_ptr<CoordinateSequence>(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
633	segment->add(pline->getCoordinateN(0));	633	segment->add(pline->getCoordinateN(0));
634	for(unsigned i=1; i<pline->getNumPoints(); i++) {	634	for(unsigned i=1; i<pline->getNumPoints(); i++) {
635	segment->add(pline->getCoordinateN(i));	635	segment->add(pline->getCoordinateN(i));
636	distance += pline->getCoordinateN(i).distance(pline->getCoordinateN(i-1));	636	distance += pline->getCoordinateN(i).distance(pline->getCoordinateN(i-1));
637	if ((distance >= split_at) \|\| (i == pline->getNumPoints()-1)) {	637	if ((distance >= split_at) \|\| (i == pline->getNumPoints()-1)) {
638	geom_ptr geom = geom_ptr(gf.createLineString(segment.release()));	638	geom_ptr geom = geom_ptr(gf->createLineString(segment.release()));
639		639
640	//copy of an empty one should be cheapest	640	//copy of an empty one should be cheapest
641	wkts->push_back(geometry_builder::wkt_t());	641	wkts->push_back(geometry_builder::wkt_t());
Lines 643-649 Link Here
643	wkts->back().geom = writer.write(geom.get());	643	wkts->back().geom = writer.write(geom.get());
644	wkts->back().area = 0;	644	wkts->back().area = 0;
645		645
646	segment.reset(gf.getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));	646	segment.reset(gf->getCoordinateSequenceFactory()->create((size_t)0, (size_t)2));
647	distance=0;	647	distance=0;
648	segment->add(pline->getCoordinateN(i));	648	segment->add(pline->getCoordinateN(i));
649	}	649	}
Lines 730-736 Link Here
730	}	730	}
731	}	731	}
732		732
733	Polygon* poly(gf.createPolygon(polys[i].ring, interior.release()));	733	Polygon* poly(gf->createPolygon(polys[i].ring, interior.release()));
734	poly->normalize();	734	poly->normalize();
735	polygons->push_back(poly);	735	polygons->push_back(poly);
736	}	736	}
Lines 738-744 Link Here
738	// Make a multipolygon if required	738	// Make a multipolygon if required
739	if ((toplevelpolygons > 1) && enable_multi)	739	if ((toplevelpolygons > 1) && enable_multi)
740	{	740	{
741	geom_ptr multipoly(gf.createMultiPolygon(polygons.release()));	741	geom_ptr multipoly(gf->createMultiPolygon(polygons.release()));
742	if (!multipoly->isValid() && (excludepoly == 0)) {	742	if (!multipoly->isValid() && (excludepoly == 0)) {
743	multipoly = geom_ptr(multipoly->buffer(0));	743	multipoly = geom_ptr(multipoly->buffer(0));
744	}	744	}