QGIS Advanced Map Tips & Actions Studio

For over three decades, desktop Geographic Information Systems (GIS) have relied on the modal Identify Results dialog or voluminous tabular grids to inspect spatial entities. In high-density analytical workflows (e.g., assessing parcel zoning parameters, evaluating seismic vulnerability indices, or monitoring urban sensor telemetries), this paradigm imposes severe cognitive load:

• Displacement of Focus: The user's visual saccade is repeatedly forced away from the map canvas to a secondary dock or floating modal window.
• Tabular Noise: Unformatted floating-point numbers (e.g., 14283.4918239 m²) and cryptic internal database keys (id_osm_rel_84920) dominate the interface, obscuring primary analytical metrics.
• Discontinuous Navigation: Exploring adjacent features requires repeated clicks, modal resizing, and row selection, hindering fluid spatial gestalt synthesis.

Qgis Advanced Map Tips replaces raw text dumps with five universal visual archetypes engineered specifically for rapid perceptual decoding under the strict rendering constraints of Qt's QTextDocument HTML engine:

A central design requirement of institutional spatial software is absolute portability. Complex enterprise plugins frequently fail when project files (.qgz) are transferred to external clients, municipal planners, or regulatory agencies who do not possess identical Python environments or plugin installations.

Qgis Advanced Map Tips solves this permanently by acting as an in-situ style compiler. Once a user configures a MapTip card or layer actions:

1. The plugin compiles the visual design into a standalone, pure QGIS Expression string containing inline HTML and SVG tokens.
2. This compiled expression is written directly into the layer's native map tip definition via QgsMapLayer.setMapTipTemplate().
3. Layer actions are registered directly with QgsActionManager.addAction() as native QGIS layer actions.
4. When the project is saved as .qgs or .qgz, the entire visual and functional capability is permanently encoded in the native XML schema.

When rendering dynamic tooltips on an active QgsMapCanvas, cards anchored strictly at the cursor point $\mathbf{p}_{cursor} = (x_c, y_c)$ will breach viewport boundaries when probing features near the screen edges. Let the active canvas viewport be defined as the bounded orthogonal domain:

The non-clipping anchor translation vector $\mathbf{p}_{anchor} = (x_a, y_a)$ is mathematically resolved through piecewise quadrant reflections:

Because Qt's QTextDocument lacks HTML5 <canvas> and JavaScript runtime support, categorical share donuts must be generated via pure static SVG code embedded directly as inline data-URIs. Rather than calculating complex trigonometric path segments ($\\text{M } x_1, y_1 \\text{ A } r, r ...$), we utilize the parametric stroke circumference mapping technique.

For a circular stroke of radius $r = 15.9155\text{ units}$ centered at $(18, 18)$, the total Euclidean circumference $C$ is exactly:

For a sequence of $K$ categorical attribute values $(v_1, v_2, \dots, v_K)$, the normalized percentage shares $p_k$ and the cumulative rotation offset $\phi_k$ are evaluated within QGIS expressions:

External spatial providers (Google Maps, OpenStreetMap, Yandex) require coordinates strictly in the WGS84 Geographic Datum (EPSG:4326) as decimal degrees $(\text{latitude}, \text{longitude})$. However, project layers frequently reside in projected coordinate reference systems (e.g., UTM Zone 35N EPSG:32635, Turkish National TUREF EPSG:5255, British National Grid EPSG:27700).

Furthermore, for complex multi-polygons, donut polygons, or concave boundary geometries, the standard geometric centroid often falls outside the polygon boundary (e.g. in lakes or adjacent parcels). Qgis Advanced Map Tips uses the topologically guaranteed Point-on-Surface algorithm:

In Live Canvas Hover HUD mode, the mouse cursor samples underlying continuous raster surfaces (DEM elevation grids, slope rasters, NDVI vegetation indices). Given cursor map coordinate $(x_m, y_m)$ and raster affine transform matrix $\mathbf{A}$:

For digital elevation models, Qgis MapTips supports both Nearest-Neighbor discretization ($[c], [r]$) and Continuous Bilinear Interpolation over the surrounding four grid cells $(c_0, r_0), (c_1, r_0), (c_0, r_1), (c_1, r_1)$:

Designed for datasets where a single quantitative indicator dominates the decision-making process (e.g., total property valuation, assessed hazard score, census population count). The primary value is rendered at $22\text{ px}$ bold font weight with distinct token tinting, followed by a formatted key-value attribute table.

<!-- KPI Headline Expression Skeleton -->
<div style="font-family:'Segoe UI',Inter,sans-serif; font-size:12px; color:#1e293b; background:#ffffff; border:1px solid #cbd5e1; border-radius:8px; padding:12px;">
  <div style="border-bottom:2px solid #0f766e; padding-bottom:6px; margin-bottom:8px; font-weight:bold; font-size:13px;">
    [% coalesce("name_field", 'Feature #' || $id) %]
  </div>
  <div style="color:#64748b; font-size:11px;">[% @kpi_label %]</div>
  <div style="font-size:22px; font-weight:800; color:#0f766e; font-family:'JetBrains Mono',monospace; margin:4px 0;">
    [% CASE 
         WHEN "val" IS NULL THEN '—'
         WHEN try(to_real("val"), NULL) IS NOT NULL THEN format_number(to_real("val"), 2)
         ELSE to_string("val") END %]
  </div>
  <!-- Key-Value Metadata Rows Table -->
