void ForceValidityVisitor::visit( MultiLineString& g )
{
g.forceValidityFlag( valid_ );
for ( size_t i = 0; i < g.numGeometries(); i++ ) {
visit( g.lineStringN( i ) );
}
}
std::auto_ptr<Geometry> collect( const Geometry& ga, const Geometry& gb )
{
if ( ga.geometryTypeId() == gb.geometryTypeId() ) {
if ( ga.geometryTypeId() == TYPE_POINT ) {
MultiPoint *mp = new MultiPoint;
mp->addGeometry( ga );
mp->addGeometry( gb );
return std::auto_ptr<Geometry>(mp);
}
else if ( ga.geometryTypeId() == TYPE_LINESTRING ) {
MultiLineString *mls = new MultiLineString();
mls->addGeometry(ga);
mls->addGeometry(gb);
return std::auto_ptr<Geometry>( mls );
}
else if ( ga.geometryTypeId() == TYPE_POLYGON ) {
MultiPolygon *mp = new MultiPolygon();
mp->addGeometry(ga);
mp->addGeometry(gb);
return std::auto_ptr<Geometry>( mp );
}
else if ( ga.geometryTypeId() == TYPE_SOLID ) {
MultiSolid *mp = new MultiSolid();
mp->addGeometry(ga);
mp->addGeometry(gb);
return std::auto_ptr<Geometry>( mp );
}
}
// else
GeometryCollection* coll = new GeometryCollection();
coll->addGeometry(ga);
coll->addGeometry(gb);
return std::auto_ptr<Geometry>( coll );
}
mapnik::geometry::multi_line_string<double> geowave_featureset::create_multi_line_string(MultiLineString multi_line_string)
{
mapnik::geometry::multi_line_string<double> multi_line_string_out;
for (int geom_idx = 0; geom_idx < multi_line_string.getNumGeometries(); ++geom_idx)
multi_line_string_out.push_back(create_line_string(java_cast<LineString>(multi_line_string.getGeometryN(geom_idx))));
return multi_line_string_out;
}
Handle<Value> MultiLineString::New(const Arguments& args)
{
HandleScope scope;
MultiLineString *f;
if (!args.IsConstructCall()) {
return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword");
}
if (args[0]->IsExternal()) {
Local<External> ext = Local<External>::Cast(args[0]);
void* ptr = ext->Value();
f = static_cast<MultiLineString *>(ptr);
} else {
if (args.Length() != 0) {
return NODE_THROW("MultiLineString constructor doesn't take any arguments");
}
f = new MultiLineString(new OGRMultiLineString());
}
Handle<Value> children = GeometryCollectionChildren::New(args.This());
args.This()->SetHiddenValue(String::NewSymbol("children_"), children);
f->Wrap(args.This());
return args.This();
}
TEST(TileCover, DISABLED_FuzzLine) {
while(1)
{
std::srand (time(NULL));
std::size_t len = std::rand() % 10000 + 3;
MultiLineString<double> mls;
std::size_t num_lines = 1;
num_lines += std::rand() % 5;
while (num_lines > 0) {
LineString<double> line;
for (std::size_t i = 0; i < len; ++i) {
double x = std::rand() % 180;
double y = std::rand() % 90;
line.push_back({x,y});
}
mls.emplace_back(line);
--num_lines;
}
std::clog << ".";
util::TileCover tc(mls, 5);
while(tc.next()) {
};
}
}
void WktWriter::write( const MultiLineString & g )
{
_s << "MULTILINESTRING" ;
if ( g.isEmpty() ){
_s << " EMPTY" ;
return ;
}
_s << "(";
for ( size_t i = 0; i < g.numGeometries(); i++ ){
if ( i != 0 )
_s << "," ;
writeInner( g.geometryN(i).as< LineString >() );
}
_s << ")";
}
void straightSkeletonToMultiLineString(
const CGAL::Straight_skeleton_2<K> & ss,
MultiLineString& result
)
{
typedef CGAL::Straight_skeleton_2<K> Ss ;
typedef typename Ss::Vertex_const_handle Vertex_const_handle ;
typedef typename Ss::Halfedge_const_handle Halfedge_const_handle ;
typedef typename Ss::Halfedge_const_iterator Halfedge_const_iterator ;
Halfedge_const_handle null_halfedge ;
Vertex_const_handle null_vertex ;
for ( Halfedge_const_iterator it = ss.halfedges_begin(); it != ss.halfedges_end(); ++it ){
// skip contour edge
if ( ! it->is_bisector() ){
continue ;
}
// avoid duplicates
if ( it->opposite() < it ){
continue ;
}
result.addGeometry( new LineString(
Point( it->opposite()->vertex()->point() ),
Point( it->vertex()->point() )
) );
}
}
void BoundaryVisitor::visit( const MultiLineString& g )
{
if ( g.isEmpty() ) {
_boundary.reset();
return ;
}
/*
* create a GeometryGraph and rely on vertex degree (1 means boundary)
*/
graph::GeometryGraph graph ;
graph::GeometryGraphBuilder graphBuilder( graph ) ;
for ( size_t i = 0; i < g.numGeometries(); i++ ) {
graphBuilder.addLineString( g.lineStringN( i ) );
}
getBoundaryFromLineStrings( graph ) ;
}
void GetPointsVisitor::visit( const MultiLineString& g )
{
for ( size_t i = 0; i < g.numGeometries(); i++ ) {
visit( g.lineStringN( i ) );
}
}
inline MultiLineStringBaseType::const_iterator range_end(const MultiLineString& mls) {return mls.end();}
inline MultiLineStringBaseType::const_iterator range_begin(const MultiLineString& mls) {return mls.begin();}
static Feature::geometry_type convertGeometry(const GeometryTileFeature& geometryTileFeature, const CanonicalTileID& tileID) {
const double size = util::EXTENT * std::pow(2, tileID.z);
const double x0 = util::EXTENT * tileID.x;
const double y0 = util::EXTENT * tileID.y;
auto tileCoordinatesToLatLng = [&] (const Point<int16_t>& p) {
double y2 = 180 - (p.y + y0) * 360 / size;
return Point<double>(
(p.x + x0) * 360 / size - 180,
360.0 / M_PI * std::atan(std::exp(y2 * M_PI / 180)) - 90.0
);
};
GeometryCollection geometries = geometryTileFeature.getGeometries();
switch (geometryTileFeature.getType()) {
case FeatureType::Unknown: {
assert(false);
return Point<double>(NAN, NAN);
}
case FeatureType::Point: {
MultiPoint<double> multiPoint;
for (const auto& p : geometries.at(0)) {
multiPoint.push_back(tileCoordinatesToLatLng(p));
}
if (multiPoint.size() == 1) {
return multiPoint[0];
} else {
return multiPoint;
}
}
case FeatureType::LineString: {
MultiLineString<double> multiLineString;
for (const auto& g : geometries) {
LineString<double> lineString;
for (const auto& p : g) {
lineString.push_back(tileCoordinatesToLatLng(p));
}
multiLineString.push_back(std::move(lineString));
}
if (multiLineString.size() == 1) {
return multiLineString[0];
} else {
return multiLineString;
}
}
case FeatureType::Polygon: {
MultiPolygon<double> multiPolygon;
for (const auto& pg : classifyRings(geometries)) {
Polygon<double> polygon;
for (const auto& r : pg) {
LinearRing<double> linearRing;
for (const auto& p : r) {
linearRing.push_back(tileCoordinatesToLatLng(p));
}
polygon.push_back(std::move(linearRing));
}
multiPolygon.push_back(std::move(polygon));
}
if (multiPolygon.size() == 1) {
return multiPolygon[0];
} else {
return multiPolygon;
}
}
}
// Unreachable, but placate GCC.
return Point<double>();
}
