void GeoParser::parseGeoJSONPolygon(const BSONObj& obj, S2Polygon* out) {
const vector<BSONElement>& coordinates =
obj.getFieldDotted(GEOJSON_COORDINATES).Array();
const vector<BSONElement>& exteriorRing = coordinates[0].Array();
vector<S2Point> exteriorVertices;
parsePoints(exteriorRing, &exteriorVertices);
S2PolygonBuilderOptions polyOptions;
polyOptions.set_validate(true);
S2PolygonBuilder polyBuilder(polyOptions);
S2Loop exteriorLoop(exteriorVertices);
if (exteriorLoop.is_hole()) {
exteriorLoop.Invert();
}
polyBuilder.AddLoop(&exteriorLoop);
// Subsequent arrays of coordinates are interior rings/holes.
for (size_t i = 1; i < coordinates.size(); ++i) {
vector<S2Point> holePoints;
parsePoints(coordinates[i].Array(), &holePoints);
// Interior rings are clockwise.
S2Loop holeLoop(holePoints);
if (!holeLoop.is_hole()) {
holeLoop.Invert();
}
polyBuilder.AddLoop(&holeLoop);
}
polyBuilder.AssemblePolygon(out, NULL);
}
static bool parseGeoJSONPolygonCoordinates(const vector<BSONElement>& coordinates,
const BSONObj &sourceObject,
S2Polygon *out) {
const vector<BSONElement>& exteriorRing = coordinates[0].Array();
vector<S2Point> exteriorVertices;
if (!parsePoints(exteriorRing, &exteriorVertices)) { return false; }
eraseDuplicatePoints(&exteriorVertices);
// The last point is duplicated. We drop it, since S2Loop expects no
// duplicate points
exteriorVertices.resize(exteriorVertices.size() - 1);
// S2 Polygon loops must have 3 vertices
if (exteriorVertices.size() < 3) { return false; }
S2PolygonBuilderOptions polyOptions;
polyOptions.set_validate(true);
// Don't silently eliminate duplicate edges.
polyOptions.set_xor_edges(false);
S2PolygonBuilder polyBuilder(polyOptions);
S2Loop exteriorLoop(exteriorVertices);
exteriorLoop.Normalize();
if (exteriorLoop.is_hole()) {
exteriorLoop.Invert();
}
if (!exteriorLoop.IsValid()) { return false; }
polyBuilder.AddLoop(&exteriorLoop);
// Subsequent arrays of coordinates are interior rings/holes.
for (size_t i = 1; i < coordinates.size(); ++i) {
vector<S2Point> holePoints;
if (!parsePoints(coordinates[i].Array(), &holePoints)) { return false; }
eraseDuplicatePoints(&holePoints);
// Drop the duplicated last point.
holePoints.resize(holePoints.size() - 1);
// S2 Polygon loops must have 3 vertices
if (holePoints.size() < 3) { return false; }
// Interior rings are clockwise.
S2Loop holeLoop(holePoints);
holeLoop.Normalize();
if (!holeLoop.IsValid()) { return false; }
if (!holeLoop.is_hole()) {
if (!exteriorLoop.Contains(&holeLoop)) { return false; }
holeLoop.Invert();
} else {
// It's already clockwise; we need to invert once to check that it's contained in
// the shell, then invert again.
holeLoop.Invert();
if (!exteriorLoop.Contains(&holeLoop)) { return false; }
holeLoop.Invert();
}
polyBuilder.AddLoop(&holeLoop);
}
return polyBuilder.AssemblePolygon(out, NULL);
}
static bool parseBigSimplePolygonCoordinates(const vector<BSONElement>& coordinates,
const BSONObj &sourceObject,
BigSimplePolygon *out) {
// Only one loop is allowed in a BigSimplePolygon
if (coordinates.size() != 1)
return false;
const vector<BSONElement>& exteriorRing = coordinates[0].Array();
vector<S2Point> exteriorVertices;
if (!parsePoints(exteriorRing, &exteriorVertices))
return false;
eraseDuplicatePoints(&exteriorVertices);
// The last point is duplicated. We drop it, since S2Loop expects no
// duplicate points
exteriorVertices.resize(exteriorVertices.size() - 1);
// S2 Polygon loops must have 3 vertices
if (exteriorVertices.size() < 3)
return false;
auto_ptr<S2Loop> loop(new S2Loop(exteriorVertices));
if (!loop->IsValid())
return false;
out->Init(loop.release());
return true;
}
QList< QVector<QPointF> > parseFile(const QString &fileName)
{
QList< QVector<QPointF> > res;
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly)) {
qDebug()<<"couldn't open "<<fileName;
return res;
}
QVector<QPointF> current;
while (!file.atEnd()) {
QByteArray line = file.readLine().trimmed();
if (line.isEmpty() || line.startsWith('/')) {
if (!current.isEmpty()) {
res.append(current);
current = QVector<QPointF>();
}
continue;
} else {
QList<QPointF> lst = parsePoints(line);
current << lst.toVector();
}
}
return res;
}
static bool isValidLineString(const vector<BSONElement>& coordinateArray) {
if (coordinateArray.size() < 2) { return false; }
if (!isArrayOfCoordinates(coordinateArray)) { return false; }
vector<S2Point> vertices;
if (!parsePoints(coordinateArray, &vertices)) { return false; }
eraseDuplicatePoints(&vertices);
return S2Polyline::IsValid(vertices);
}
void GeoParser::parseGeoJSONPolygon(const BSONObj& obj, S2Polygon* out) {
const vector<BSONElement>& coordinates =
obj.getFieldDotted(GEOJSON_COORDINATES).Array();
const vector<BSONElement>& exteriorRing = coordinates[0].Array();
vector<S2Point> exteriorVertices;
parsePoints(exteriorRing, &exteriorVertices);
// The last point is duplicated. We drop it, since S2Loop expects no
// duplicate points
exteriorVertices.resize(exteriorVertices.size() - 1);
S2PolygonBuilderOptions polyOptions;
polyOptions.set_validate(true);
// Don't silently eliminate duplicate edges.
polyOptions.set_xor_edges(false);
S2PolygonBuilder polyBuilder(polyOptions);
S2Loop exteriorLoop(exteriorVertices);
exteriorLoop.Normalize();
if (exteriorLoop.is_hole()) {
exteriorLoop.Invert();
}
uassert(16693, "Exterior shell of polygon is invalid: " + obj.toString(),
exteriorLoop.IsValid());
polyBuilder.AddLoop(&exteriorLoop);
// Subsequent arrays of coordinates are interior rings/holes.
for (size_t i = 1; i < coordinates.size(); ++i) {
vector<S2Point> holePoints;
parsePoints(coordinates[i].Array(), &holePoints);
// Drop the duplicated last point.
holePoints.resize(holePoints.size() - 1);
// Interior rings are clockwise.
S2Loop holeLoop(holePoints);
holeLoop.Normalize();
uassert(16694, "Interior hole of polygon is invalid: " + obj.toString(),
holeLoop.IsValid());
if (!holeLoop.is_hole()) {
holeLoop.Invert();
}
polyBuilder.AddLoop(&holeLoop);
}
uassert(16695, "Couldn't assemble polygon: " + obj.toString(),
polyBuilder.AssemblePolygon(out, NULL));
}
bool GeoParser::parseLine(const BSONObj& obj, LineWithCRS* out) {
vector<S2Point> vertices;
if (!parsePoints(obj.getFieldDotted(GEOJSON_COORDINATES).Array(), &vertices)) {
return false;
}
eraseDuplicatePoints(&vertices);
out->line.Init(vertices);
out->crs = SPHERE;
return true;
}
bool GeoParser::parseMultiLine(const BSONObj &obj, MultiLineWithCRS *out) {
vector<BSONElement> coordElt = obj.getFieldDotted(GEOJSON_COORDINATES).Array();
out->lines.mutableVector().clear();
out->lines.mutableVector().resize(coordElt.size());
for (size_t i = 0; i < coordElt.size(); ++i) {
vector<S2Point> vertices;
if (!parsePoints(coordElt[i].Array(), &vertices)) { return false; }
out->lines.mutableVector()[i] = new S2Polyline();
out->lines.mutableVector()[i]->Init(vertices);
}
return true;
}
void LightWaveParser::loadModel(string fname) {
in.open(fname.c_str(), ios::in | ios::binary);
if (!in.good()) {
fprintf(stderr, "Lightwave Parser: Error opening %s\n", fname.c_str());
return ;
}
string chunkID = readChunkID(in, 4);
int size = readIntBE(in);
int count = 0;
readChunkID(in, 4); // read LWO2
count += 4;
while(count < size) {
chunkID = readChunkID(in, 4);
count += 4;
fprintf(stderr, "ID = %s\n", chunkID.c_str());
if(chunkID == "TAGS") {
count += parseTags();
}
else if(chunkID == "PNTS") {
count += parsePoints();
}
else if(chunkID == "POLS") {
count += parsePolygons();
}
else if(chunkID == "PTAG") {
parsePTag();
}
else if(chunkID == "SURF") {
parseSurface();
}
else {
count += skipChunk();
}
}
in.close();
calculateNormals();
setupCells();
}
xmlDocPtr createXmlDoc(SHAPE *shape, RULESET *ruleset)
{
int i, j;
xmlDocPtr doc = NULL;
xmlNodePtr root_node = NULL;
srid = shape->srid;
// apply ruleset, set alt field name to use for osm tags
for (i = 0; i < (shape->num_fields - 1); i++)
{
for (j = 0; j < (ruleset->num_rules - 1); j++) {
if ((strcmp(getKey(&shape->fields[i]), getKey(&ruleset->rules[j])) == 0))
{
setValue(&shape->fields[i], getValue(&ruleset->rules[j]));
}
}
}
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "osm");
xmlNewProp(root_node, BAD_CAST "version", BAD_CAST xmlEscape("0.6"));
xmlDocSetRootElement(doc, root_node);
if (shape->filetype == SHPT_POINT)
{
buildNodes(root_node, parsePoints(shape), shape);
} else if (shape->filetype == SHPT_MULTIPOINT) {
// TODO
fprintf(stderr, "Error: Unknown or invalid shapefile type\n");
exit(0);
} else if (shape->filetype == SHPT_ARC) {
parseLine(root_node, shape);
} else {
fprintf(stderr, "Error: Unknown or invalid shapefile type\n");
exit(0);
}
fprintf(stderr, "Done: processed %d records.\n", shape->num_records);
return doc;
}
bool GeoParser::isGeoJSONLineString(const BSONObj& obj) {
BSONElement type = obj.getFieldDotted(GEOJSON_TYPE);
if (type.eoo() || (String != type.type())) { return false; }
if (GEOJSON_TYPE_LINESTRING != type.String()) { return false; }
if (!crsIsOK(obj)) {
warning() << "Invalid CRS: " << obj.toString() << endl;
return false;
}
BSONElement coordElt = obj.getFieldDotted(GEOJSON_COORDINATES);
if (coordElt.eoo() || (Array != coordElt.type())) { return false; }
const vector<BSONElement>& coordinateArray = coordElt.Array();
if (coordinateArray.size() < 2) { return false; }
if (!isArrayOfCoordinates(coordinateArray)) { return false; }
vector<S2Point> vertices;
parsePoints(obj.getFieldDotted(GEOJSON_COORDINATES).Array(), &vertices);
return S2Polyline::IsValid(vertices);
}
void SVGPolyElement::parseMappedAttribute(MappedAttribute* attr)
{
const AtomicString& value = attr->value();
if (attr->name() == SVGNames::pointsAttr) {
ExceptionCode ec = 0;
points()->clear(ec);
if (!parsePoints(value) && !m_ignoreAttributeChanges) {
points()->clear(ec);
document()->accessSVGExtensions()->reportError("Problem parsing points=\"" + value + "\"");
}
} else {
if (SVGTests::parseMappedAttribute(attr))
return;
if (SVGLangSpace::parseMappedAttribute(attr))
return;
if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
return;
SVGStyledTransformableElement::parseMappedAttribute(attr);
}
}
QList< QVector<QPointF> > parseData(const QByteArray &contents)
{
QList<QByteArray> lines = contents.split('\n');
QList<QByteArray>::const_iterator itr;
QList< QVector<QPointF> > res;
QVector<QPointF> current;
for (itr = lines.begin(); itr != lines.end(); ++itr) {
QByteArray line = (*itr).trimmed();
if (line.isEmpty() || line.startsWith('/')) {
if (!current.isEmpty()) {
res.append(current);
current = QVector<QPointF>();
}
continue;
} else {
QList<QPointF> lst = parsePoints(line);
current << lst.toVector();
}
}
return res;
}
void GeoParser::parseGeoJSONLineString(const BSONObj& obj, S2Polyline* out) {
vector<S2Point> vertices;
parsePoints(obj.getFieldDotted(GEOJSON_COORDINATES).Array(), &vertices);
out->Init(vertices);
}