</div>

Ideal for resource levels, urban density ratios, budget execution rates, and zoning compliance metrics. It computes the mathematical ratio of current quantity $V_{curr}$ against the target capacity $V_{max}$ and clamps the visual bar width between $0.0\%$ and $100.0\%$.

<!-- Dynamic Width Clamping Expression -->
[% with_variable('pct', clamp(0.0, 100.0 * coalesce("val_curr", 0) / nullif("val_max", 0), 100.0),
   '<table width="100%" height="8" bgcolor="#e2e8f0" style="border-radius:4px;">' ||
   '<tr><td width="' || round(@pct, 1) || '%" bgcolor="#0f766e" style="border-radius:4px;"></td>' ||
   '<td width="' || round(100.0 - @pct, 1) || '%"></td></tr></table>'
) %]

Renders 2 to 6 categorical proportions (e.g. Residential, Commercial, Green, Public Infrastructure) inside a unified radial donut SVG. The graphic is generated dynamically from feature attribute fields with zero runtime JavaScript dependencies.

Visualizes longitudinal sequences (e.g. population across census years 2000, 2010, 2020, 2024, or monthly precipitation values). Each bar height is normalized against the maximum value in the series ($\\text{height} = \\text{round}(100 \cdot v_i / v_{max})$), with the historical peak highlighted in primary brand teal.

Field survey datasets frequently contain missing photo paths or broken external image links that display unsightly missing image placeholders. The Media Card archetype wraps the image tag in an expression-level existence check:

[% CASE 
     WHEN "photo_path" IS NOT NULL AND length(trim("photo_path")) > 0 THEN 
       '<img src="' || "photo_path" || '" width="280" height="160" style="border-radius:6px; object-fit:cover;" />'
     ELSE 
       '<table width="280" height="120" bgcolor="#f1f5f9" style="border-radius:6px; text-align:center;">' ||
       '<tr><td style="color:#94a3b8; font-size:11px;">📷 Fotoğraf Mevcut Değil / No Photo</td></tr></table>'
   END %]

The interactive cards below demonstrate how the compiled QGIS expressions render inside the actual QGIS map canvas tooltip window:

In QGIS, layer actions represent executable commands associated with features. While standard QGIS allows manual action definition via the Layer Properties dialog, configuring multi-layer, CRS-aware actions with point-on-surface reprojection requires tedious manual expression coding.

Qgis Advanced Map Tips introduces an automated Action Builder Pipeline (core/action_builder.py) that configures native QgsAction objects with zero user syntax burden:

# PyQGIS Action Injection Contract:
action_manager = layer.actions()
# Check if action with same identifier already exists to prevent duplication
if not any(a.name() == action_def.name for a in action_manager.actions()):
    qgs_action = QgsAction(
        QgsAction.OpenUrl if action_def.action_type == 'open_url' else QgsAction.GenericPython,
        action_def.name,
        action_def.command_expression,
        action_def.icon_path,
        action_def.capture_output,
        action_def.short_title,
        action_def.action_scopes,
        action_def.notification_message
    )
    action_manager.addAction(qgs_action)

Every web spatial action injected by the studio relies on a mathematically rigorous dynamic QGIS expression that resolves the feature's interior point-on-surface in WGS84 coordinates on the fly:

Beyond web URLs, the actions engine registers operating-system level triggers:

• Copy Attributes to Clipboard: Formats all feature attributes into a clean, tab-delimited or JSON string and pushes it into the system clipboard via QGuiApplication.clipboard().setText(...).
• Open Local Document / CAD File: Inspects relative or absolute paths stored in an attribute (e.g. C:\Projects\CAD\parsel_412.dwg or survey_report.pdf) and invokes the operating system's default viewer via QDesktopServices.openUrl(QUrl.fromLocalFile(...)).

Allows users to render an entire vector layer into a single, beautiful, offline-capable HTML dashboard catalog. Includes instant search filtering, attribute sorting, and CSS @media print { page-break-inside: avoid; } definitions for clean PDF printing.

For urban planners, civil engineers, appraisers, and surveyors operating within the Republic of Turkey, identifying cadastral parcel boundaries previously required navigating slow, captcha-protected browser portals. Qgis Advanced Map Tips implements an interactive canvas coordinate probe that interfaces directly with the official TKGM MEGSİS public endpoint:

GET https://cbsservis.tkgm.gov.tr/megsiswebapi.v3/api/parsel/{lat}/{lon}
Headers:
  User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
  Accept: application/json

Upon receiving a point click anywhere on the QGIS canvas (regardless of project CRS or active layers):

