LuciadRIA Release notes

      const polyline = createPolyline(reference, [[0,0], [5,2]]);
      const polygon = createPolygon(reference, [[0,0,1000], [5,2,1000], [0,4,1000]]);
    

• EPSG:2065
• EPSG:5221
• EPSG:5513
• EPSG:5514
• EPSG:8352
• EPSG:8353

• MIL-STD-2525b: G*G*OLAV--****X - Friendly Aviation
• MIL-STD-2525b: G*G*OLAA--****X - Friendly Airborne
• MIL-STD-2525c: G*G*OLAV--****X - Aviation
• MIL-STD-2525c: G*G*OLAA--****X - Airborne
• MIL-STD-2525d: 10002500001514010000 - Friendly Airborne/Aviation
• APP-6A: G*C*MOLAF-***** - Friendly Aviation
• APP-6A: G*C*MOLAA-***** - Friendly Airborne
• APP-6B: G*C*MOLAF-***** - Friendly Aviation
• APP-6B: G*C*MOLAA-***** - Friendly Airborne
• APP-6C: 10002500001513000000 - Airborne/Aviation Axis Of Advance
• APP-6D: 10002500001514010000 - Friendly Airborne/Aviation

• MIL-STD 2525b: 2.X.4.3.1.1 - Rectangular Target
• MIL-STD 2525c: 2.X.4.3.1.1 - Rectangular Target
• APP-6C: 10002500002306000000 - Rectangular Target

1. Indicate the origin point A
2. Indicate a point B on the minor radius of the first sector
3. Indicate a point C on the left side of the first sector
4. Indicate a point D on the right side of the first sector Note: the major radius is defined by the point (C or D) that is furthest away from B.
5. Repeat steps 2, 3 and 4 for the subsequent sectors.

1. MIL-STD-2525d
2. APP-6D

• MIL-STD-2525b: Wind Plot - WAS-WP----P----
• MIL-STD-2525c: Wind Plot - WAS-WP----P----
• APP-6A: Wind Barb - W*A*W-----*****
• APP-6B: Wind Barb - W*A*W-----*****
• APP-6C: Wind Barb - 10004500001126000000

      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
        }
      });
    

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

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

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.

• 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.

A WebGLMap with a Cartesian reference can be used to create this timeline for example.

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

      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.