inet::visualizer::OpenStreetMapSceneCanvasVisualizer Class Reference

#include <OpenStreetMapSceneCanvasVisualizer.h>

Inheritance diagram for inet::visualizer::OpenStreetMapSceneCanvasVisualizer:

Protected Member Functions
virtual void	initialize (int stage) override
cFigure::Point	toCanvas (const osm::OpenStreetMap &map, double lat, double lon)
cGroupFigure *	createMapFigure (const osm::OpenStreetMap &map)
Protected Member Functions inherited from inet::visualizer::SceneVisualizerBase
virtual Box	getSceneBounds ()
Protected Member Functions inherited from inet::visualizer::VisualizerBase
virtual int	numInitStages () const override
virtual Coord	getPosition (const cModule *networkNode) const
virtual Coord	getContactPosition (const cModule *networkNode, const Coord &fromPosition, const char *contactMode, double contactSpacing) const
virtual Quaternion	getOrientation (const cModule *networkNode) const
virtual void	mapChunks (const Ptr< const Chunk > &chunk, const std::function< void(const Ptr< const Chunk > &, int)> &thunk) const

Protected Attributes
ModuleRefByPar< IGeographicCoordinateSystem >	coordinateSystem
CanvasProjection *	canvasProjection = nullptr
Protected Attributes inherited from inet::visualizer::SceneVisualizerBase
Coord	sceneMin
Coord	sceneMax
Protected Attributes inherited from inet::visualizer::VisualizerBase
cModule *	visualizationTargetModule = nullptr
cModule *	visualizationSubjectModule = nullptr
const char *	tags = nullptr

Member Function Documentation

createMapFigure()

cGroupFigure * inet::visualizer::OpenStreetMapSceneCanvasVisualizer::createMapFigure ( const osm::OpenStreetMap &  map )

protected

{
    const cFigure::Color COLOR_HIGHWAY_PRIMARY = { 255, 255, 120 };
    const cFigure::Color COLOR_HIGHWAY_RESIDENTIAL = { 240, 240, 240 };
    const cFigure::Color COLOR_HIGHWAY_PATH = { 128, 128, 128 };
 
    auto buildings = new cGroupFigure("buildings");
    buildings->setTags("buildings");
    auto primaryStreets = new cGroupFigure("primaryStreets");
    primaryStreets->setTags("primary_streets");
    auto residentialStreets = new cGroupFigure("residentialStreets");
    residentialStreets->setTags("residential_streets");
    auto pathways = new cGroupFigure("pathways");
    pathways->setTags("pathways");
 
    auto mapFigure = new cGroupFigure("openStreetMap");
    mapFigure->setTags("street_map");
    mapFigure->addFigure(buildings);
    mapFigure->addFigure(pathways);
    mapFigure->addFigure(residentialStreets);
    mapFigure->addFigure(primaryStreets);
 
    for (const auto& way : map.getWays()) {
        std::vector<cFigure::Point> points;
        for (const auto& node : way->getNodes())
            points.push_back(toCanvas(map, node->getLat(), node->getLon()));
        bool isArea = way->getNodes().front() == way->getNodes().back();
 
        if (!isArea) {
            // road, street, footway, etc.
            cPolylineFigure *polyline = new cPolylineFigure();
            polyline->setPoints(points);
            polyline->setZoomLineWidth(true);
 
            polyline->setName(std::to_string(way->getId()).c_str());
            const char *name = way->getTag("name");
            if (name != nullptr)
                polyline->setTooltip(name);
 
            std::string highwayType = opp_nulltoempty(way->getTag("highway"));
            if (highwayType == "primary" || highwayType == "secondary" || highwayType == "tertiary" ||
                highwayType == "primary_link" || highwayType == "secondary_link" || highwayType == "tertiary_link")
            {
                polyline->setLineWidth(8);
                polyline->setLineColor(COLOR_HIGHWAY_PRIMARY);
                polyline->setCapStyle(cFigure::CAP_ROUND);
                polyline->setJoinStyle(cFigure::JOIN_ROUND);
                primaryStreets->addFigure(polyline);
            }
            else if (highwayType == "residential" || highwayType == "service") {
                polyline->setLineWidth(4);
                polyline->setLineColor(COLOR_HIGHWAY_RESIDENTIAL);
                polyline->setCapStyle(cFigure::CAP_ROUND);
                polyline->setJoinStyle(cFigure::JOIN_ROUND);
                residentialStreets->addFigure(polyline);
            }
            else if (highwayType != "") { // footpath or similar
                polyline->setLineStyle(cFigure::LINE_DOTTED);
                polyline->setLineColor(COLOR_HIGHWAY_PATH);
                pathways->addFigure(polyline);
            }
            else { // administrative boundary or some other non-path thing
                delete polyline;
                polyline = nullptr;
            }
        }
        else {
            // building, park, etc.
            cPolygonFigure *polygon = new cPolygonFigure();
            points.pop_back();
            polygon->setPoints(points);
 
            polygon->setName(std::to_string(way->getId()).c_str());
            const char *name = way->getTag("name");
            if (name != nullptr)
                polygon->setTooltip(name);
 
            polygon->setFilled(true);
            polygon->setFillOpacity(0.1);
            polygon->setLineOpacity(0.5);
            polygon->setLineColor(cFigure::GREY);
            if (!opp_isempty(way->getTag("building")))
                polygon->setFillColor(cFigure::RED);
            else
                polygon->setFillColor(cFigure::GREEN);
            buildings->addFigure(polygon);
        }
    }
    return mapFigure;
}

initialize()

void inet::visualizer::OpenStreetMapSceneCanvasVisualizer::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::visualizer::SceneVisualizerBase.

{
    SceneVisualizerBase::initialize(stage);
    if (!hasGUI()) return;
    if (stage == INITSTAGE_PHYSICAL_ENVIRONMENT) {
        auto canvas = visualizationTargetModule->getCanvas();
        coordinateSystem.reference(this, "coordinateSystemModule", true);
        canvasProjection = CanvasProjection::getCanvasProjection(canvas);
 
        cXMLElement *mapXml = par("mapFile").xmlValue();
        OpenStreetMap map = OpenStreetMap::from(mapXml);
        EV << "Loaded " << map.getNodes().size() << " nodes, " << map.getWays().size() << " ways\n";
        auto mapGroupFigure = createMapFigure(map);
        mapGroupFigure->setZIndex(par("zIndex"));
        visualizationTargetModule->getCanvas()->addFigure(mapGroupFigure);
 
        cDisplayString& displayString = visualizationTargetModule->getDisplayString();
        if (par("adjustBackgroundBox").boolValue()) {
            const osm::Bounds& bounds = map.getBounds();
            cFigure::Point bottomRight = toCanvas(map, bounds.minlat, bounds.maxlon);
            displayString.setTagArg("bgb", 0, bottomRight.x);
            displayString.setTagArg("bgb", 1, bottomRight.y);
        }
    }
}

toCanvas()

cFigure::Point inet::visualizer::OpenStreetMapSceneCanvasVisualizer::toCanvas ( const osm::OpenStreetMap &  map, double  lat, double  lon  )

protected

{
    Coord coord = coordinateSystem->computeSceneCoordinate(GeoCoord(deg(lat), deg(lon), m(0)));
    return canvasProjection->computeCanvasPoint(coord);
}

Member Data Documentation

canvasProjection

CanvasProjection* inet::visualizer::OpenStreetMapSceneCanvasVisualizer::canvasProjection = nullptr

protected

coordinateSystem

ModuleRefByPar<IGeographicCoordinateSystem> inet::visualizer::OpenStreetMapSceneCanvasVisualizer::coordinateSystem

protected

---

The documentation for this class was generated from the following files:

• OpenStreetMapSceneCanvasVisualizer.h
• OpenStreetMapSceneCanvasVisualizer.cc