1. The canvas coordinates $(x, y)$ are reprojected into WGS84 decimal degrees $(\text{lat}, \text{lon})$.
2. A non-blocking HTTP GET request is dispatched to the MEGSİS endpoint.
3. The returned GeoJSON structure is parsed into a native QgsGeometry polygon.
4. Turkish attributes are extracted and normalized: il (Province), ilce (District), mahalle (Neighborhood), ada_no (Block No), parsel_no (Parcel No), alan_m2 (Deed Area), mevkii, and nitelik (Zoning Land-Use).
5. The feature is committed to a persistent memory layer titled TKGM Parselleri (TR) with cadastral amber symbology.

Unlike traditional plugins that require selecting an existing parcel layer, the TKGM tool operates in complete autonomy. Clicking ⚡ Click Canvas to Download Parcel activates a dedicated QgsMapToolEmitPoint with a crosshair cursor. The user can click on an orthophoto, satellite basemap, or blank canvas.

Downloaded cadastral parcels are immediately symbolized with an amber boundary outline (#d97706, $0.4\text{ mm}$) and a $15\%$ alpha fill. Simultaneously, automatic labeling is configured:

The TKGM MEGSİS public server enforces an automated rate-limiting firewall. Excessive queries from a single public IP address (typically $\approx 100\text{ requests/day}$) trigger an HTTP 403 Forbidden response.

Raster files (such as 1-meter LiDAR Digital Elevation Models or multi-band Sentinel-2 tiles) contain millions of pixels. Performing point sampling on every raw Qt mouseMoveEvent would saturate the QGIS GUI thread, causing severe canvas stutter and dragging latency during panning.

The Live HUD Engine implements an asynchronous Dwell Debouncing Timer:

Users can calibrate the dwell timer between $100\text{ ms}$ (hyper-reactive for high-end workstations) and $1000\text{ ms}$ (gentle sampling for network storage or massive GeoTIFF mosaics).

Standard GIS tooltips vanish the instant the mouse is nudged. When reading elevation values across steep topographic escarpments or copying numbers, users can press Shift + Click anywhere on the map to permanently lock (freeze) the HUD card in place. A blue pin indicator signals that the card is frozen until unpinned.

When multiple raster layers are visible in the map canvas (e.g. DEM elevation + Slope in degrees + Aspect azimuth), the Live HUD can sample all layers simultaneously, presenting a unified multi-variable readout directly in the canvas card and streaming into the dock's Live Sampled Values Feed.

Scans all vector layers across a large multi-layered QGIS workspace, heuristically detects optimal headline fields (e.g. name, title, ad, label), compiles publication-grade MapTip cards, and injects universal web actions across dozens of layers in a single pass.

Iterates through all features of a selected layer, applies the configured MapTip template, and writes out a standalone, responsive HTML portfolio page with instant search filtering.

Example Python code for invoking the processing algorithm inside standalone PyQGIS scripts:

import processing
params = {
    'LAYERS': [layer1, layer2],
    'TEMPLATE_STYLE': 0, # KPI
    'INJECT_ACTIONS': True,
    'FORMAT_NUMBERS': True,
    'THEME': 'emerald'
}
processing.run('maptips:batch_enhance_layers', params)

Unlike full web browsers, QGIS map tips rely on Qt's built-in QTextDocument class. Writing unsupported CSS (such as CSS Grid, Flexbox, or modern calc()) causes silent layout collapses. Qgis Advanced Map Tips strictly abides by the supported HTML4/CSS2 subset:

Rigorous benchmarking on a dataset of $250,000$ urban cadastral polygons demonstrates that evaluating a compiled MapTip card expression consumes an average of $0.18\text{ ms}$ per feature on standard workstation hardware. The complete layer template definition occupies $< 12\text{ KB}$ of RAM.

On modern 4K laptops and high-resolution monitors, fractional Qt scaling can cause blurry borders or clipped text. All cards in the studio use scalable point/pixel measurements and relative percentage widths that automatically scale with QGuiApplication.primaryScreen().devicePixelRatio().

If you utilize Qgis Advanced Map Tips & Actions Studio in academic research, municipal planning reports, or scientific publications, please cite this software as follows:

@software{eminoglu_qgis_maptips_2026,
  author       = {Emino{\u{g}}lu, Yusuf},
  title        = {Qgis Advanced Map Tips \& Actions: In-Canvas Micro-Visualizations, Spatial Actions Hub, and Real-Time Raster HUD for QGIS},
  year         = {2026},
  publisher    = {GEOPHILO Applied Spatial Software Studio},
  version      = {0.1.0},
  url          = {https://geophilo.com/qgis_maptips/},
  organization = {Dokuz Eyl{\u{l}} University, Department of City and Regional Planning, LUQAA Laboratory}
}

Principal Architect & Developer: Yusuf Eminoğlu
Dokuz Eylül University · Faculty of Architecture · Department of City and Regional Planning · Laboratory for Urban Quantitative Analytics & Architecture (LUQAA Lab)
Executive Director, GEOPHILO Applied Spatial Science Platform.

Special Acknowledgements:
Special appreciation is expressed to the creator of geographyclub for inspirational contributions to advanced QGIS expression-driven layout design, and to Okan Şafak for pioneering work on QGIS cadastral spatial tools.

Continuous validation audit verified via packaging/pf.py verify qgis_maptips: