bool VirtualKeyboardParser::parserCallback_area(ParserNode *node) { String &shape = node->values["shape"]; String &target = node->values["target"]; String &coords = node->values["coords"]; if (target.equalsIgnoreCase("display_area")) { if (!shape.equalsIgnoreCase("rect")) return parserError("display_area must be a rect area"); _mode->displayArea = Rect(); return parseRect(_mode->displayArea, coords); } else if (shape.equalsIgnoreCase("rect")) { Polygon *poly = _mode->imageMap.createArea(target); if (!poly) return parserError(Common::String::format("Cannot define area '%s' again", target.c_str())); else return parseRectAsPolygon(*poly, coords); } else if (shape.equalsIgnoreCase("poly")) { Polygon *poly = _mode->imageMap.createArea(target); if (!poly) return parserError(Common::String::format("Cannot define area '%s' again", target.c_str())); else return parsePolygon(*poly, coords); } return parserError("Area shape '" + shape + "' not known"); }
bool CGarminTyp::decode(QDataStream& in, QMap<quint32, polygon_property>& polygons, QMap<quint32, polyline_property>& polylines, QList<quint32>& drawOrder, QMap<quint32, point_property>& points) { if(!parseHeader(in)) { return false; } if(!parseDrawOrder(in, drawOrder)) { return false; } if(!parsePolygon(in, polygons)) { return false; } if(!parsePolyline(in, polylines)) { return false; } if(!parsePoint(in, points)) { return false; } return true; }
/// Parses osm json data from stream calling visitor. void parse(std::istream &istream, Visitor &visitor) const { istream.unsetf(std::ios::skipws); ptree pt; read_json(istream, pt); for (const ptree::value_type &feature : pt) { std::string featureName = feature.first; std::uint32_t featureId = stringTable_.getId(featureName); for (const ptree::value_type &f : pt.get_child(featureName).get_child("features")) { const auto &type = f.second.get_child("geometry.type").data(); if (type=="Point") parsePoint(visitor, featureId, f.second); else if (type=="LineString") parseLineString(visitor, featureId, f.second); else if (type=="Polygon") parsePolygon(visitor, featureId, f.second); else if (type=="MultiLineString") parseMultiLineString(visitor, featureId, f.second); else if (type=="MultiPolygon") parseMultiPolygon(visitor, featureId, f.second); else throw std::invalid_argument(std::string("Unknown geometry type:") + type); } } }
int main(int argc, char * argv[]){ if(argc < 2){ printf("Usage: %s <filename> <Q.x> <Q.y>\n", argv[0]); return EXIT_FAILURE; } int n; point * polygon = parsePolygon(argv[1], &n); point O = {1,1}; polar_angle_sort(polygon, n, O); print_polygon(polygon, n); return EXIT_SUCCESS; }
Polygon_with_holes Parser::parsePolygonWithHoles() { _tokens.consume(Token::LEFT_PARENTHESIS); Polygon boundary = parsePolygon(); if (boundary.orientation() != CGAL::COUNTERCLOCKWISE) { std::cerr << "WARNING: Polygon boundary is not oriented counter-clockwise. Reversing orientation..." << std::endl; boundary.reverse_orientation(); } std::list<Polygon> holes; while (_tokens.peek().type() == Token::COMMA) { _tokens.consume(Token::COMMA); Polygon hole = parsePolygon(); if (hole.orientation() != CGAL::CLOCKWISE) { std::cerr << "WARNING: Polygon hole is not oriented clockwise. Reversing orientation..." << std::endl; hole.reverse_orientation(); } holes.push_back(hole); } _tokens.consume(Token::RIGHT_PARENTHESIS); return Polygon_with_holes(boundary, holes.begin(), holes.end()); }
bool GeoParser::parseGeometryCollection(const BSONObj &obj, GeometryCollection *out) { BSONElement coordElt = obj.getFieldDotted(GEOJSON_GEOMETRIES); const vector<BSONElement>& geometries = coordElt.Array(); for (size_t i = 0; i < geometries.size(); ++i) { const BSONObj& geoObj = geometries[i].Obj(); if (isGeoJSONPoint(geoObj)) { PointWithCRS point; if (!parsePoint(geoObj, &point)) { return false; } out->points.push_back(point); } else if (isLine(geoObj)) { out->lines.mutableVector().push_back(new LineWithCRS()); if (!parseLine(geoObj, out->lines.vector().back())) { return false; } } else if (isGeoJSONPolygon(geoObj)) { out->polygons.mutableVector().push_back(new PolygonWithCRS()); if (!parsePolygon(geoObj, out->polygons.vector().back())) { return false; } } else if (isMultiPoint(geoObj)) { out->multiPoints.mutableVector().push_back(new MultiPointWithCRS()); if (!parseMultiPoint(geoObj, out->multiPoints.mutableVector().back())) { return false; } } else if (isMultiPolygon(geoObj)) { out->multiPolygons.mutableVector().push_back(new MultiPolygonWithCRS()); if (!parseMultiPolygon(geoObj, out->multiPolygons.mutableVector().back())) { return false; } } else { verify(isMultiLine(geoObj)); out->multiLines.mutableVector().push_back(new MultiLineWithCRS()); if (!parseMultiLine(geoObj, out->multiLines.mutableVector().back())) { return false; } } } return true; }
bool SvmParser::parse(const QByteArray &data) { // Check the signature "VCLMTF" if (!data.startsWith("VCLMTF")) return false; QBuffer buffer((QByteArray *) &data); buffer.open(QIODevice::ReadOnly); QDataStream mainStream(&buffer); mainStream.setByteOrder(QDataStream::LittleEndian); // Start reading from the stream: read past the signature and get the header. soakBytes(mainStream, 6); SvmHeader header(mainStream); #if DEBUG_SVMPARSER debugVectorImage << "================ SVM HEADER ================"; debugVectorImage << "version, length:" << header.versionCompat.version << header.versionCompat.length; debugVectorImage << "compressionMode:" << header.compressionMode; debugVectorImage << "mapMode:" << "Origin" << header.mapMode.origin << "scaleX" << header.mapMode.scaleX.numerator << header.mapMode.scaleX.denominator << (qreal(header.mapMode.scaleX.numerator) / header.mapMode.scaleX.denominator) << "scaleY" << header.mapMode.scaleY.numerator << header.mapMode.scaleY.denominator << (qreal(header.mapMode.scaleY.numerator) / header.mapMode.scaleY.denominator); debugVectorImage << "size:" << header.width << header.height; debugVectorImage << "actionCount:" << header.actionCount; debugVectorImage << "================ SVM HEADER ================"; #endif mBackend->init(header); #if DEBUG_SVMPARSER { QPolygon polygon; polygon << QPoint(0, 0); polygon << QPoint(header.width, header.height); mBackend->polyLine(mContext, polygon); } #endif // Parse all actions and call the appropriate backend callback for // the graphics drawing actions. The context actions will // manipulate the graphics context, which is maintained here. for (uint action = 0; action < header.actionCount; ++action) { quint16 actionType; quint16 version; quint32 totalSize; // Here starts the Action itself. The first two bytes is the action type. mainStream >> actionType; // The VersionCompat object mainStream >> version; mainStream >> totalSize; char *rawData = new char[totalSize]; mainStream.readRawData(rawData, totalSize); QByteArray dataArray(rawData, totalSize); QDataStream stream(&dataArray, QIODevice::ReadOnly); stream.setByteOrder(QDataStream::LittleEndian); // Debug #if DEBUG_SVMPARSER { QString name; if (actionType == 0) name = actionNames[0].actionName; else if (100 <= actionType && actionType <= META_LAST_ACTION) name = actionNames[actionType - 99].actionName; else if (actionType == 512) name = "META_COMMENT_ACTION"; else name = "(out of bounds)"; debugVectorImage << name << "(" << actionType << ")" << "version" << version << "totalSize" << totalSize; } #endif // Parse all actions. switch (actionType) { case META_NULL_ACTION: break; case META_PIXEL_ACTION: break; case META_POINT_ACTION: break; case META_LINE_ACTION: break; case META_RECT_ACTION: { QRect rect; parseRect(stream, rect); debugVectorImage << "Rect:" << rect; mBackend->rect(mContext, rect); } break; case META_ROUNDRECT_ACTION: break; case META_ELLIPSE_ACTION: break; case META_ARC_ACTION: break; case META_PIE_ACTION: break; case META_CHORD_ACTION: break; case META_POLYLINE_ACTION: { QPolygon polygon; parsePolygon(stream, polygon); debugVectorImage << "Polyline:" << polygon; mBackend->polyLine(mContext, polygon); // FIXME: Version 2: Lineinfo, Version 3: polyflags if (version > 1) soakBytes(stream, totalSize - 2 - 4 * 2 * polygon.size()); } break; case META_POLYGON_ACTION: { QPolygon polygon; parsePolygon(stream, polygon); debugVectorImage << "Polygon:" << polygon; mBackend->polygon(mContext, polygon); // FIXME: Version 2: Lineinfo, Version 3: polyflags if (version > 1) soakBytes(stream, totalSize - 2 - 4 * 2 * polygon.size()); } break; case META_POLYPOLYGON_ACTION: { quint16 polygonCount; stream >> polygonCount; //debugVectorImage << "Number of polygons:" << polygonCount; QList<QPolygon> polygons; for (quint16 i = 0 ; i < polygonCount ; i++) { QPolygon polygon; parsePolygon(stream, polygon); polygons << polygon; //debugVectorImage << "Polygon:" << polygon; } if (version > 1) { quint16 complexPolygonCount; stream >> complexPolygonCount; //debugVectorImage << "Number of complex polygons:" << complexPolygonCount; // Parse the so called "complex polygons". For // each one, there is an index and a polygon. The // index tells which of the original polygons to // replace. for (quint16 i = 0; i < complexPolygonCount; i++) { quint16 complexPolygonIndex; stream >> complexPolygonIndex; QPolygon polygon; parsePolygon(stream, polygon); //debugVectorImage << "polygon index:" << complexPolygonIndex << polygon; // FIXME: The so called complex polygons have something to do // with modifying the polygons, but I have not yet been // able to understand how. So until I do, we'll disable // this. //polygons[complexPolygonIndex] = polygon; } } mBackend->polyPolygon(mContext, polygons); } break; case META_TEXT_ACTION: break; case META_TEXTARRAY_ACTION: { QPoint startPoint; QString string; quint16 startIndex; quint16 len; quint32 dxArrayLen; qint32 *dxArray = 0; stream >> startPoint; parseString(stream, string); stream >> startIndex; stream >> len; stream >> dxArrayLen; if (dxArrayLen > 0) { quint32 maxDxArrayLen = totalSize - stream.device()->pos(); if (dxArrayLen > maxDxArrayLen) { debugVectorImage << "Defined dxArrayLen= " << dxArrayLen << "exceeds availalable size" << maxDxArrayLen; dxArrayLen = maxDxArrayLen; } dxArray = new qint32[dxArrayLen]; for (uint i = 0; i < dxArrayLen; ++i) stream >> dxArray[i]; } if (version > 1) { quint16 len2; stream >> len2; // FIXME: More here } #if 0 debugVectorImage << "Text: " << startPoint << string << startIndex << len; if (dxArrayLen > 0) { debugVectorImage << "dxArrayLen:" << dxArrayLen; for (uint i = 0; i < dxArrayLen; ++i) debugVectorImage << dxArray[i]; } else debugVectorImage << "dxArrayLen = 0"; #endif mBackend->textArray(mContext, startPoint, string, startIndex, len, dxArrayLen, dxArray); if (dxArrayLen) delete[] dxArray; }