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;
}
