QGIS Temporal Controller – Get Current Animation Time with Expressions/Variables

animationexpressionqgisqgis-3temporal-controller

The question

How can I get the current animation time of a Temporal Controller animation using expressions with QGIS 3.24? I guess I'm almost there (see below), but have trouble dividing a time formatted as interval by a number.

The background (what I need it for)

I finally want to get a value that shows what percentage of the whole animation has elapsed at a certain frame. I want to use this value to style a line layer with geometry generator, using line_substring() function to draw the same percentage of the line's total length as the percentage of time elapsed: so at the beginning, 0% of the line, after 30% of the whole animation the first 30% of the line's lenght etc. Like this, I could animate the line without creating interpolated points with timestamps (what would be a workaround) by activating Dynamic Temporal Contral in the layer properties with Configuration Redraw Layer Only.

The expression to create this would look like: line_substring( $geometry, 0, $length * [percentage] ) – where [percentage] is the value I'm trying to create.

What I tried

My idea was to the get the total length of the whole anmimation with @animation_end_time - @animation_start_time. This return a time interval (like <interval: 10.375 minutes>). Unfortunately, there is no variable like @animation_current_time that returns the time of the current frame.

There is, however, the variable @frame_number that returns the current frame number during animation playback. The variables @frame_timestep and @frame_duration return the temporal duration of each animation frame.

Example

Let's say I have the following values. A total time of 24 frames * 8 seconds = 192 seconds have elapsed, that is 30.8% of the total animation time of 10.375 minutes:

Total length of animation: <interval: 10.375 minutes> ( = @animation_end_time - @animation_start_time)
Current frame number: 24 ( = @frame_number)
Temporal duration of each animation frame: 8 (using @frame_timestep) or <interval: 8 seconds> (with @frame_duration)
What I want to get (pseudocode): <current-time> / <total-duration> -> 0.308 (30.8%)

So how to divide <interval: 10.375 minutes> by the time elapsed : 192 (@frame_number * @frame_timestep)?

Best Answer

You can get the percentage by using an expression such as:

second(datetime_from_epoch(epoch(to_datetime(to_string("mytime")+'Z')) - epoch(@animation_start_time)) - make_datetime(1970,1,1,0,0,0)) / second(@animation_interval)

Be aware of the timezones! Seems like QGIS temporal-controller-variables always work with UTC, while your datetime may be in another timezone. You can correct this by adding or subtracting the hour difference in seconds. Or a little more elegant change the 0-time of make_datetime(1970,1,1,0,0,0) to e.g. make_datetime(1970,1,1,1,0,0) In my example above I had to manually set UTC as timezone, thats why I use to_string("mytime")+'Z'. Remove that part if you dont need it!

Example result:

Related Solutions

[GIS] QGIS Temporal Controller with raster data

I wrote a PyQGIS script to handle the workaround for NetCDF files which uses temporal controller's updateTemporalRange signal. Just copy the following script to QGIS Python editor window, edit your dates, run the script and use Temporal Controller as usual.

import datetime

# These functions are part of https://github.com/GispoCoding/qgis_plugin_tools/blob/master/tools/raster_layers.py

def set_raster_renderer_to_singleband(layer: QgsRasterLayer, band: int = 1) -> None:
    """
    Set raster renderer to singleband
    :param layer: raster layer
    """
    # https://gis.stackexchange.com/a/377631/123927 and https://gis.stackexchange.com/a/157573/123927
    provider: QgsRasterDataProvider = layer.dataProvider()
    renderer: QgsSingleBandGrayRenderer = QgsSingleBandGrayRenderer(layer.dataProvider(), band)

    stats: QgsRasterBandStats = provider.bandStatistics(band, QgsRasterBandStats.All, layer.extent(), 0)
    min_val = max(stats.minimumValue, 0)
    max_val = max(stats.maximumValue, 0)

    enhancement = QgsContrastEnhancement(renderer.dataType(band))
    contrast_enhancement = QgsContrastEnhancement.StretchToMinimumMaximum
    enhancement.setContrastEnhancementAlgorithm(contrast_enhancement, True)
    enhancement.setMinimumValue(min_val)
    enhancement.setMaximumValue(max_val)
    layer.setRenderer(renderer)
    layer.renderer().setContrastEnhancement(enhancement)
    layer.triggerRepaint()
    
