LuciadRIA Release notes

You can now visualize panoramas in LuciadRIA. To do this, you call GeoCanvas.drawPanorama in FeaturePainter.paintBody after assigning a PanoramaModel to FeatureLayer.panoramaModel. If you want to visualize panorama data processed by LuciadFusion, you should use FusionPanoramaModel. LuciadRIA can visualize panoramas in a cubemap image format, or in equirectangular format. The panoramic imagery can be multileveled as well (in both formats). Please refer to the API documentation for details. The "Panorama" sample also demonstrates how you can use the RIA panorama API. Note that you'll need a license for the LuciadRIA "Panoramics" optional module for this API to work.

The default styling of editing handles was changed to a non-draped circle icon. If you prefer the old EditController handle icons, you can still set that style using:

      const editController = new EditController(layer, feature, {
        handleIconStyle: {
          image: IconFactory.rectangle({ // from samples/common (@luciad/ria-sample-common/IconFactory)
            stroke: "rgb(0,0,0)",
            strokeWidth: 1,
            fill: "rgb(255,255,255)",
            width: 10,
            height: 10
          }),
          width: "10px",
          height: "10px",
          zOrder: 10
        }
      });
    

You can now schedule the automatic data reloads in a FeatureLayer using LoadingStrategy API. The new LoadingStrategy.refresh property accepts the following values:

• number - the loading strategy refreshes every n milliseconds.
• Date object - the loading strategy will refresh at that time.
• null - the loading strategy never refreshes.

This API can be used to implement a KML layer, created based on KMLNetworkLinkFeature, that reloads data according to KMLLink object.

HSPCTilesModelDescriptor now exposes more information about its metadata properties. Properties now have a role that describes their type. It is now possible to detect if a model exposes colors or intensity for instance. This can be useful for styling and filtering.

It is now possible to decode KMZ files with LuciadRIA. Both KMLModel and KMLCodec accept KMZ files.

KMLCodec is introduced which can be used with existing Store implementations. For example, you can now connect to a WFS service that returns KML using the KMLCodec in combination with the WFSFeatureStore.

LuciadRIA can now parse version 2.3 KML files with the following:

• Placemark items
• Network links
• Container elements
• Ground overlays
• KMZ data can now be parsed.

For more information on these new features have a look at the documentation on KMLCodec and KMLModel. A KML sample was also added to demonstrate how the new API can be used to create a tree view UI component.
See also the how-to article on visualization of KML data.

Draco compressed pnts datasets are now detected, with a proper warning logged to notify they are not supported yet.

It is now possible to obtain the bounds of a tile in a RasterTileSetModel. This may come in handy if you have to pass the tile bounds in tile requests.

FeaturePainter implements the Evented interface and exposes the "Invalidate", "InvalidateById" and "InvalidateAll" events that are emitted when corresponding invalidation methods are called.

You can now have transparent objects in a TileSet3DLayer, for example based on an OGC 3D Tiles mesh dataset. The transparency can originate from transparent pixels in an rgba texture, transparent colors in a vertex attribute, or transparent colors from a color expression.

Since painting with transparency can have a performance impact, it is disabled by default. You can enable it with the new flag transparency on TileSet3DLayer. When disabled, any transparent surfaces will just be opaque.

Use the LoadingStrategy.shouldUpdate API to decide if an existing feature should be replaced by a feature that comes from a processed query cursor. You can implement a custom shouldUpdate predicate to control how changes to features should be handled by LuciadRIA. This API is extended now to include the LoadEverything strategy too. Please note that LoadSpatially already exposes this API since releases 2018.1.

It is now possible to displace terrain geometry by setting a RasterStyle.displacementExpression on the RasterTileSetLayer.rasterStyle of an elevation layer. This can for example be used to flatten the terrain in an area where you want to place a 3D mesh of a building.

It is now possible to add an outline to a TileSet3DLayer by using TileSet3DLayer.outlineStyle. Additionally it is now also possible to make your TileSet3DLayer visible when it is obscured by another layer, for example underground pipes beneath another mesh. To enable this you need to set an OcclusionStyle via TileSet3DLayer.occlusionStyle. With OcclusionStyle.bodyColorExpression you can control the color of the occluded part of the layer. An outline can also be configured for the occluded part of the layer using OcclusionStyle.outlineStyle.

Improved TypeScript definition for Decoration.alignment property. The property accepts now only expected string literals: "left", "center" or "right".

The Icon3DStyle now accepts both glTF version 1.0 and 2.0. Additionally it's now possible to use binary glTF as well.

Labels drawn on borders of a Cartesian map are positioned by default as follows:

• PointLabelPosition.SOUTH for labels drawn on the bottom border
• PointLabelPosition.WEST for labels drawn on the left border

