You can use graphics
Graphics and graphics overlays allow you to do things like:
- Show updated locations for objects in the map view, such as moving vehicles.
- Display results from an analysis
Analysis is a systematic examination of a problem that provides new information. , geocodingGeocoding is the process of converting text for an address or place to a complete address with a location. , or routingA route is a polyline that defines the best path between two or more points in a street network. operation. - Allow the user to draw temporary sketches on top of the map.
- Store user input, such as a set of route stops
A stop is a single point along a route: it can be the origin, an intermediate stop, or destination. to visit. - Show ad hoc text labels to describe things on the map.
How graphics work
A map view has a graphics overlay collection that may contain zero or more graphics overlays
Graphics in map views and scene views
The pattern for working with graphics is the same whether in a map view
For more information about working with graphics in 3D, see Add graphics to a scene view.
Graphics overlays
A GraphicsOverlay is a container for temporary graphics
The following code shows how to create a new graphics overlay and add it to your map view.
// Create a new graphics overlay.
GraphicsOverlay* graphicsOverlay = new GraphicsOverlay(this);
// Add the overlay to the geoview.
m_geoView->graphicsOverlays()->append(graphicsOverlay);
Unlike a feature layer
For more information and a description of when to use each, see the Features and graphics topic.
Graphics
Graphics are created at run time and only persist for as long as the app is running. You can create them to show geocode
A Graphic uses the following to represent an object on the map view:
- Geometry: a point, line, or polygon that represents the object's location and shape.
- Attributes: a collection of one or more pairs of fields and values that describe the object.
- Symbol: an object that controls the visual representation of the graphic's geometry on the display.
Draw order (z-index)
A graphic's z-index defines the draw order of that graphic within its graphics overlay. It is primarily intended for use when working with graphics in a 2D map view.
If the z-index is not set, the graphics will render in the order in which they were added to the graphics overlay
Work with graphics
Because they are both geoelements
Add a graphics overlay and a graphic
The following example shows how to create a graphics overlay
-
Create a new
GraphicsOverlay. -
Create a
Geometryto define the graphic's shape and geographic location. -
Create a symbol
A symbol defines the properties used to display a geometry or text. to display the graphic.- You can also do this by defining a
Rendererfor the graphics overlayA graphics overlay is a client-side, temporary container of graphics to display on a map view or scene view. . See Styles and data visualization for more information about symbolizing geoelementsA geoelement refers to any geographic element in a map or map view that can be identified by its location to return attribute information. .
- You can also do this by defining a
-
Create a new
Graphicusing the geometry and symbol.- Optionally, you can define a set of attributes
Attributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service. for the graphicA graphic is a visual element composed of a geometry, symbol, and attributes that is displayed on a map or scene. .
- Optionally, you can define a set of attributes
-
Add the graphic to the graphics overlay.
-
Add the graphics overlay to the map view.
// Create a new graphics overlay.
GraphicsOverlay* graphicsOverlay = new GraphicsOverlay(this);
// Create a point for the location.
const Point pierLocation(-118.4978, 34.0086, SpatialReference::wgs84());
// Create the graphic symbol.
SimpleMarkerSymbol* pierSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbolStyle::Circle,
QColor(Qt::red), 10);
// Create the graphic with the point and symbol and add it to the overlay.
graphicsOverlay->graphics()->append(new Graphic(pierLocation, pierSymbol, this));
// Add the overlay to the mapview.
m_mapView->graphicsOverlays()->append(graphicsOverlay);
Symbolize
A comprehensive API for creating and modifying symbols
There are two ways to symbolize a graphic
- Apply a symbol directly to the graphic. Graphics expose a symbol property that you can use to define the symbol.
- Apply a renderer to the graphics overlay. A renderer
A renderer is a collection of rules and symbols used to display the data in a layer. is a collection of one or more symbols that are applied to all graphics in the graphics overlay. A renderer allows you to do things like control symbology based on attributeAttributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service. values.
If you define a renderer for a graphics overlay, you do not need to assign symbols to the individual graphics it contains. Assigning a symbol directly to a graphic overrides the symbology defined by the renderer of the graphics overlay.
Display text
To display text on the map view as a graphic, create a graphic with a point, line, or polygon to define the location for your text. You can then provide a TextSymbol that defines the font, color, size, and text to display.
// Define a point that represent the location of a pier.
Point pierLocation(-118.4978, 34.0086, 500.0, SpatialReference::wgs84());
// Create a new text symbol for the pier.
TextSymbol* pierTextSymbol = new TextSymbol(
"Santa Monica Pier", QColor(0xFF, 0, 0, 0xE6), 10,
HorizontalAlignment::Left, VerticalAlignment::Bottom, this);
// Add the graphic (based on the point location and text symbol) to the graphics overlay.
graphicsOverlay->graphics()->append(new Graphic(pierLocation, pierTextSymbol, this));
Identify
A graphic can contain descriptive information in the form of attributes
The following example shows how you can identify a graphics overlay in response to a tap on the map view.
// Connect to the mouse clicked signal on the MapQuickView.
connect(m_mapView, &MapQuickView::mouseClicked, this, [this, m_graphicsOverlay](QMouseEvent& mouseEvent)
{
// Define the parameters for the idenitify operation.
constexpr double tolerance = 5.0;
constexpr bool returnPopupsOnly = false;
constexpr int maximumResults = 1;
// Asynchronously call the identify grapgucs overlay async method on the mapview using the parametery defined.
m_mapView->identifyGraphicsOverlayAsync(m_graphicsOverlay, mouseEvent.position(), tolerance, returnPopupsOnly,
maximumResults).then(this, [](IdentifyGraphicsOverlayResult* rawIdentifyResult)
{
// Delete rawIdentifyResult on leaving scope.
auto identifyResult = std::unique_ptr<IdentifyGraphicsOverlayResult>(rawIdentifyResult);
// Proceed if we have an identify with results.
if (identifyResult)
{
// Get the count of graphics fomud from the identify.
long identifiedGraphicsCount = identifyResult->graphics().size();
// Display the count to the app.
qDebug() << "Graphics count: " << identifiedGraphicsCount;
}
});
});
Select
Select graphics to highlight them on the display. You can select zero, one, or several graphics in a graphics overlay. Each graphic's selection state is represented with an is property that is either true or false.
The following example finds all graphics in the points of interest graphics overlay that have a "type" attribute of "pier" and selects them on the display.
// Get the graphics list model from the graphics overlay.
GraphicListModel* m_graphicsListModel = graphicsOverlay->graphics();
// Find all graphics in the points of interest graphics overlay that have a "type" attribute of "pier".
auto graphicsIt = std::find_if(m_graphicsListModel->constBegin(), m_graphicsListModel->constEnd(),
[](Graphic* graphic)
{
return graphic->attributes()->attributeValue("type") == "pier";
});
if (graphicsIt == m_graphicsListModel->constEnd())
{
qDebug() << "Did not find graphic";
return;
}
// Select the graphics found on the display.
(*graphicsIt)->setSelected(true);
Move graphics
To move a graphic, you only need to update its geometry. This is much more efficient than creating a new graphic and replacing the existing one. Updating a graphic's geometry will cause it to immediately display at the new location. Use this technique to animate the display of moving geoelements
// Create a point using the geometry from a point graphic create previosuly.
const Point pointGraphicCurrentPosition = geometry_cast<Point>(pointGraphic->geometry());
// Define some x and y offset values.
constexpr double deltaX = .05;
constexpr double deltaY = .02;
// Create some new x and y values that are offset from point.
double newX = pointGraphicCurrentPosition.x() - deltaX;
double newY = pointGraphicCurrentPosition.y() - deltaY;
// Create a new point using the new offset x and y location and a spatial reference.
const Point newPosition(newX, newY, SpatialReference::wgs84());
// Set the geometry of the point graphic to the new offset values.
pointGraphic->setGeometry(newPosition);