def set_band_based_on_range(layer: QgsRasterLayer, t_range: QgsDateTimeRange) -> int:
    """

    :param layer: raster layer
    :param t_range: temporal range
    :return: band number
    """
    band_num = 1
    tprops: QgsRasterLayerTemporalProperties = layer.temporalProperties()
    if tprops.isVisibleInTemporalRange(t_range) and t_range.begin().isValid() and t_range.end().isValid():
        if tprops.mode() == QgsRasterLayerTemporalProperties.ModeFixedTemporalRange:
            layer_t_range: QgsDateTimeRange = tprops.fixedTemporalRange()
            start: datetime.datetime = layer_t_range.begin().toPyDateTime()
            end: datetime.datetime = layer_t_range.end().toPyDateTime()
            delta = (end - start) / layer.bandCount()
            band_num = int((t_range.begin().toPyDateTime() - start) / delta) + 1
            set_raster_renderer_to_singleband(layer, band_num)
    return band_num
    
def set_fixed_temporal_range(layer: QgsRasterLayer, t_range: QgsDateTimeRange) -> None:
    """
    Set fixed temporal range for raster layer
    :param layer: raster layer
    :param t_range: fixed temporal range
    """
    mode = QgsRasterLayerTemporalProperties.ModeFixedTemporalRange
    tprops: QgsRasterLayerTemporalProperties = layer.temporalProperties()
    tprops.setMode(mode)
    if t_range.begin().timeSpec() == 0 or t_range.end().timeSpec() == 0:
        begin = t_range.begin()
        end = t_range.end()
        begin.setTimeSpec(Qt.TimeSpec(1))
        end.setTimeSpec(Qt.TimeSpec(1))
        t_range = QgsDateTimeRange(begin, end)
    tprops.setFixedTemporalRange(t_range)
    tprops.setIsActive(True)
    
def temporal_range_changed(t_range: QgsDateTimeRange):
    layer = iface.activeLayer()
    if isinstance(layer, QgsRasterLayer):
        set_band_based_on_range(layer, t_range)
    
def set_range():
    mode = QgsRasterLayerTemporalProperties.ModeFixedTemporalRange
    
temporal_controller: QgsTemporalController = iface.mapCanvas().temporalController()
temporal_controller.updateTemporalRange.connect(temporal_range_changed)
# Add one second to make the last frame visible
set_fixed_temporal_range(iface.activeLayer(), QgsDateTimeRange(datetime.datetime(2020, 11, 2, 15, 0), datetime.datetime(2020, 11, 3, 11, 0, 1)))

Here is a simple gif animation showing the usage:

QGIS – Interpolating Points with QGIS Native Temporal Controller

The basic ideas

Interpolating points based on location and time is possible using Geometry generator. The basic idea to interpolate between point N and point N+1 (both with differend values for the datetime attribute arrival_time) is to create a line between both points, render just a substring of it, representing the percentage of the time elapsed at the current frame, and get the end-point of this substring.

Red point, interpolated between the blue points that correspond to the features of the layer:

Details of the idea

Create a line connecting each point with the following point, using make_line() from point N to point N+1
Create a substring of this line using line_substring(): the starts at 0 (the start point of the line) and goes up to a certain length. This length corresponds to the percentage of the total time elapsed between the time defined for point N and point N+1.

Example: if point N appears at 05:07 and N+1 at 07:37, total time between both points is 2:30 (=150 seconds). At 05:57 (= 50 seconds after point N), a third of the total time has elapsed - so the substring should cover the first thrid of the line