Cartesian references which can be created with ReferenceProvider.createCartesianReference can now be used as the world reference on a WebGLMap. This allows you to visualize non-georeferenced data on a WebGLMap, e.g. timeline, image defined in CRS:1, etc.

The use of a WebGLMap with a Cartesian reference is demonstrated in the timeline, vertical view and image viewer sample.

A WebGLMap with a Cartesian reference has the following limitations:

• For raster data the reference of the data and the map must be equal, e.g. both must use CRS:1.
• World sized styling is not supported.

The type of Feature.properties is FeatureProperties instead of object. Now it's no longer needed to cast Feature.properties to a specific type in order to prevent typing issues when accessing an arbitrary property.

The atmosphere effect of GraphicsEffects was enhanced. The atmosphere can now more accurately visualize time of day. See LightScatteringAtmosphere for more details.

The model accessor of RasterTileSetLayer is now more precisely typed with RasterTileSetModel | null instead of Model | null.

LuciadRIA now supports HSPC version 12.

Fixed the type definition of BasicFeaturePainter.setStyle and BasicFeaturePainter.getStyle. It no longer takes a complete PaintState object, but rather just an object literal with a selected property (no need to specify a level, which isn't used by BasicFeaturePainter).

Fixed the ordering of multiple icons at the exact same 3D location. The painting now follows the regular ordering based on layer and z-order.

Improved the performance of feature updates through model changes on a WebGLMap. This is particularly noticeable when regularly updating thousands of track positions. Such scenarios had regressed compared to LuciadRIA 2019 and LuciadRIA 2018. Now its performance has improved by up to 50% compared to previous releases.

The ContextMenuManager in the samples now only consumes click events on the document.body node when the context menu is being displayed. This makes the ContextMenuManager compatible with UI frameworks like React. Before this change, React components would not respond to click events.

The caching for symbols retrieved from the SymbologyServer is now optimised to make sure that for each symbol only a single request is sent to the server.

HSPCTilesModelDescriptor now exposes the properties as an object. Before 2020.1, they were exposed as an array of strings encoding their names. The format is now aligned on the one given in the OGC3DTilesModelDescriptor. If you were reading the property array, you will need to change the logic to loop on the members of this new object.

The KMLLayer.painter now respects the visibility flag when drawing KML features. Prior to 2020.1 release, KML features were always visible disregarding the visibility. The previous behavior can be restored by forcing the visibility value to "true".

      layer.workingSet.on("QueryFinished", () => {
        layer.workingSet.get().forEach(kmlFeature => kmlFeature.properties.visibility = true);
        layer.painter.invalidateAll();
      });
    

An alternative solution is to create a user interface to control visibility of KML features. The "KML" sample demonstrates how to create such a UI component.

Codec.decode can now also return a Promise<Cursor>. If you are using this you will need to do a type check first.

The RasterStyle interface was moved to its own module. Since this is a type only import, only TypeScript projects are affected by this change. In your TypeScript code you will need to update the import to import {RasterStyle} from "@luciad/ria/view/style/RasterStyle"

The ES modules version of LuciadRIA no longer has out-of-the-box support for Internet Explorer 11. This makes the LuciadRIA modules smaller in size and it results in more performance on modern browsers. If you do still need Internet Explorer 11 support, you can use the AMD version of LuciadRIA. Alternatively, you can transpile LuciadRIA's ES modules down to ES5 with IE11 support, using a transpiler like Babel. The "Supporting Internet Explorer 11" how-to article explains how you can do this. Note that LuciadRIA samples will no longer run on Internet Explorer 11 out-of-the-box.

Functions that had Promise<number> | Promise<string> in their return type, now return Promise<number | string>. As a result you might need to change some casting in your TypeScript code. This change affects functions on WorkingSet and FeatureModel.

The way inheritance is implemented in the constructor of ES5 classes, has changed. If you subclassed a RIA class in ES5, like this:

      function SubClass() {
        SuperClass.call(this, arg1, arg2);
        this._field = arg1;
      }

      SubClass.prototype = Object.create(SuperClass.prototype);
      SubClass.prototype.constructor = SubClass;
    

You'll have to change the implementation of the constructor, like this:

    function SubClass() {
      var _this = Reflect.construct(SuperClass, [arg1, arg2], this.constructor);
      _this._field = arg1;
      return _this;
    }

    SubClass.prototype = Object.create(SuperClass.prototype);
    SubClass.prototype.constructor = SubClass;
    

Note that Reflect.construct is not available on Internet Explorer. If you're targeting Internet Explorer, you will have to make sure that a polyfill for Reflect.construct is available.

If you're using ES6 classes, no changes are necessary.

LayerTreeVisitor has been converted to an interface, thus you can no longer extend from it. The default implementation had no functional use, thus removing the inheritance from your code does not change any functionality.