To do so, get the middle of the current frame (mean of @map_start_time and @map_end_time) and culculate how many time has elapsed since the time the current feature appeared (here the attribute arrival_time): subtract arrival_time from the mean. Divide this value by the total length (time) between the arrival_time of the current and the next feature (N and N+1). This is the percentage of the total time between the two feature's appearing on the map that has elapsed during the current frame. So mulitply this percentage with the total length of the line to get the length of the substring that should be rendered.
Create the end-point of the line with end_point()
Set a condition that the line / end point appears only for time values covered by the current frame: in between N and N+1 (and not at every feature).

Use a case condition with the variables @map_start_time and @map_end_time (defines the start- and end-time of the current animation frame) and the time/datetime attribute from the layer, here arrival_time. If the mean of the current frame (=the middle between @map_start_time and @map_end_time) is smaller then arrival_time of the next feature (N+1), but larger then arrival_time of the current feature, then the current frame shows a point between N and N+1. Only in this case, the line substring's end point should be shown.

What to be aware of: different time zones (attributes vs. variables)

This solution is based on the sample data provided here from the question Animating data with Temporal Controller - When loading the data (csv) to QGIS, each feature comes with an attribute arrival_time, interpreted as Central European Time (CET) on my system. As the variables for the animation like @animation_start_time are in UTC, I had to convert arrival_time to UTC, adding 2 hours: arrival_time + to_interval ('2 hours'). Adapt this value in the expression below.

Time Controller settings

Make time controller settings in layer properties > Temporal tab: check the box Dynamic temporal control and for Configuration, use Redraw Layer Only.
Open Temporal controller panel (no 1 in screenshot below), select the button in the middle Animated temporal navigation and click the icon with two arrows Set to full range to load min/max values for the anmination (no. two in screenshot.
Set the step between each frame, here e.g. 1 second (no. 3). The higher the value, the faster the point moves.
Click the yellow gear icon (no. 4) to change frame rate (frames per second). The higher the value, the faster the point moves.

The expression

Based on a point layer with a datatime attribute called arrival_time, the following expression creates an animated point that "moves", based on interpolated points as described above. Use it in Geometry Generator, make the relevant settings in Temporal controller panel as described above and start the animation by clicking the play button.

The expression to use in geometry generator looks like this. The expression uses the following custom variables:

@zone: number of hours to add to change from UTC to local time zone (change this value on line 3 for other time zones)
@arrival: changes the attribute value from the field arrival_time to UTC, based on the value defined in variable @zone
@next: gets the value for arrival_time attribute of the next feature
@mapstart: datetime timecode of the mean of the current animation frame (where in the timeline the animation currently is)
@line: creates a line from the current to the next feature (N to N+1)

with_variable (
    'zone',
    2,  -- change this value to add/subtract hours to/from attribute named arrival_time to transform local time zone to UTC
    with_variable(
        'arrival',
        arrival_time + to_interval (@zone  || ' hours'),
        with_variable(
            'next',
            attribute (get_feature_by_id (@layer, $id+1), 'arrival_time'),
            with_variable (
                'mapstart',
                @map_start_time + to_interval ((second (@map_end_time - @map_start_time)/2 ) || ' seconds'),
                with_variable (
                    'line',
                    make_line (
                        $geometry,
                        geometry( get_feature_by_id (@layer, $id+1))
                    ),
                    case 
                    when 
                        @mapstart < @next and @mapstart > arrival_time +  @frame_duration 
                    then 
                        end_point (
                            line_substring (
                                @line,
                                0,
                                length (@line) * 
                                minute ( @map_start_time + (second (@frame_duration )/2)  || ' seconds' - @arrival ) /
                                minute (  @next + to_interval (@zone  || ' hours') - @arrival)
                            )
                        )
                    
                end
                )
            )
        )
    )
)