More

Chained rendering to create contour gives correct WMS but incorrect WFS using openlayers


I'm trying to create a contour as vector layer using this example: http://boundlessgeo.com/2013/01/chaining-rendering-transformations-in-geoserver/. My setup is GeoServer v2.5.3 and gwt-openlayers. When I create the contour as WMS layer, the layer shows OK with correct contour lines, but when I create the same layer as WFS layer, the layer only shows the original points used for the barnessurface.

Is my assumption correct it should be possible to create the contour layer as real vectors/features and how can I accomplish this? Or is it only possible to create the contours as WMS layer?

Here is a code section for the two layers. WMS shows correct contours, WFS only displays the points:

WMSParams wmsParams = new WMSParams(); // wmsParams.setFormat("format"); wmsParams.setLayers("ws:values"); wmsParams.setFormat("image/png"); wmsParams.setTransparent(true); WMSOptions wmsLayerParams = new WMSOptions(); wmsLayerParams.setUntiled(); wmsLayerParams.setTransitionEffect(TransitionEffect.RESIZE); wmsLayerParams.setSingleTile(false); String wmsUrl = "http://localhost:8080/geoserver/gwc/service/wms"; WMS wmsLayer = new WMS("WMS contour", wmsUrl, wmsParams, wmsLayerParams); wmsLayer.setIsBaseLayer(false); wmsLayer.setIsVisible(false); map.addLayer(wmsLayer); // now set style (seems like can't be done before layer is added to // map) wmsLayer.getParams().setStyles("contours"); WFSProtocolOptions wfsProtocolOptions = new WFSProtocolOptions(); wfsProtocolOptions.setUrl("http://local3:8080/geoserver/ws_geotax/wfs"); wfsProtocolOptions.setFeatureType("values"); wfsProtocolOptions.setGeometryName("GEOMETRIE"); WFSProtocol wfsProtocol = new WFSProtocol(wfsProtocolOptions); VectorOptions vectorOptions = new VectorOptions(); vectorOptions.setProtocol(wfsProtocol); vectorOptions.setStrategies(new Strategy[] { new BBoxStrategy() }); vectorOptions.setStyle(new Style("contours")); Vector wfsLayer = new Vector("WFS contour", vectorOptions); map.addLayer(wfsLayer);

That is not an error. The data are points also for WMS but the advanced SLD with transformations creates a visual presentation with contour lines on-a-fly.

The purpose of WFS is to deliver data as they are natively and therefore you are getting points. Data processing like generating contours from points is something for Web Processing Service (WPS). Read this tutorial about that http://suite.opengeo.org/4.1/processing/contour/static.html.


Web cartography with open standards – A solution to cartographic challenges of environmental management

The visualization of spatial information in the form of maps is a critical task to facilitate decision making in environmental management. Web Map Services (WMS), Styled Layer Descriptor (SLD) and Symbology Encoding (SE) already created an open framework for Web mapping services. However, from the cartographic point of view, the OGC standards have several limitations for producing high quality cartographic representations.

Fortunately, these standards can be cartographically enriched to fulfil the complex visualization requirements coming from environmental management. A solution to creating cartographic visualizations based on open standards was developed in the frame of two major European projects, namely ORCHESTRA (Open Architecture and Spatial Data Infrastructure for Risk Management) and SANY (Sensors Anywhere). For example, the IST – 6th Framework Integrated Project SANY, focuses on interoperability of in situ sensors and sensor networks. In this context, sensors serve as an extreme illustration for the dynamic nature of spatial information that must be represented in the form of maps.

The cartographic extensions for the Symbology Encoding (SE) standards allow expressing cartographic rules with spatial operators and advanced feature filtering for layer masking, flexible point symbolization, and patterns and gradients for all spatial features. Furthermore the critical point of creating thematic maps is also solved with extensions for intuitive choropleth and various diagram types generation.


Using residue theorem to calculate following integral

eginlabel S(z) = dfrac<1><2pi>int_<0>^ <2pi>dfrac<>+z><>-z> e^<-lambdasin^<2>(phi/2)> mathrm dphi end where $lambda$ is a real positive parameter. Now here's my attempt which I'm pretty sure is incorrect. We can transform the above real integral into a contour integral over the unit circle using the substitution $w = e^$ . First note that - egin exp(-lambdasin^<2>(phi/2)) &= exp(-lambda/2)exp((lambda/4)(e^ + e^<-iphi>)) &= exp(-lambda/2)exp((lambda/4)(w + 1/w)) end

Therefore the above integral now becomes -

The integrand has singularities at $w = z$ and $w = 0$ (I'm interested in the case when $|z|<1$ ) so we can evaluate the residues at both of these singularities and then employ the residue theorem. The residue at $w = z$ is found to be

whereas to evaluate the residues at $w = 0$ , we need to expand the exponential as a power series and keep only all those terms which possess a simple pole at $w=0$ . Since

$expigg(dfrac<4>igg(w + dfrac<1>igg)igg)dfrac<1> = sum_^ dfrac<1>igg(dfrac<4>igg)^dfrac<(w^2+1)^><>>$ and from the binomial expansion we know that

It's clear that only the terms with even n yield a simple pole since we must have $n=2k$ . And I think finally the residue evaluates to a modified Bessel function of the form $ - I_<0>(lambda/2)$ where the negative sign comes about from the $(w+z)/(w-z)$ part. And so we obtain

$S(z) = exp(-lambda/2)igg( 2 expigg(dfrac<4>igg(z + dfrac<1>igg)igg) - I_<0>(lambda/2) igg)$

But something seems to have gone wrong here since the above expression has a singularity at $z = 0$ whereas the original expression for the function is clearly finite at $z=0$ . I'm really unsure where I've made the mistake. Any help is hugely appreciated. Thanks !!


6 Answers 6

I played around with this using parts because it looks like an integral that involves polylogs. Many of these can be done with parts or multiple use of parts.

Now, use parts on this last integral:

(as a note, $intfracdu=Li_<2>(1/u)$ is a rather famous integral related to the dilog).

Also, note this last integral is simply $-Li_<3>(1/u)$

Now, back sub $u=x+1$, and put it altogether using the integration limits 0 to 1.

I think this ties together the aforementioned ideas quite nicely:

Step 1: Integrate by parts. Let $u=log$ and $dv=frac<1+x>$. We obtain $v=frac<1> <2>[log(1+x)]^2$. Being somewhat careful with the limits, we see that the integral itself is equal to $ -frac<1> <2>int_0^1 frac<[log(1+x)]^2>,dx $

Step 2: Expand $log(1+x)$ and $log(1+x)/x$ into their Taylor series and combine. $ -frac<1> <2>int_0^1left(sum_^ (-1)^ frac ight)left(sum_^infty (-1)^i frac ight),dx = -frac<1> <2>sum_^infty sum_^infty frac<(-1)^> $

Step 3: There are a few ways to go here, but I like $k=i+j+1$ followed by a partial fraction decomposition. Then, $ -frac<1> <2>sum_^infty frac<(-1)^k> sum_^ frac<1> = -sum_^infty frac<(-1)^k> H_ $

Step 4: . It is not clear to me why this quantity is the desired one, but prior responses seem to indicate as such. Anybody else with thoughts?


Methodology

In order to find out the requirements for the deliverables of the Working Group, use cases were collected. For the purpose of the Working Group, a use case is a story that describes challenges with respect to spatial data on the Web for existing or envisaged information systems. It does not need to adhere to certain standardized format. Use cases are primarily used as a source of requirements, but a use case could be revisited near the time the work of the Working Group will reach completion, to demonstrate that it is now possible to make the use case work.

The Working Group has derived requirements from the collected use cases. A requirement is something that needs to be achieved by one or more deliverables and is phrased as a specification of functionality. Requirements can lead to one or more tests that can prove whether the requirement is met.

Care was taken to only derive requirements that are considered to in scope for the further work of the Working Group. The scope of the Working Group is determined by the charter. To help keeping the requirements in scope, the following questions were applied:

  1. Is the requirement specifically about spatial data on the Web?
  2. Is the use case including data published, reused, and accessible via Web technologies?
  3. Has a use case a description that can lead to a testable requirement?

National Geodetic Survey Web Site

Posted by jeffhobbs on May 29, 2008

For a while I’ve been wanting to sanity check my GPS points against a known entity. So, I’ve been looking for a set of survey monuments for Santa Clara County. Up to now, I haven’t been able to find them. My plan is to simply shoot the monument with each of my GPS units and compare the results I receive from the unit to the survey monument coordinates. HOPEFULLY they’ll be very similar….

Anyhow, today I finally got the bright idea to contact the county surveyor’s office. They pointed me to the NGS web site. As it turns out, they host survey monuments for the entire nation on this site. Even better, they allow you to download a shapefile with the control points. So next I’ll be loading the shapefile into GeoMedia and then writing a couple of simple functional attributes to translate from lat/long to California State Plane coordinates. After that, I’ll be able to shoot the survey monuments and finally double check the horizontal accuracy of my GPS systems.

Not very GeoMedia related, but did want to pass the site along to others looking to do something similar.


Recent advances and challenges in uncertainty visualization: a survey

With data comes uncertainty, which is a widespread and frequent phenomenon in data science and analysis. The amount of information available to us is growing exponentially, owing to never-ending technological advancements. Data visualization is one of the ways to convey that information effectively. Since the error is intrinsic to data, users cannot ignore it in visualization. Failing to observe it in visualization can lead to flawed decision-making by data analysts. Data scientists know that missing out on uncertainty in data visualization can lead to misleading conclusions about data accuracy. In most cases, visualization approaches assume that the information represented is free from any error or unreliability however, this is rarely true. The goal of uncertainty visualization is to minimize the errors in judgment and represent the information as accurately as possible. This survey discusses state-of-the-art approaches to uncertainty visualization, along with the concept of uncertainty and its sources. From the study of uncertainty visualization literature, we identified popular techniques accompanied by their merits and shortcomings. We also briefly discuss several uncertainty visualization evaluation strategies. Finally, we present possible future research directions in uncertainty visualization, along with the conclusion.

Graphic Abstract

This is a preview of subscription content, access via your institution.


LuciadFusion Samples

This is a command-line sample. Click More info for run instructions.

This command-line tool demonstrates how to decode vector data in various formats and export them as a GeoJson file.

Run the sample using the shell script in the samples folder:

The input consists of two parameters: (1) the path to the input vector file (for example, in SHP format), and (2), the path of the output GeoJson file.

Encoding MIF samples.encoder.mif.Main

This is a command-line sample. Click More info for run instructions.

This command-line tool demonstrates how to decode vector data in various formats and export them as a MIF file.

Run the sample using the shell script in the samples folder:

The input consists of two parameters: (1) the path to the input vector file (for example, in SHP format), and (2), the path of the output MIF file.

Encoding GeoTIFF samples.encoder.raster.geotiff.Main

This is a command-line sample. Click More info for run instructions.

This command-line tool demonstrates how to decode rasters in various format and encode them in GeoTIFF format, using a TLcdGeoTIFFModelEncoder.

Run the sample using the shell script in the samples folder:

The input can be a single raster or a list of rasters that lie on a regular grid. The sample automatically figures out the structure of the grid and creates a composite raster that can be saved. The code may be generally useful for creating such composite rasters. They are more efficient to work with than the original unstructured list of rasters, for instance for analysis or for visualization.

The output GeoTIFFs are tiled and multi-leveled, and optionally compressed with JPEG compression. The default tile size is 256x256 pixels. The default number of levels is 5. The JPEG compression quality is a specified value between 0 and 1.

The supported options are:

GXY: Balloon samples.gxy.balloon.MainPanel

This sample demonstrates how to create your own balloons. Just click any of the domain objects to see an example of a balloon in action. Of the 4 domain objects 3 have a balloon attached to them.

Instructions

This sample demonstrates how to create your own balloons. Select a domain object to see an example of a balloon in action. Balloons are only shown when one domain object is selected.

One of the objects contains a balloon with a button that can be used to close itself. An other balloon shows an image, and an other one shows a text label. The last domain object doesn't have a balloon attached to it.

You can move around balloons by dragging near their border. Balloons can be rescaled by dragging their lower right corner. The can also be closed by clicking the exit icon in the upper right corner.

Map raster values to colors samples.gxy.colormap.MainPanel

This sample shows you how to map raster data values to colors using TLcdColorMap , and how to interactively customize such a map using TLcdColorMapCustomizer .

The sample shows elevation data that can be customized using the configuration panel.

Instructions

The color map customizer allows configuring the following:

  • change the altitudes by clicking on them
  • change the colors by clicking on the colored rectangles
  • enable or disable gradient coloring
  • enable or disable the linear scale
  • in linear scale mode, drag the arrows around with the mouse
  • add, remove, or re-initialize levels using the toolbar buttons

GXY: Asynchronous layer painting samples.gxy.concurrent.painting.MainPanel

This sample demonstrates the ability to paint asynchronously. It shows how to instantiate an asynchronously painted layer and a paint queue that handles the actual painting. The layer is then painted in the background, in a separate thread, so the painting no longer blocks the user interface.

It also illustrates how to automatically assign paint queues to the asynchronous layers by using several paint queue managers which can be activated one-by-one:

  • The default paint queue manager, minimizing the number of paint queues.
  • A paint queue manager based on the paint times of the layers. The layers will only share a paint queue if their average painting times are of the same magnitude.
  • A paint queue manager using a fixed number of paint queue instances. The default number of paint queues is determined by the number of CPUs.

The sample shows a number of layers that are painted asynchronously. Layers sharing a paint queue have the same color in the layer control. For illustration purposes, some layers have a fixed paint time, which is indicated in between square brackets.

Instructions

Try panning and zooming with the mouse wheel. New layer contents are added after the operations. The layer control coloring shows which layers use the same paint queue. Switch the paint manager, and notice how the paint queue assignments change. The synchronous layers (in black) and the unmanaged layer stay the same.

There are 2 rendering checkboxes to the right of the map:

  • the Asynchronous checkbox allows you to switch on and off the asynchronous rendering, falling back to the synchronously painted original layer. Be advised that, because there are some very slow layers in the sample, the synchronous mode will make the sample slow and unresponsive.
  • the Translucent checkbox renders all content translucent. This demonstrates how to modify the state of the wrapped layer.

GXY: Contours samples.gxy.contour.MainPanel

This sample demonstrates how to calculate and visualize terrain contours as polylines and complex polygons.

Instructions

Four different contour layers are available:

  • labeled polyline contours
  • polyline contours with the altitude in the line style
  • polygon contours that contain each other
  • disjoint polygon contours

GXY: Decoding multiple format data samples.gxy.decoder.MainPanel

This sample demonstrates the ability to load and visualize data from sources in different formats by making use of ILcdModelDecoder and ILcdGXYLayerFactory .

A File and a URL action are configured to load data in almost every available format.

The sample uses a composite ILcdModelDecoder to decode the data into an ILcdModel . After this, a composite ILcdGXYLayerFactory creates a layer that controls how the ILcdModel of the loaded data is displayed. The model decoders and layer factories are retrieved using a service look-up mechanism, and contain both built-in and sample implementations.

The sample supports images that are not georeferenced if the images are described in a small *.rst meta-file (see TLcdRasterModelDecoder ). The sample also includes a custom format (see the package samples.decoder.custom1 ) to show how to implement your own model decoder.

A save action, only available when the sample is run standalone, allows you to save an ILcdModel to its file if an ILcdModelEncoder is set to the ILcdModel . Currently this is only done for the custom format.

Instructions

Open a file or URL by clicking the appropriate toolbar button or by dragging a file or URL onto the map. Load Washington DC spot satellite image ( .rst format ) and Washington DC streets ( .shp format ) and notice how the data overlap. Load mixed.txt, edit the shapes and save the model (only when run standalone).

GXY: Displaying element densities samples.gxy.density.MainPanel

This sample demonstrates how to display color-coded densities of data, by means of a TLcdGXYDensityLayer.

The applet shows a set of flight trajectories above USA, with colors ranging from blue, for quiet regions, to bright white, for busy regions.

Instructions

Pan and zoom around. Notice that asynchronous painting ensures that the view stays responsive.

GXY: Editing geometric shapes samples.gxy.editing.MainPanel

This sample demonstrates how to interactively create and edit ILcdShape objects in an ILcdGXYView.

The toolbar contains buttons that create several shapes, by using different instances of the TLcdGXYNewController2 controller. Each controller has its own controller model, defining the type of shape to create, in which ILcdGXYLayer to add it and how to add it.

The layers provide the necessary ILcdGXYPainter and ILcdGXYEditor instances to properly render, create and edit any ILcdShape it contains.

Next to this, the panel at the right has the following configuration options:

  • Rendering can be simplified by using straight lines (a pen setting)
  • The shape outline/fill can be changed (a painter setting)
  • New shapes can be defined in a geodetic (lon lat) reference, or a grid reference. Note that rhumb shapes cannot be defined in a grid reference.
  • The sub-curve type of composite curves can be changed, even while creating the curve.
Instructions
  • Click one of the new shape buttons in the toolbar and click on the map to create a new shape. For composite curves, you can start a new subcurve by selecting a shape in the drop down box.
  • Edit a shape in one of the shape layers by dragging one of its points or segments. Notice how Geodetic shapes stay within their model reference (e.g. the earth) and wrap over the dateline, whereas Grid shapes are not bound by lon-lat coordinates.
  • Using the CTRL (CMD on Mac OS) key, you can reshape objects. For example, for polylines and polygons, it allows you to add or remove points.
  • Right-click on a point, polyline, or polygon and convert them into a buffer.
  • Notice how very long geodetic and rhumb lines are not necessarily straight.

GXY: Editing with multiple modes samples.gxy.editmodes.MainPanel

This sample shows how to implement a multi-mode edit controller i.e. a controller that changes its state when you click on an already selected object. The controller is used in a painter/editor wrapper to change the painter/editor, allowing different editing behavior.

The controller supports 2 modes:

  • DEFAULT: the default mode indicating the controller's standard behavior.
  • ROTATION: the rotation mode of the controller.

To add the rotation behavior, a support class defines a number of abstract methods that need to be implemented for a specific shape:

  • a method returning an object's current rotation
  • a method returning the rotation center of an object
  • a method that rotates an object
Instructions

The sample shows two polygons that can be rotated in their respective model references. To activate the rotation mode, select an object, and click once more on the object. Rotate the shape by grabbing and dragging one of the rotation handles. Click again on the object to cycle through the available modes. Click on a previously unselected object to reset the editing mode.

GXY: Geoid samples.gxy.geoid.MainPanel

This sample illustrates support in LuciadLightspeed for geoids. It shows an image containing the geoid heights of the EGM2008 datum (Earth Gravity Model, 2008). Blue colors indicate that the geoid heights are negative (geoid below the ellipsoid of the WGS84 datum). Green colors indicate that the geoid heights are positive (geoid above the ellipsoid).

The geoid heights are also displayed in a label on the toolbar.

Geoid heights are typically used behind the screens, in calculations with references that have geodetic datums based on geoids. They are relevant for elevation data, for instance, which are commonly defined with respect to a few standardized geoid models. For accurate computations, elevations above a geoid can then be transformed to elevations above an ellipsoid.

Instructions

Move the mouse and see how the geoid height changes.

GXY: Grids samples.gxy.grid.MainPanel

This sample demonstrates how to display the following grid layers:

  • Lon Lat: a simple multi-level grid showing longitude and latitude lines. The lines are refined up to the second.
  • Border: a maritime-style lon lat border grid. The coordinates are refined up to the degree.
  • Georef: an alphanumeric multi-level grid based on longitude latitude lines. The lines are refined up to the degree. The labels denote 1-by-1 degree squares.
  • XY: a grid based on an ILcdXYWorldReference. The labels denote meters.
  • MGRS: an alphanumeric multi-level, multi-reference grid used by NATO. The grid starts with 60 zones, plus the north and south pole area. As you zoom in, each zone is refined into 100.000m squares that are defined in a zone-specific reference system. The squares are further refined up to the kilometer.
  • CGRS, GARS, and OSGR: sample implementations of multi-level alphanumeric grid systems. GARS starts with cells half a degree wide and half a degree high, that are subdivided into 4, then into 9. CGRS can be defined for a specific area. It starts with cells half a degree wide and half a degree high, that are subdivided into 9, then into 4. OSGR is only defined for the United Kingdom, and offers two levels.
Instructions

Pan and zoom around. Play around with different projections and grid layers. Notice how the grid and its labels adapt.

The GARS and CGRS grids allow assigning alliances to individual grid elements at any level. To do this, activate the paint controller and choose the desired alliance from the combo box.

Height samples.gxy.height.MainPanel

This sample illustrates the use of height providers in LuciadLightspeed. It shows a raster containing height data. The height values of the data under the mouse cursor are displayed in a label on the toolbar.

The sample uses a view height provider to retrieve height values.

Instructions

Move the mouse over the raster and see how the height values change. Moving the mouse outside the raster will indicate that no height data could be found.

GXY: Highlighting domain objects samples.gxy.highlight.MainPanel

This sample demonstrates how to highlight domain objects. A custom controller looks at the domain objects under the mouse cursor and informs the relevant layer that an object should be highlighted.

Instructions

Hover above the cities and states. The city or state under the mouse will change color.

GXY: A painter/editor implementation samples.gxy.hippodromePainter.MainPanel

This sample contains an implementation of the ILcdGXYPainter and ILcdGXYEditor interfaces for a new shape, a hippodrome, which consists of two half circles connected by two lines. Instead of using composition this sample demonstrates how to create a painter/editor from scratch.

Note that this is sample code to demonstrate writing painters. If you need to model a hippodrome, please refer to our ILcdGeoBuffer implementations.

The shape is defined by two points and a width. An XY and a lonlat shape is provided both of which can be handled by the painter/editor taking into account some precaution for the geodetic shape.

The painter supports painting in the following modes:

  • painting the object in default and selected mode,
  • painting the object while it is being edited,
  • painting the object while it is being created.
  • moving one of the defining points which results in a rotation, elongation of the shape,
  • moving the whole shape,
  • changing the width of the shape.
Instructions

This sample is mainly intended as a developer's guide to construct painters and editors from scratch. To create a new hippodrome, click on either of the two buttons in the toolbar. To edit a hippodrome,

  • move one of the points by dragging the mouse starting from a point,
  • move the whole shape by dragging the mouse starting from the outline,
  • change the width of the shape by dragging the mouse starting from the outline with the CTRL (CMD on Mac OS) key down.

GXY: Basic icons samples.gxy.icons.MainPanel

This sample demonstrates LuciadLightspeed's abilities to display icons. These icons, painted by a TLcdGXYIconPainter can be scaled using a world or pixel scaling mode. They can also return an anchor point, which gives them an offset. The sample also demonstrates oriented icons.

Instructions

You can dynamically change the scale and scale mode by using the controls in the 'Icon scaling options' panel. The pin icons represent cities. Notice how the tip of the pin is anchored to the city. Notice how every airplane has a different rotation: the rotation is automatically retrieved from the domain object.

GXY: Create Labeling Algorithm samples.gxy.labels.createalgorithm.MainPanel

This sample demonstrates the creation and usage of labeling algorithms and labeling algorithm wrappers. MyLabelingAlgorithm is a labeling algorithm that tries to place all labels on the domain object's anchor point. There are three wrappers that can be combined with this algorithm and each other.

  • RotationAlgorithmWrapper : Rotates all labels
  • MorePositionsAlgorithmWrapper : Creates extra label placements to be tried by offsetting the label by a few pixels in each direction.
  • LabelDetailAlgorithmWrapper : Adjusts the size of the font and amount of information to create more label placement possibilities.
Instructions

After starting the sample, it is possible to choose between two labeling algorithms: The sample algorithm SampleLabelingAlgorithm and a default labeling algorithm. Use the check boxes to enable/disable using more possible positions or changing the font size during labeling. Also moving the slider adjusts the rotation of all labels.

GXY: Interactive labels samples.gxy.labels.interactive.MainPanel

This sample demonstrates how labels can be made interactive. The labels can be edited in the sense that they can be moved to a new location, as well as in the sense that they offer the user an interactive component that can be used to edit information related to the domain objects.

Instructions

Move the mouse over a label of a city. An interactive, editable label will be shown instead of the regular label. You can enter a comment for the labeled city in the text field. To apply the changes, press the Enter key or press the green tick mark at the top of the interactive label. To cancel the outstanding changes, press the red 'cancel' icon at the top of the label or press the Escape key.

The interactive label can be moved by clicking and dragging on the title bar of the interactive label.

GXY: Offset icons samples.gxy.labels.offset.MainPanel

This sample demonstrates LuciadLightspeed's abilities to display icons at a certain offset. These icons, painted by a regular ILcdGXYPainter, are offset with respect to the domain object. This offset can be dynamically changed using the mouse.

It also shows how the used labeling algorithm can be configured to drop labels together.

Instructions

You can dynamically change the offset of the icon by selecting a city, and then dragging the icon while keeping the 'Control' button pressed.

GXY: Basic Labeling samples.gxy.labels.placement.MainPanel

This sample demonstrates the asynchronous label placer and the default labeling algorithms.

Labeling algorithms take into account the labels that are already placed to avoid overlap. An ILcdGXYLayer will therefore most likely have less labels painted when it is at the bottom than when it is at the top of the ILcdGXYView.

Instructions

To see the effects of the labeling algorithms select a layer, by clicking it in the layer control and:

  • change the layer's visibility
  • set the layer labeled/not labeled
  • move the layer up/down

GXY: Street Labeling samples.gxy.labels.streets.MainPanel

This sample demonstrates LuciadLightspeed's abilities to paint and label streets. Highways are labeled using an icon, while city streets (zoom in on Washington DC) are labeled using text labels.

Instructions

Zoom in and out to see multiple levels of detail on the map. The USA region contains highway data, and the Washington DC region contains streets data.

Magnetic north samples.gxy.magneticnorth.MainPanel

This sample shows you LuciadLightspeed's capabilities regarding the magnetic north.

The magnetic north does not coincide with the true north. The difference between the magnetic and true north is called magnetic declination and depends on your position in space and time. There are different mathematical models to calculate and predict the magnetic north, each with their own lifespan. LuciadLightspeed comes with the two most popular models: WMM and IGRF.

The sample shows a compass control for the magnetic north, and iso lines of constant magnetic north declination.

Instructions

Click on any place on the map to center on that point and rotate the map so that the top points towards the magnetic north. Notice that the magnetic north compass will point straight up. Right-click to reset the custom rotation again. Zoom in on a magnetic declination line. The readout at the bottom of the map shows the exact declination value for the mouse location. The magnetic value at the center of the map should be the difference between both compasses.

GXY: On Map Navigation Controls samples.gxy.navigationcontrols.MainPanel

This sample demonstrates how to create, customize, add on map navigation controls over a 2D view.

Instructions

The default controls are in the top right corner when you run the sample. Drag the outer ring of the upper part to rotate the view (you can hold down the CTRL (CMD on Mac OS) button to constrain rotation to multiples of 15 degrees). Click on the North symbol of the outer ring to return the view to the original rotation. Press and hold anywhere in the circle with the hand symbol to pan the view. The lower part allows you to zoom in and out.

On the left you can find a customized configuration. In the alternative configuration, the controls are split and the two sub-components are added in different places. Furthermore, the zoom component is now always emphasized, not only when the mouse is over it and the compass component can be relocated by dragging it with the right mouse button pressed.

GXY: Offscreen view samples.gxy.offscreen.Main

This is a command-line sample. Click More info for run instructions.

This command-line tool demonstrates how to create an off-screen view, display some decoded data in it, and save the result as a GeoTIFF file.

Run the sample using the shell script in the samples folder:

The input data can be in a variety of formats: SHP, MIF, MAP, GeoTIFF, etc. The output GeoTIFFs are 1024x1024 pixels, tiled (256x256 pixels) and multi-leveled (3 levels), and compressed with a lossless compression scheme. All of these settings can be changed in the sample code.

GXY: Overview map samples.gxy.overview.MainPanel

This sample demonstrates the use of a TLcdGXYOverviewController and the sharing of layers between multiple ILcdGXYView objects.

It consists of one main ILcdGXYView (TLcdMapJPanel) in the center and an overview map (TLcdMapJPanel) in the top right. The overview map remains focused on the USA and also displays a Rectangle that corresponds as much as possible to the area visible in the main view. Dragging the Rectangle in the overview or creating a new one makes the main view display data that are in the Rectangle. This Rectangle is updated each time the visible area in the main view changes (e.g. when panning or zooming). The overview displays the same ILcdModels using the same ILcdGXYLayers used in the main view.

Since an ILcdGXYView automatically listens to any property change of its ILcdGXYLayer objects, any change of those properties via the layercontrol will show in both views.

Instructions

Drag the Rectangle in the overview or create a new one. Pan and zoom in the main view: the Rectangle overview will update itself automatically. Remove a layer and notice that it is removed from both views.

GXY: Painter styles samples.gxy.painterstyles.MainPanel

This sample demonstrates the ability to paint polylines and polygons with rounded corners, simple or complex strokes, simple and hatched fill patterns, and a halo-effect.

The functionality to paint an ILcdPointList, like a polyline or polygon, with rounded corners is provided by TLcdGXYRoundedPointListPainter. A spline algorithm is used to transform the set of points into a smooth line that rounds each corner, by using additional control points on each line segment. The roundness of the corners can be adjusted in the sample, by selecting a shape and dragging the slider on top of the configuration panel.

To fill shapes with a solid color, TLcdGXYPainterColorStyle is used. To fill shapes with a hatched pattern, TLcdGXYHatchedFillStyle is used.

To render outlines with a simple, dashed stroke, TLcdStrokeLineStyle is used. To render the shapes with a pattern-based stroke, TLcdGXYComplexStroke is used. This java.awt.Stroke implementation allows to use a Shape array as pattern to render a shape. The sample illustrates how two different patterns can be combined in one TLcdGXYComplexStroke. It is also possible to control the width of each individual Shape, to obtain a gap between subsequent Shape objects. When a pattern is rather long, the functionality to automatically split up patterns can be used. This allows TLcdGXYComplexStroke to draw only a part of the pattern, when there is not enough space to put the complete pattern. If needed, the space between split up pieces is filled up with a fallback stroke.

The sample also illustrates halo effects. A halo is an outline of constant width and color around shapes or text, which is typically drawn in a contrasting color to ensure that the shapes or text are clearly visible on any background. For shapes, the halo effect is obtained by wrapping an ILcdGXYPainter (in this case, the TLcdGXYRoundedPointListPainter) into a TLcdGXYHaloPainter. This painter allows to control the halo color and thickness, as illustrated by the sample in the configuration panel.

Instructions
  • Select a polyline or polygon.
  • Change the roundness through the slider.
  • Choose a different pattern for the complex stroke, and adjust the repeating factor.
  • Change the halo color, and increase/decrease the halo width.

GXY: Printing samples.gxy.printing.MainPanel

This sample demonstrates how to print a component containing a view, using the TLcdGXYViewComponentPrintable.

Instructions

The sample creates a page layout containing the view and some decorations. You can preview the page or print it directly using the buttons in the toolbar.

GXY: Rectifying rasters samples.gxy.rectification.MainPanel

This sample demonstrates the ability to combine parametric rectification - using camera and terrain information - and non-parametric rectification - using user-defined tie-points.

Instructions

The left panel displays a non-modified version of the image currently being processed, together with a set of tie points. The right panel displays several layers, from bottom to top:

  • the world background data
  • the digital elevation map (terrain)
  • the input raster in its unmodified geographical reference (original raster)
  • the result of parametric rectification (orthorectified raster)
  • the result of non-parametric rectification (tie-point corrected raster)
  • the tie points
  • a layer containing data that can be used to verify the accuracy of the rectification

The default data is a simulated satellite photo of the city of Ithaca, NY. Due to the slanted viewing direction, the position of the original picture is distorted by a variable amount compared to the real position. The size of the distortion depends on the local terrain elevation - this can be verified by comparing the position of roads in the original raster with their actual position displayed by layer "109rds".

By taking into account the viewing direction and the variable terrain elevation, the sample creates an initial orthorectified version of the raster, which corrects most of the positioning errors. The user may further correct a copy of this raster by fine-tuning a set of tie points.

An initial set of tie points are shown in the left and in the right panels. Selecting a point in one panel will display the corresponding tie point in the other panel. Tie points in both panels can be dragged to other locations. This will trigger a remapping of the corrected image in the right panel, so that the tie points appear in approximately the same location relative to the raster.

New tie points can be added in the left panel by selecting the "Create new tie point" controller. Every time a new point is added in the left panel, a corresponding tie point is added to the right panel, at approximately the same raster coordinates (a small difference may be observed for highly warped rasters).

Existing tie points can be deleted by right-clicking on them and choosing "Delete" from the context menu. If fewer than 3 points are available, the raster is no longer updated.

By default, the mapping is done using a polynomial function. You may choose a rational function or a projective function instead, by selecting the "Edit raster projection parameters" action. You can also choose the maximum degree of the polynomial(s) used by the selected function. Note that polynomials of higher degree (3 or 4) are highly unstable and may produce strange warping effects. The number of required tie point pairs varies with the degree of the polynomial(s). If an insufficient number of tie points is defined, the function will automatically decrease the degree(s) used.

When you are satisfied with the rectification you may save a re-sampled version of the raster using the reference of the right-panel view using the "Save the raster in view's reference" button.

The sample can open existing single-level referenced GeoTIFF files, or non-referenced images (tif, png, gif, bmp, jpg). If the image is not georeferenced, it is placed at a default location, together with four initial tie points in the corners.

The open and save options are not available when the sample is running in a browser.

GXY: Displaying shapes samples.gxy.shapes.MainPanel

This sample shows how to programmatically create and display a model. It reveals how to create an ILcdModel, how to populate it with ILcdShape objects, and how to display that data in an ILcdGXYLayer on the ILcdGXYView.

Instructions

The sample shows a polyline, a polygon, and a point visualized by an icon. Try selecting and editing the shapes.

GXY: Painter, shape composition samples.gxy.shortestDistancePainter.MainPanel

This sample demonstrates how to create a composite ILcd2DEditableShape and a suitable ILcdGXYPainter and ILcdGXYEditor for that ILcd2DEditableShape.

The class ShortestDistanceShape is a composition of a TLcdLonLatPolyline and a TLcdLonLatPoint around this polyline. The class ShortestDistanceShape knows how to calculate the ILcdPoint on the geodesic TLcdLonLatPolyline that is the closest to the TLcdLonLatPoint.

The class ShortestDistancePainter implements ILcdGXYPainter and ILcdGXYEditor and is used for painting and editing ShortestDistanceShape objects. Existing painters for the composed shape object are used for painting, TLcdGXYIconPainter for the TLcdLonLatPoint and TLcdGXYPointListPainter for the TLcdLonLatPolyline. For painting the shortest distance path of the TLcdLonLatPoint to the TLcdLonLatPolyline the utility ILcdGXYPen is used.

Instructions

The painter-editor allows to move the TLcdLonLatPoint or a point of the TLcdLonLatPolyline of the ShortestDistanceShape object to any location while constantly showing the shortest distance path of the TLcdLonLatPoint to the TLcdLonLatPolyline.

GXY: Visualizing statistical information samples.gxy.statisticalPainter.MainPanel

This sample shows how to visualize shapes based on their domain object properties. A custom painter provider displays counties as polygons that are colored according to population density. Icon-based labels show different size rectangles depending on the population change.

Instructions

You can verify the visualization by double-clicking on a shape to examine its properties.

Model in a table samples.gxy.swingTable.MainPanel

This is a sample for displaying an ILcdModel's elements in a JTable. All the domain objects implement ILcdDataObject, which means they have a data type with a set of properties associated to each of them.

We load several ILcdModel which are displayed/represented in both the TLcdMapJPanel and the JTabbedPane (i.e. each ILcdModel is represented in 2 different views). For each ILcdModel, there is a corresponding ILcdGXYLayer in the map and a JTable in the JTabbedPane. The column names of each JTable correspond to the attributes names, the rows correspond to the attribute values. A mediator is used to synchronize the map and table selections.

Instructions
  • Select one or more rows in one of the tables. Notice how the domain objects are made visible and selected in the map.
  • Select one or more objects on the map. Notice how the corresponding table rows are selected as well.

GXY: Tooltips on the map samples.gxy.tooltip.MainPanel

This sample contains a custom implementation of ILcdGXYController, which displays tooltips for objects under the cursor. The text of the tooltips is obtained via the ILcdDataObject interface. The applyOnInteract2DBounds() method of ILcd2DBoundsIndexedModel is used to locate the object under the mouse cursor.

Instructions

Hover over a city or state and a tooltip will pop up after a short while.

GXY: Touch controller samples.gxy.touch.basic.MainPanel

This sample demonstrates the touch-based navigation, selection and ruler controllers in a GXY view. The controllers are shown in the toolbar at the top. The leftmost controller is a context sensitive selection and navigation controller.

The second controller only deals with navigation. It features one finger panning, and two finger panning, zooming and rotating (at the same time).

The third is a ruler controller. It works similar to the mouse based ruler controller, creating a polyline on the map that will display the length of each segment as well as the total length.

This sample features large buttons to allow easy manipulation with fingers instead of a mouse as input device.

Instructions

Using the select controller, you can touch objects to select them, pan around by dragging the map, or zoom and pan by dragging two fingers. A number of modifier buttons are available to change the selection behavior:

  • The first button enables multi-object selection by dragging a rectangle around objects. By default, dragging pans the map.
  • The second button toggles what happens when you touch selectable objects: select them (and deselect all other objects), add them to the selection, or remove them from the selection.
  • The third button enables showing a pop-up with the objects under your finger. The pop-up allows you to choose the object to select.

For the pan controller, drag one finger to pan, and two fingers to simultaneously pan, zoom and rotate the map.

To add points to the ruler controller's measurement, touch and lift your finger. Here as well a number of buttons are added to the map:

  • The blue arrows undo/redo a step.
  • The green V commits the created polyline. This switches the ruler controller to edit mode.
  • The red cross clears the polyline and allows you to start again.

GXY: Create and edit shapes with a touch device samples.gxy.touch.editing.MainPanel

This sample demonstrates how to create new ILcdShape objects and edit existing ILcdShape objects in an ILcdGXYView using a touch device.

The functionality available here is very similar to the functionality demonstrated by the editing sample. The main difference is that the controllers now interpret touch input instead of mouse input. This allows you for instance to translate an object using the edit controller with one finger and pan the view with another finger at the same time. The same goes for the controllers creating objects. Another issue is the lack of modifier buttons (on keyboard and mouse). To compensate the touch controllers have been extended with some on-map buttons. The edit controller has:

  • the same buttons as the select controller (see the touch.basic sample)
  • a button that toggles between translate and reshape behaviour when editing.
  • two buttons (blue arrows) to perform an undo respectively a redo operation. An undo will remove a previously placed point, while a redo will place a removed point again.
  • a (green) button to commit a shape under construction. This is only relevant for polylines and polygons. Other shapes will be committed when the necessary amount of points is placed.
  • a (red cross) button to cancel the current shape under construction, removing all points.
Instructions
  • Touch or click on one of the new shape buttons in the toolbar and touch the map to create a new shape. The point will only be placed when you release the touch. When you have placed of number of points (how many depends on the shape), an object will be added to the drawing layer, and the edit controller will be activated. For composite curves, you can start a new subcurve by selecting a shape in the drop down box.
  • Edit a shape in the user layer by dragging one of its points or segments

GXY: Generating touch events samples.gxy.touch.touchEvents.MainPanel

This sample demonstrates how TLcdTouchEvents can be created from hardware events. The sample simulates touch hardware generating hardware events. These events are intercepted and converted into touch events that can be used by LuciadLightspeed. After that they are dispatched.

Instructions

After opening the sample, touch events will be generated automatically. They pan, zoom and rotate the view.

Grid systems samples.gxy.transformation.geodeticToGrid.MainPanel

This sample demonstrates the ability to display a geodetic location which can be expressed based on different ILcdGeodeticDatum and express its coordinates in some commonly used grid reference systems and some lon lat formats.

Instructions

Move the displayed icon and see how its coordinates change.

There are two text fields which contain the geodetic latitude and longitude respectively. The latitude and the longitude are represented in a certain format which can be changed. Values have to be entered in this format too. The geodetic coordinate is with respect to a certain geodetic datum which can be altered. In the grid coordinates panel are the (x,y) grid coordinates of this geodetic LatLon coordinate according to some commonly used grid coordinate systems.

Changing the geodetic datum or the UTM zone will affect only the geodetic coordinate or the UTM coordinate. Since the geodetic datum of the projection in the map component is kept the same as the geodetic datum of the grid calculator, the icon will move slightly too.

GXY: Model-world and world-view transformations samples.gxy.transformation.mouseToGeodetic.MainPanel

This sample contains a custom implementation of ILcdGXYController, which transforms a rectangle dragged by the user (in view coordinates) into model coordinates. The mouse location is also converted into an arbitrary model reference (a grid reference with a polar projection for the north pole).

Instructions

Drag a rectangle on the map, and see the coordinates of its counter part in model coordinates, below the map. The last mouse drag or mouse click location is also expressed in another model reference.

GXY: Undo capabilities of LuciadLightspeed samples.gxy.undo.MainPanel

This sample demonstrates the undo support of LuciadLightspeed. It is based on the "shapes" sample and makes it possible to undo changes made to the domain objects.

Instructions

To witness the undo support, perform the following steps:

  • Activate the edit controller using the leftmost button in the toolbar.
  • Make some changes by dragging the polyline or one of its handles.
  • Create one or more new polylines using the new polyline controller in the toolbar.
  • Click the undo button in the toolbar and the changes you made will be reverted.

GXY: Vertical view samples.gxy.vertical.MainPanel

This sample demonstrates the use of the vertical view package. The 2D view in the upper part contains two layers: a background layer with a map of the world countries and a layer that contains two flights. Each flight is modeled as a list of 3D points. The 2D view only uses the first two coordinates(X,Y) of each of the points.

The vertical view in the lower part is used to display the vertical profile of the flight that is selected in the 2D view. Apart from this profile, a number of sub-profiles associated to it can be shown in a vertical view. In this case, only one sub-profile is associated to the view: the air route. FlightVVModel, an implementation of ILcdVVModel holds the main-profile points and the information about the sub-profile.

Instructions

Select a flight. A vertical marker is shown in both views. Change the height of the flight by dragging its points up or down. You can zoom the X and Y axes by using the sliders to the right and at the bottom. You can disregard flight points at the left or right of the flight using the sliders at the top. Finally, the panel at the right allows you to select the altitude unit.

Preprocessing 3D terrain samples.earth.preprocessor.MainPanel

This sample demonstrates the use of TLcdEarthTileRepositoryPreprocessor . This sample provides a simple user interface for creating, loading and saving 3D terrain metadata and preprocessing it to an Earth tile repository.

Instructions

To preprocess data as a 3D terrain to an Earth tile repository you need to:

The terrain metadata consists of a number of assets (that is source data files) and a geographic reference. Add some assets to the metadata by using the button at the bottom of the panel. You can either select individual files that need to be preprocessed or a directory that contains the files that need to be preprocessed. Once the assets are loaded they will appear in the metadata panel and their bounding box will appear on the map. For image assets you can also optionally set a clipping shape to limit the preprocessed part. This can for example be used avoid preprocessing a border that is present in the asset. You can save the terrain metadata (for example for using with the Earth On-the-fly sample) using the button below the map. Finally you can change the geographic reference of the terrain using the combo box at the top of the metadata panel. Typically this geographic reference is the one that will most often be used when visualizing the terrain repository.

The repository where the assets should be preprocessed to must be configured before the preprocessor can be started. You can optionally also change the data type that must be preprocessed and enable texture transparency. After pressing the start button the preprocessing progress can be tracked in the progress panel and on the map. The preprocessor can be stopped at any time and resumed again using the buttons in the progress panel.

Filtering data using the OGC Filter API samples.ogc.filter.model.MainPanel

This applet demonstrates the ability to filter data using the OGC Filter API. A layer showing earthquakes is added to the view on which a filter is configured. The layer filter is created from an OGC filter, which is created from a combination of three OGC conditions: 'a less than' for the magnitude, a temporal for the time period and a bounding box condition of a country.

The OGC conditions are expressed programmatically using the OGC Filter API. The creation of the OGC conditions is done in EarthQuakeFilterModel#createCombinedCondition. If there is a change in one of the parameters for the OGC conditions, a new OGC filter is created and converted to an ILcdFiltered by means of a filter evaluator. This conversion code can be found in MainPanel#addData.

Instructions

Use the controls in the filter configuration panel to adjust the different parameters of the filter.

Filtering data using the OGC Filter XML Decoding facilities samples.ogc.filter.xml.MainPanel

This applet demonstrates the ability to filter GML data using the OGC Filter XML decoding and evaluation facilities.

It displays all the countries of the world and the same data, with a filter applied in another layer.

Instructions

Enter a filter manually in the text area at the bottom or click the load button to load a predefined filter from the list.

Click the apply button to apply the filter to the countries layer. The filtered layer will display all countries that pass the filter.

Double-click on a country in order to view its related features and compare them to the filter.

Command-line sample Tiling Engine samples.fusion.engine.Fuser

This is a command-line sample. Click More info for run instructions.

This command-line sample demonstrates how to fuse a single coverage from one or more input data sources. It illustrates both basic and advanced usage of the fusion engine. It has extension points that allow subclasses to customize it further. It can be used as a stand-alone command-line fusion tool in scripts. Because of 32-bit VM restrictions, it uses a default maximum heap of 768 MB (-Xmx768m), which may be too limited to fuse large data sets such as the NOAA ENCs. For a 64-bit VM, you may want set this to higher value in the sample's startup script, for example -Xmx1500m.

Run the sample using the shell script in the samples folder:

Instructions

For a detailed list of command-line options, run the sample without arguments.

The minimal arguments are the input data source(s) and the target Tile Store URI:

  • "-s:<source>" The input data source(s), which may be a single file or a directory.
  • "-t:<target-tile-store>" The target Tile Store, which may be a local directory ("file:" URI) or a remote Tile Store ("http:" URI).

For example, "fusion.engine.sh -s:/my/input/data/sources -t:http://my.server:8081/LuciadFusion/lts" will create a coverage using all the input data found in /my/input/data/sources . The coverage and assets will have a generated UUID as ID, and no name.

Typically, you want to specify some options for assets and coverage. Options for assets start with "-a:" , options for the coverage start with "-c:" . For example, "fusion.engine.sh -s[0]:/my/input/data/background.tif" -s[1]:/my/input/data/california.jp2 -a[0]:id:background.tif -a[1]:id:california.jp2 -c:id:california will create a coverage "california" from two input data sources. The indexes determine the order: "california.jp2" will be on top of "background.tif".

When you use this sample in a script, for example to regularly re-fuse a specific coverage, you may want to consider the "-overwrite" option. Without it, fusion would resume from checkpoint if a previous fusion was unfinished, or do nothing if a previous fusion was finished.

Command-line sample Tiling Engine with custom ArcInfo ASCII Grid format samples.fusion.engine.format.Fuser

This is a command-line sample. Click More info for run instructions.

This command-line sample demonstrates how to plug in a custom raster format into the fusion engine. It illustrates how support for ArcInfo ASCII Grid can be added by extending the fusion.engine sample.

Run the sample using the shell script in the samples folder:

Instructions

For a detailed list of command-line options, run the sample without arguments. See also the fusion.engine sample for detailed instructions.

The minimal arguments are the input data source(s) and the target Tile Store URI:

  • "-s:<source>" The input data source(s), which may be a single file or a directory.
  • "-t:<target-tile-store>" The target Tile Store, which may be a local directory ("file:" URI) or a remote Tile Store ("http:" URI).

For example, "fusion.engine.sh -s:/my/input/data/sources.asc -t:http://my.server:8081/LuciadFusion/lts" will create a coverage using all the input data found in /my/input/data/sources . The coverage and assets will have a generated UUID as ID, and no name.

Command-line sample Point Cloud Pre-processor samples.fusion.pointcloud.PointCloudPreprocessorTool

This is a command-line sample. Click More info for run instructions.

This command-line sample demonstrates how to pre-process one or more input files into a single point cloud. It illustrates both basic usage of the pre-processor. It can be used as a stand-alone command-line tool in scripts. Because of 32-bit VM restrictions, it uses a default maximum heap of 768 MB (-Xmx768m), which may be too limited to process large data sets. For a 64-bit VM, you may want set this to higher value in the sample's startup script, for example -Xmx2g.

Run the sample using the shell script in the samples folder:

Instructions

For a detailed list of command-line options, run the sample without arguments.

The minimal arguments are the input data source(s) and the target path:

  • "--input=<source>" The input source, which may be a single file or a directory.
  • "--output=<target>" The target directory, which will be created if necessary.

For example, "fusion.pointcloud.sh --input=/my/input/data/sources --target=/my/output/pointcloud" will create a point cloud store using all the input data found in /my/input/data/sources .

The output of this process can be imported into LuciadFusion Studio by adding the entire output directory as a "Data Root". Once the data root is crawled, you should be able to see a new data entry that represents the preprocesed dataset in your "Data" tab. To serve it, create a new Service using this dataset, and set the service type to "OGC 3D Tiles".

The preprocessed output can also be opened directly in a Lightspeed-based client such as Lucy. To do this, open the "tileset.json" found in the root of the output directory.

When you use this sample in a script, for example to regularly re-fuse a specific coverage, you may want to consider removing the target directory first. Without this, the preprocessor would add data from the input sources to the existing point cloud, or do nothing if all of the input sources were already to the point cloud previously.

Exporting data to GML31 samples.encoder.gml3.Main

This is a command-line sample. Click More info for run instructions.

This sample illustrates how to data in SHP, MIF or MAP formats can be transformed and exported as GML31 data.

Run the sample using the shell script in the samples folder:

These are the parameters to pass:

  • gmlSchema: the location of the GML schema to be encoded in the xsi:schemaLocations attribute
  • xmlSchema: the location of the XML-SCHEMA schema to be encoded in the xsi:schemaLocations attribute
  • namespace: the target namespace, if none is available.
  • vectorFile: the name of a vector file that is to be converted
  • resultFile: the name of the output file

Transforming data to and from GML samples.transformation.gml.GMLTransformationDemo

This is a command-line sample. Click More info for run instructions.

This sample uses the FlightPlan data model from the LuciadLightspeed fundamentals as source model. It shows how this data model can be transformed into a GML data model. It shows how the GML application schema can be generated. It then encodes a model containing flight plans as a GML document. Then this document is decoded back into a model containing flight plans.

Run the sample using the shell script in the samples folder:

GXY: displaying KML data samples.decoder.kml22.gxy.MainPanel

This sample demonstrates how to load and display KML data on a map.

Instructions

The sample will automatically load a basic KML file containing most KML features, and fit the map on the data.

The model content tree next to the map is a tree-based structure showing the contents of all KML files that are currently displayed on the map.

Objects can be selected either via the map or via the model content tree. When an object is selected a balloon will pop-up, displaying additional information on the object.

The sample will automatically resolve network links in KML files, and refresh the model contents if a refresh mode is specified in the link.

When KML files containing time information (timestamp, timespan) are loaded, a time toolbar will become visible, showing the time interval for which data is available. The time slider can be used to control which data should be shown on the map.

Lightspeed: displaying KML data samples.decoder.kml22.lightspeed.MainPanel

This sample demonstrates how to load and display KML data on a map.

Instructions

The sample will automatically load two KML files:

  • a file containing Collada data, representing the town hall of Leuven.
  • a basic KML file containing most KML features.

The model content tree next to the map is a tree-based structure showing the contents of all KML files that are currently displayed on the map.

Objects can be selected either via the map or via the model content tree. When an object is selected a balloon will pop-up, displaying additional information on the object.

The sample will automatically resolve network links in KML files, and refresh the model contents if a refresh mode is specified in the link.

When KML files containing time information (timestamp, timespan) are loaded, a time toolbar will become visible, showing the time interval for which data is available. The time slider can be used to control which data should be shown on the map.

Convert models into KML models and save them into KML files samples.encoder.kml22.KMLConverter

This is a command-line sample. Click More info for run instructions.

This sample demonstrates how to convert models into KML. The KML format is particularly useful for sharing a situational map with a broader set of stakeholders, who do not necessarily have access to LuciadLightspeed, but can open KML data in other map visualization tools. LuciadLightspeed allows you to convert map data into KML. This sample illustrates one way to convert vector data into KML and customize the conversion. It gives you full control of the style and the geometry information that will be converted in the KML model. The model encoder TLcdKML22ModelEncoder can then export the KML model.

Run the sample using the shell script in the samples folder:

Run the sample to convert the files and the in-memory model into KML. The three new KML files are located in the Kml directory inside the data resources folder for the samples. You can visualize the KML files in the general decoder samples, the KML decoder samples, or any KML visualization tool.

First, the KML encoding sample decodes a SHP file representing tracks, and converts a subset of the tracks into a KML model. The KML model is then encoded in a file. Another SHP file representing the USA states is also decoded, and some states are encoded in KML. Next, the sample creates an in-memory model of airspaces. Each airspace is an extruded shape with a circle or a polygon as its base shape. The airspace model is also converted into KML and encoded.

Lightspeed: Lidar visualization samples.lightspeed.lidar.MainPanel

This sample illustrates how Lidar data from .las files can be visualized in a Lightspeed view.

With this sample, you can open one or more .las files and apply different styling.

The following styling options are available if at least one layer supports it:

  • Color: uses the color information available in the file.
  • Height: shows a color gradient over the combined height range of all layers.
  • Classification: shows a different color per class.
  • Intensity: shows greyscale gradient based on the intensity available in the file.
  • Infrared: shows a color gradient based on the infrared information available in the file.

Additionally, a shading technique to enhance depth perception is enabled by default. Using the controls in the panel, the settings can be changed:

  • Enhance: the checkbox enables or disables the shading technique
  • The thickness slider alters the thickness of the applied shade
  • The strength slider alters the strength of the applied shade
  • The color chooser changes the color of the applied shade
Instructions

Open .las files using the "Open File" icon, or by dragging files onto the sample.

Change the styling and filtering using the panel on the right. The styling will be applied to the layers that support it. Layers that don't support it use Height styling.

Change the depth perception settings using the panel on the right. The settings will be applied to all layers.

GXY: Clustering samples.gxy.clustering.MainPanel

This sample demonstrates how to introduce clustering in a GXY application using TLcdTransformingModelFactory and TLcdClusteringTransformer .

The sample contains a large number of recorded humanitarian events in Africa. When a number of events are close together (in view-space), they become hard to distinguish. Therefore a cluster is shown instead of the individual events.

This sample uses two different clustering strategies:

  • When zoomed in, only events happening in the same country will be clustered together (if needed). Clusters will never contain events happening in different countries. This is achieved by specifying an ILcdClassifier on the transformer.
  • When zoomed out, all events are considered for clustering, even when they happened in different countries.

This scale-dependent clustering behavior is created by calling the TLcdClusteringTransformer.createScaleDependent method.

Instructions

Navigate around the map and see the clusters update when necessary.

GXY: Asynchronous layer painting using Lightspeed samples.gxy.concurrent.painting.lightspeed.MainPanel

This sample demonstrates the ability to paint asynchronously in an ILcdGXYView using a Lightspeed layer. This can be useful when you cannot use a Lightspeed view, but you do want to speed up rendering in your ILcdGXYView , for example when painting many objects or complex visualizations such as line-of-sight visualization.

The sample shows how to instantiate an asynchronously painted layer that handles the actual painting. The layer is then painted in the background, in a separate thread, so the painting no longer blocks the user interface.

It also illustrates how to automatically assign paint queues to the asynchronous layers by using a paint queue manager. The paint queue manager used in this sample minimizes the number of paint queues, but never lets Lightspeed layers share their queues with other types of asynchronous layers. The paint queue assignments can be seen in the layer tree: layers sharing a paint queue have the same color.

Instructions

Try panning and zooming with the mouse wheel. New layer contents are added after the operations. The Translucent checkbox renders all content translucent. This demonstrates how to modify the state of the Lightspeed layer.

Lightspeed: Balloon samples.lightspeed.balloon.MainPanel

This sample demonstrates how to display balloons in an ILspView using TLspBalloonManager .

The sample generates four icons, each of which contains a balloon. A balloon is made visible when a single object is selected. The balloon contains an icon and an editable text field containing the position of the icon in geodetic coordinates.

For a more extensive description of the balloon manager API see the developers' guide.

Instructions

Select one of the icons. A balloon will appear. Editing the coordinate panel in the balloon and hitting return will change the location of the icon. The balloon arrow also gets relocated with this operation. Balloons are only shown when one domain object is selected.

Lightspeed: Clustering samples.lightspeed.clustering.MainPanel

This sample demonstrates how to introduce clustering in a Lightspeed application using TLcdTransformingModelFactory and TLcdClusteringTransformer .

The sample contains a large number of recorded humanitarian events in Africa. When a number of events are close together (in view-space), they become hard to distinguish. Therefore a cluster is shown instead of the individual events. Selecting a cluster also selects and displays its contained elements.

This sample uses two different clustering strategies:

  • When zoomed in, only events happening in the same country will be clustered together (if needed). Clusters will never contain events happening in different countries. This is achieved by specifying an ILcdClassifier on the transformer.
  • When zoomed out, all events are considered for clustering, even when they happened in different countries.

This scale-dependent clustering behavior is created by calling the TLcdClusteringTransformer.createScaleDependent method.

Instructions

Navigate around the map and see the clusters update when necessary. A cluster's contained elements can be displayed by selecting it. Moving a cluster also moves the contained elements.

Lightspeed: Custom Controller samples.lightspeed.customization.controller.MainPanel

This sample demonstrates how to implement and use a custom controller. The first controller (active by default) shows an information panel when hovering over an object. The second controller allows you to navigate using arrow and other keys.

Instructions

When using the first controller, use the mouse to hover over some of the counties in the USA and an information panel will pop-up with some information about the county. When using the second controller, the following keys can be used:

  • arrow keys: pan the view left, up, right and down.
  • Home and End: zoom in and out.
  • Insert and Delete: rotate yaw left and right.
  • Page Up and Page Down: rotate pitch forward and backward (only 3D).
  • F: toggle full screen mode.

Lightspeed: Hippodrome samples.lightspeed.customization.hippodrome.MainPanel

This sample demonstrates how to add support for painting and editing a custom shape: the hippodrome. The hippodrome consists of two 180 degrees arcs and two lines connecting these arcs and at a given distance from the line between the center points (width).

Please refer to the documented sample code and the developer's guide for more information.

Instructions
  • Select a hippodrome to start editing it.
  • Move one of the hippodrome points by dragging the mouse starting from a point.
  • Move the whole hippodrome by dragging the mouse starting from the shape itself.
  • Change the width of the hippodrome by dragging the mouse starting from the outline of the shape.
  • Create a new geodetic- or grid hippodrome by selecting the corresponding create controller in the toolbar and by clicking three times for a regular hippodrome and four times for creating an extruded hippodrome in 3D. The first two clicks define the start and end points. The third click defines the width. The optional fourth click defines the maximal altitude of the extruded hippodrome.

Lightspeed: Using custom paint representations samples.lightspeed.customization.paintrepresentation.MainPanel

This sample is an adaptation of the Editing sample (which illustrates the editing and creation capabilities of the editors that are available in the Lightspeed API).

The Shapes layer in this sample has a regular shape painter ( TLspShapePainter ) to paint the shapes' bodies. In addition, this sample adds another shape painter with a different styler that is identified by a custom paint representation. This special styler provides the painter with the bounds of the shape as opposed to the shape itself. Hence, each shape is painted twice: once using its own geometry and once using the bounds geometry.

For more detailed information on how to create an application which uses custom paint representations, see the developer's guide or the documented source code of this sample.

Instructions

Try editing and creating new shapes and notice how both paint representations (the shape itself and its bounds) are painted and updated.

Lightspeed: Animated style samples.lightspeed.customization.style.animated.MainPanel

This sample demostrates how LuciadLightspeed's animation framework can be used to animate the style of an object. The animation is implemented in AnimatedAreaStyler, a custom ILspStyler implementation which uses an ILcdAnimation to update style properties and fire style change events when needed.

Instructions

When the sample is started, the style of one of the countries should automatically be animated.

Lightspeed: Styling editing handles samples.lightspeed.customization.style.handles.MainPanel

This sample illustrates how to customize the visualization of editing handles using some custom stylers. This sample uses two stylers to:

Instructions

Select an ellipse in the sample. This should activate editing on that shape, and you should see the following customizations:

Lightspeed: Highlighting samples.lightspeed.customization.style.highlighting.MainPanel

This sample demonstrates how LuciadLightspeed's animation and style frameworks can be used to highlight and show custom animations for the object under the cursor.

The sample consists of a layer containing shapes for each country. When the mouse is moved over a country, a pie chart appears showing the demographic distribution in that country.

This layer has two stylers:

  • An AnimatedHighlightAreaShapeStyler which takes care of the styling of the countries/pie charts themselves ( fill/line colors )
  • An AnimatedHighlightAreaLabelStyler which takes care of the styling of the labels of the countries/pie charts

The pie charts are created and styled by passing their style and geometry to a ALspStyleCollector along with the object to which they belong.

Instructions

Move your cursor over the different countries of the world. When the cursor is on top of a country, a pie chart will gradually rise and display population statistics specific of that country. When the cursor moves away from the highlighted country, the pie chart for that country will gradually vanish.

Lightspeed: Thematic mapping samples.lightspeed.customization.style.thematic.MainPanel

This sample demonstrates how to implement "thematic mapping", i.e. to adjust the style of an object to that object's attributes.

The sample consists of a layer of country shapes on which custom colors are being styled. The colors for the countries are linearly interpolated between a minimum color and a maximum color chosen by the user, with the population of each country as a weight for the interpolation. More populated areas will therefore tend towards the maximum color, while less populated areas will tend towards the minimum color. This styling is accomplished by using a custom styler implementation, namely a samples.lightspeed.customization.style.thematic.CountryStyler

Instructions

Click on either the left or right gradient button on the toolbar to set the lowest or highest population color respectively. You will notice that the color of the countries is an interpolated value between those two colors, based on their population.

Data Model Tree Sample samples.lightspeed.datamodel.MainPanel

This sample adds functionality to view the TLcdDataModel of an ILcdModel that has an ILcdDataModelDescriptor as a model descriptor.

The 'Data Model Tree' is visible on start-up, showing the data model tree for the currently selected layer.

The data model tree contains all declared TLcdDataType instances of the TLcdDataModel. Each TLcdDataType contains a series of properties and TLcdDataProperties.

All TLcdDataTypes that are also model element TLcdDataType instances are highlighted in a special color.

Note that TLcdDataModel instances can define data types that are cyclical. There is no explicit check for this issue in the sample code, as it was not needed for this special case.

Instructions

Open some random files and see how the data model tree gets updated each time you select a new layer which has an ILcdModelDescriptor as model descriptor on its model.

Lightspeed: Day/night Map samples.lightspeed.daynight.MainPanel

This sample shows how to create a day/night map in a Lightspeed view. The areas in civil/nautical/astronomical twilight and night are drawn in progressively darker shades. An icon on the map indicates the point where the sun is directly overhead. The day/night map animates in fast time over a period of 1 year.

The day/night map is constructed as follows:

  1. Find the point on the Earth where the sun is directly overhead.
  2. On the opposite side of the globe, construct a set of concentric circles to represent the night and twilight areas.
  3. Fill these circles with a dark translucent color.
Instructions

The sample automatically shows an animated day/night map. A label on the top edge of the map shows the current date and time of the map.

Lightspeed: Hardware capability report samples.lightspeed.debug.report.MainPanel

The hardware capability report sample generates a detailed list of the hardware related capabilities of the device running the sample. The sample generates a hardware report with the OpenGL and OpenCL capabilities of the system using the com.luciad.view.lightspeed.util.TLspPlatformInfo utility class. Reported capabilities include:

  • OS information
  • OpenGL basic information (vendor, renderer, version)
  • OpenGL available extensions
  • OpenGL state variables
  • OpenCL basic information (vendor, version, . )
  • OpenCL available extensions
  • OpenCL device info
Instructions

When contacting Luciad support about any Lightspeed-related problems, it is always appreciated if you include the report generated by this sample.

Lightspeed: Decoding multiple format data samples.lightspeed.decoder.MainPanel

This sample demonstrates the ability to load and visualize data from sources in different formats on a Lightspeed map using ILcdModelDecoder and ILspLayerFactory .

A File and a URL action are configured to load data in almost every available format.

The sample uses a composite ILcdModelDecoder to decode the data into an ILcdModel . After this, a composite ILspLayerFactory creates a layer that controls how the model of the loaded data is displayed. The model decoders and layer factories are retrieved using a service look-up mechanism, and contain both built-in and sample implementations.

The toolbar includes several controllers to visually compare layers.

Instructions

Add new data by pressing the appropriate toolbar button or by dragging and dropping files or URLs on the map. Not all styled LuciadLightspeed formats have a dedicated Lightspeed layer factory (an example of this is DGN), in which case a fallback layer factory is used. As a result, the visualization of some data might not be correctly styled.

The toolbar allows selecting the following visual inspection controllers:

  • The swipe controller: Select two sets of layers. Drag the swipe line horizontally or vertically to inspect differences between the two sets along the line.
  • The flicker controller: Select two layers. Quickly click the mouse to toggle between the two layers.
  • The porthole controller: Select two sets of layers and move your mouse over the map. The first set of layers is visible by default. The second set is shown in a rectangular area around the mouse location. Holding down the shift key and moving the mouse wheel resizes the porthole.
  • The magnifier controller: a square area around the mouse location shows a zoomed in view of the visible layers. In the magnifier overlay, view-sized items still have the same size while world-sized items are scaled to respect the zoom-factor of the magnifier. Holding down the shift key and moving the mouse wheel changes the zoom factor of the magnifier. Holding down the control key and moving the mouse wheel resizes the magnifier overlay.

Lightspeed: Editing geometric shapes samples.lightspeed.editing.MainPanel

This sample illustrates the editing and creation capabilities of the editors that are available in the Lightspeed API. The sample contains one shape layer for both editing and creation. Shape creation is performed using TLspCreateController. Shape editing is performed using TLspEditController.

Consult the developer's guide or the documented source code of this sample for detailed information on how to create an application that uses Lightspeed editors.

Instructions

To edit one of the shapes, click on the shape and interact with one of its edit handles. Please refer to the javadoc of the different editor classes in the com.luciad.view.lightspeed.editor package to see what functionality is provided by each of the handles.

To create a new shape, activate one of the create controllers in the toolbar. Most of the controllers also have an extruded creation variant. This variant creates an extruded shape with the base shape that is created by the normal editor. For instance, the ellipse create controller creates an extruded ellipse when extrusion is activated. Extrusion can be activated by the extrusion button in the creation toolbar.

For most shapes creation is simply performed by a sequence of mouse clicks or taps. Some additional instructions for special cases:

  • Polylines and polygons: End creation by right or double clicking.
  • Complex polygons: Advance to the next polygon by right clicking. Finalize the creation process by double clicking.
  • Complex rings and curves: Advance to the next shape by right clicking. Change the shape type using one of the buttons that appear in the view.
  • Extruded polylines and polygons: End creation of the base shape by right clicking.

When creating or editing shapes you can disable snapping by pressing the control key (cmd on macOS). Insert or remove a point from a polyline or polygon by holding down the control key (cmd on macOS) while pressing. Select multiple shapes by holding the shift while pressing. Use the delete key to remove selected shapes.

Lightspeed: Geoid samples.lightspeed.geoid.MainPanel

This sample visualizes the EGM2008 geoid in 3D. The geoid heights are exaggerated they actually vary between -110m and +90m. Blue colors indicate that the geoid heights are negative (geoid below the ellipsoid of the WGS84 datum). Green colors indicate that the geoid heights are positive (geoid above the ellipsoid).

Geoid heights are typically used behind the screens, in calculations with references that have geodetic datums based on geoids. They are relevant for elevation data, for instance, which are commonly defined with respect to a few standardized geoid models. For accurate computations, elevations above a geoid can then be transformed to elevations above an ellipsoid.

The geoid heights are retrieved from the geodetic datum that is created by the TLcdGeoidGeodeticDatumFactory.

Instructions

Lightspeed: Grids samples.lightspeed.grid.MainPanel

This sample demonstrates the longitude/latitude, MGRS, Georef and XY grid layers, and how to change the text and line styles.

Instructions

For the longitude/latitude grid, you can change the following styling options:

  • Parallels: changes the color of all parallels
  • Equator: changes the color the equator specifically
  • Meridians: changes the color of all meridians
  • Prime Meridian: changes the color of the prime meridian specifically
  • Coordinate format: changes the way degrees are formatted (using decimals or minutes)
  • Positioning: changes the position of the labels (above, below or on the grid line)
  • Spacing: changes the spacing of the grid lines (default or coarse)

For the MGRS grid, you can change the following styling options:

  • Primary: changes the color of the most common lines
  • Secondary: changes the color of the second-most common lines
  • Tertiary: changes the color of the third-most common lines
  • Spacing: changes the spacing of the grid lines (default or coarse)

For the Georef grid, you can change the following styling options:

  • Primary: changes the color of the most common lines
  • Secondary: changes the color of the second-most common lines
  • Tertiary: changes the color of the third-most common lines
  • Spacing: changes the spacing of the grid lines (default or coarse)

For the XY grid, you can change the following styling options:

  • Primary: changes the color of the most common lines
  • Secondary: changes the color of the second-most common lines
  • Tertiary: changes the color of the third-most common lines
  • Spacing: changes the spacing of the grid lines (default or coarse)

Lightspeed: 3D icons samples.lightspeed.icons3d.MainPanel

This sample demonstrates how to visualize point data using 3D icons. Icons can be loaded from files in either Collada, OpenFlight or WaveFront OBJ format.

Instructions

The sample shows animated 3D points. At startup, they are displayed using an airplane icon. Use the "open" button on the toolbar to load a .DAE, .OBJ or .FLT file. Doing so will replace the airplane model.

Lightspeed: Image Projection samples.lightspeed.imageprojection.MainPanel

This sample demonstrates how to project images on terrain.

Instructions

The sample shows an image being projected on terrain by an animated plane. Notice how the projected image deforms when projected on the terrain. The white lines indicate the projection frustum. This frustum can be toggled on or off in the layer pane.

Lightspeed: Multispectral image visualization samples.lightspeed.imaging.multispectral.MainPanel

This sample illustrates how multispectral raster imagery can be visualized and analyzed in an ILspView.

The sample starts with pre-loaded satellite image files covering the region of Las Vegas. The images are obtained from the LandSat7 USGS archive. They are multi-spectral GeoTIFF files that consist of 7 bands. The sample also allows you to load other GeoTIFF files from disk.

The panel below the layer controls demonstrates the LuciadLightspeed imaging operators and filters, and allows you to configure how the image in the selected layer is displayed. You can adjust brightness, contrast, opacity, and apply a sharpening filter using the sliders.

You can also choose which of the 7 image bands are displayed, and to which color channel they are mapped. To display the pre-loaded images in the the LandSat7 natural color preset for instance, select the bands 3, 2 and 1 in the Red, Green and Blue drop-down menus respectively. Other interesting band combinations that highlight specific aspects of the image data are 4-3-2, to display the near infrared (NIR) data, and 7-4-2 to display short-wavelength infrared (SWIR) data. The band combination 7-4-2 displays vegetation in bright shades of green, for instance.

The Curves panel displays the data distribution of the displayed image bands in a histogram. You can adjust the dynamic range for the bands in each color channel by manipulating the line displayed on top of the histogram into a curve. You can also enhance the image contrast automatically by applying the Equalization function on the Luminance tab.

The toolbar allows selecting a swipe and flicker controller to visually compare layers.The swipe controller displays a swipe line that can be dragged horizontally or vertically, displaying only half of the first set of layers on the left or top side, and half of the other set of layers on the other side. The flicker controller allows to quickly toggle between multiple layer sets by clicking the mouse. See the documentation of TLspSwipeController and TLspFlickerController for more info.

The sample makes use of TLspImageFilterStyle and the ALcdImageOperator API to perform the band selection and dynamic range adjustments.

Instructions

Load additional files with drag and drop, or by clicking the Open button on the toolbar. When you select the resulting layer in the layer control panel, three additional panels appear below the layer controls.

In the General panel, you can apply several image filters to the selected raster layer. Use the sliders to adapt the image contrast, brightness, opacity and sharpness.Click Reset to return to the default filter settings.

The Visible bands panel allows you to choose which image bands are made visible, and in which color. The drop-down menus next to the Red, Green and Blue color channels contain a list of the image bands present in the selected raster layer. To map an image band to a particular color channel, select the band number from the drop-down menu next to the preferred color.
To see just one band in grayscale, click the grayscale icon and select a band from the drop-down menu.

The Curves panel consists of four tabs. The Red, Green and Blue tabs displays a histogram and a tone curve for the color-mapped bands of the loaded image. To see the histogram and tone curve for a particular band, select the tab with the color to which you mapped the band. To change the tone curve in a particular color channel, select the line on the histogram, and drag its control points until it forms a curve, and your image displays the required color balance. You can add or delete points on the selected curve by ctrl-clicking. The Luminance tab displays a histogram and curve for the brightness of the image. You can manipulate the tone curve to improve the contrast in the image. To enhance image contrast automatically, click Equalize. As a result, the contrast will be stretched automatically, and the curve will change.
To reset curves to their original settings, click Reset.

To visually compare layers, select the swipe controller from the toolbar. Compare for example the Las Vegas image from 2000 and 2003. By dragging the swipe line you should be able to easily see the differences between the two image files. Enable the flicker controller from the toolbar and select the two Las Vegas image files. Quickly click the mouse to toggle between the two layers.

Lightspeed: ILcdGXYLayer integration samples.lightspeed.integration.gxy.MainPanel

This sample demonstrates how to visualize and interact with ILcdGXYLayer instances in a Lightspeed view. This is achieved using TLspGXYLayerAdapter , which renders a GXY layer into an off-screen ILcdGXYView and then draws the resulting image into the Lightspeed view. The TLspGXYLayerTreeNodeAdapter can be used to display whole trees of GXY layers.

Instructions

The sample shows a map with an adapted raster and vector layer. Try panning and zooming with the mouse wheel. You'll notice that the GXY content is rendered asynchronously.

Lightspeed (JavaFX): Balloon samples.lightspeed.javafx.balloon.Main

This sample demonstrates how to display balloons in a TLspFXView using TLspFXBalloonManager .
This sample requires JavaFX. Depending on the JDK you are using, you may need to install it separately. Refer to the technical notes in the documentation for more information.

The sample shows two points on the map, each of which is tied to a balloon. A balloon is made visible when a single object is selected. The balloon contains an editable text field containing the position of the icon in geodetic coordinates.

For a more extensive description of the balloon manager API see the developers' guide.

Instructions

Select one of the icons. A balloon will appear. Editing the coordinate panel in the balloon and hitting return will change the location of the icon. The balloon arrow also gets relocated with this operation. Balloons are only shown when one domain object is selected.

Lightspeed (JavaFX): Decoding multiple format data samples.lightspeed.javafx.decoder.Main

This sample demonstrates the ability to load and visualize data from sources in different formats on a Lightspeed JavaFX map using ILcdModelDecoder and ILspLayerFactory .
This sample requires JavaFX. Depending on the JDK you are using, you may need to install it separately. Refer to the technical notes in the documentation for more information.

A file and a URL action are configured to load data in almost every available format.

The sample uses a composite ILcdModelDecoder to decode the data into an ILcdModel . After this, a composite ILspLayerFactory creates a layer that controls how the model of the loaded data is displayed. The model decoders and layer factories are retrieved using a service look-up mechanism, and contain both built-in and sample implementations.

Instructions

Add new data by pressing the appropriate toolbar button or by dragging and dropping files or URLs on the map. Not all styled LuciadLightspeed formats have a dedicated Lightspeed layer factory (an example of this is DGN), in which case a fallback layer factory is used. As a result, the visualization of some data might not be correctly styled.

Lightspeed (JavaFX): Editing geometric shapes samples.lightspeed.javafx.editing.Main

This sample illustrates the editing and creation capabilities of the editors that are available in the Lightspeed API.
This sample requires JavaFX. Depending on the JDK you are using, you may need to install it separately. Refer to the technical notes in the documentation for more information.

The sample contains one shape layer for both editing and creation. Shape creation is performed using TLspCreateController. Shape editing is performed using TLspEditController.

Consult the developer's guide or the documented source code of this sample for detailed information on how to create an application that uses Lightspeed editors.

Instructions

To edit one of the shapes, click on the shape and interact with one of its edit handles. Please refer to the javadoc of the different editor classes in the com.luciad.view.lightspeed.editor package to see what functionality is provided by each of the handles.

To create a new shape, activate one of the create controllers in the toolbar. Most of the controllers also have an extruded creation variant. This variant creates an extruded shape with the base shape that is created by the normal editor. For instance, the ellipse create controller creates an extruded ellipse when extrusion is activated. Extrusion can be activated by the extrusion button in the creation toolbar.

For most shapes creation is simply performed by a sequence of mouse clicks or taps. Some additional instructions for special cases:

  • Polylines and polygons: End creation by right or double clicking.
  • Complex polygons: Advance to the next polygon by right clicking. Finalize the creation process by double clicking.
  • Complex rings and curves: Advance to the next shape by right clicking. Change the shape type using one of the buttons that appear in the view.
  • Extruded polylines and polygons: End creation of the base shape by right clicking.

When creating or editing shapes you can disable snapping by pressing the control key (cmd on macOS). Insert or remove a point from a polyline or polygon by holding down the control key (cmd on macOS) while pressing. Select multiple shapes by holding the shift while pressing. Use the delete key to remove selected shapes.

Lightspeed: JavaFX touch editing samples.lightspeed.javafx.touch.Main

This sample demonstrates how to add touch support into a JavaFX application.
This sample requires JavaFX. Depending on the JDK you are using, you may need to install it separately. Refer to the technical notes in the documentation for more information.

The sample features large buttons to allow easy manipulation with fingers instead of a mouse as input device.

Instructions

Use one finger to pan around and to select or edit objects. Use two fingers to zoom or rotate.

To edit one of the shapes, you just have to touch the shape and interact with one of its editing handles. Please refer to the javadoc of the different editor classes in the API to see what functionality is provided by each of the handles.

To create a new shape, activate one of the create controllers in the toolbar. Note that most of the controllers also have an extruded creation variant. This variant creates an extruded shape with the base shape that is created by the normal editor. For instance, the ellipse create controller creates an extruded ellipse when extrusion is activated. Extrusion can be activated by the extrusion button in the creation toolbar (third button).

Some shapes like polylines, polygons, and complex polygons have different (dynamic) creation steps that can be ended by pressing the Commit button. For example, to create a complex polygon containing two triangular shapes, the sequence of interactions should be: tap-tap-tap, commit (to end first polygon), tap-tap-tap, commit (to end second polygon), commit (to end complex polygon creation).

Lightspeed: Interactive labels samples.lightspeed.labels.interactive.MainPanel

This sample demonstrates how labels can be made editable. The labels are editable in the sense that they can be moved to a new location, as well as in the sense that they offer the user an interactive component that can be used to edit information related to the domain objects.

Instructions

Move the mouse over a label of a city. An interactive, editable label will be shown instead of the regular label. You can enter a comment for the labeled city in the text field. To apply the changes, press the Enter key or press the green tick mark at the top of the interactive label. To cancel the outstanding changes, press the red 'cancel' icon at the top of the label or press the Escape key.

The interactive label can be moved by clicking and dragging on the title bar of the interactive label.

Lightspeed: Label placement samples.lightspeed.labels.placement.MainPanel

This sample demonstrates various labeling algorithms:

  • TLspLabelingAlgorithm, for labeling cities
  • TLspInPathLabelingAlgorithm, for labeling states
  • TLspCurvedPathLabelingAlgorithm, for labeling rivers

Note that the river's springs are determined as the first point of the first polyline, which may not correspond to reality.

Instructions

To see the effects of the labeling algorithms select a layer, by clicking it in the layer control and:

  • change the layer's visibility
  • set the layer labeled/not labeled
  • move the layer up/down: labeling is started from the topmost layer

To modify the label styling, drag the opacity slider, or change the font using the Font combobox.

Lightspeed: Lightweight views samples.lightspeed.lightweight.MainPanel

This sample demonstrates how Swing components can be overlaid on an ILspView. Specifically, the sample shows a JInternalFrame which contains a secondary map view, alongside with navigation controls for the main view.

To avoid issues with the mixing of lightweight and heavyweight components, the sample uses TLspSwingView rather than TLspAWTView. A JLayeredPane is added to the main view. Within this layered pane, one layer is a JDesktopPane containing the internal frame with the second view. Another layer contains the standard navigation controls and scale indicator for the main view (as can also be seen in other samples).

Instructions

Move, resize, minimize and maximize the internal frame. Observe how it sits between the main view and its overlaid navigation controls.

Lightspeed: Constrained navigation samples.lightspeed.limitnavigation.MainPanel

This sample demonstrates how the view-world transformation can be customized in order to constrain the navigation freedom. This behavior can be enabled or disabled using a checkbox in the toolbar.

Instructions

Take note of the checkbox labeled "Limit Navigation" in the upper right corner of the screen, by default it is checked. As long as this checkbox is checked your navigational options are constrained:

  • Rotate the view, notice how this has no effect. The view is automatically rotated to keep the north at the top of the screen.
  • Zoom in and out, notice how you can only zoom out to a certain degree and how you can only zoom in to a certain degree and only to a certain area marked by the red rectangle.
  • Pan and navigate around the view, notice how you can only pan to the boundaries of the area marked by the red rectangle.

Uncheck the "Limit Navigation" checkbox and retry panning, zooming and rotating the view and notice the difference with the constrained version of these behaviors.

Lightspeed: Map Overview samples.lightspeed.mapoverview.MainPanel

This sample shows how a map overview can be implemented for an ILspView. The map overview is overlaid on the main view. It shows a polygon which bounds the area of the world that is visible in the main view.

The map overview is itself a TLspSwingView, which is added to the main view's overlay panel. The polygon which bounds the visible map area is obtained using ALspViewXYZWorldTransformation.getGeodeticVisibleArea(). The map overview continuously fits to this polygon.

Instructions

Navigate in the main view. Switch between 3D and the various 2D projections. Observe how the map overview updates continuously and how the polygon in the map overview corresponds to the area of the world that can be seen in the main view.

Lightspeed: Encode shape as JSON mesh samples.lightspeed.meshencoder.MainPanel

This sample demonstrates how 3D shapes in LuciadLightspeed can be discretized and saved as 3D meshes in a custom file format.

The intent of this sample is to show you how to export 3D shapes from LuciadLightspeed as 3D meshes for re-use in a LuciadRIA client. The produced JSON file can easily be parsed by the LuciadRIA MeshFactory.

Instructions

To save a 3D shape as a JSON mesh-file, select a shape in the view, and press the save button in the toolbar.

Lightspeed: Navigation controls samples.lightspeed.navigationcontrols.MainPanel

This sample demonstrates how to use TLspNavigationControlsFactory to create Swing-based controls for view navigation and overlay these controls on a view.

The default navigation controls are as usual visible in the top right corner. A secondary set of controls is added to the left side of the view. The distinct components are the same but they are separated and added in different corners and they always appear active. The compass navigation control on the left side points towards the magnetic north instead of the real north.

Instructions

Use the secondary set of navigation controls to pan, zoom and rotate the view.

Lightspeed: Painting data that is not geographically referenced samples.lightspeed.nongeoreferenced.MainPanel

This sample contains three layers:

  • Raster data: a GIF file of Washington DC.
  • Vector data: a number of vector shapes drawn on top of the raster.
  • XY Grid: an xy grid, including labels.
Instructions

Navigate the map. Notice how the mouse location at the bottom indicates the pixel coordinates in the image.

Select one of the shapes and edit it or create a new shape.

Lightspeed: Painting in view coordinates samples.lightspeed.paintinview.MainPanel

This sample contains two layers:

  • Screen data: a point, polygon and ellipse defined in screen coordinates. This is achieved by using a model reference that is not an ILcdGeoReference.
  • Georeferenced data: three lon-lat ellipses. For each ellipse, a pencil icon is drawn in screen coordinates, as well as a mini version of the ellipse. This is achieved by using an ALspStyleTargetProvider that returns null as its target geo reference.
Instructions

Navigate the map. Notice how the shapes at the top of the screen remain at the same position at any time.

Select one of the green shapes and edit it.

Select one of the blue ellipses. One of the icons and mini-ellipses is automatically selected as well.

Select one of the pencil icons or mini-ellipse. The corresponding ellipse is selected as well.

Edit one of the blue ellipses. The corresponding mini-ellipse is edited as well.

Lightspeed: Plot painting samples.lightspeed.plots.MainPanel

The sample loads 500.000 aircraft positions around New York.

The plots are painted with a plot layer ( TLspPlotLayerBuilder ).

At a certain scale, heading arrows are displayed, and labels that are de-cluttered using the continuous de-cluttering algorithm.

Filtering can be done through the properties of the data model.

  • Ranged properties (such as time, speed) can be filtered using the sliders
  • For properties with limited values (such as class) you can select one value from the drop-down boxes

Styling is also based on the properties of the data model.

  • For ranged properties (such as time, speed) the icon color is interpolated between red and green based on the filter sliders
  • For properties with limited values (such as class) a color or icon is automatically assigned to each possible value
Instructions

Change the filtering through the sliders and drop-down boxes. The filter is immediately effective.

Change the color and icons through the drop-down boxes. The change is immediately effective.

Enable and disable density plots through the checkbox. The change is immediately effective.

Lightspeed: Printing samples.lightspeed.printing.MainPanel

This sample demonstrates how to print a component containing a view, using the TLspViewComponentPrintable.

Instructions

The sample creates a page layout containing the view and some decorations. You can preview the page or print it directly using the buttons in the toolbar.

Lightspeed: Measurement Controller samples.lightspeed.ruler.MainPanel

This sample demonstrates how to configure the measurement controller and change different properties of it dynamically at runtime.

Instructions

It is possible to modify the following ruler settings:

  • Measure mode: Geodetic, Rhumbline or Cartesian. The latter measures cartesian distances between points in world coordinates, which is useful e.g. to measure the height of a 3D shape.
  • Color style: the color of the measurement polylines.
  • Font style: the font of the labels.
  • Distance unit: Meters, Kilometers, Feet or US Miles.
  • Display azimuth: the azimuth of the measurement segments.
  • Display Equal Distance Circles: visual aid during editing of measurements. Only supported in the Geodetic measure mode.
  • Keep Measurements: Don't delete the old measurement when starting the creation of a new one.

Lightspeed: Displaying shapes samples.lightspeed.shapes.MainPanel

This sample shows how to programmatically create and display a model. It reveals how to create an ILcdModel, how to populate it with ILcdShape objects, and how to display that data in an ILspLayer on a Lightspeed view.

For a more extensive description of each of these steps see the developers' guide.

Instructions

The sample shows a polyline, a polygon, and a point visualized by an icon. Try interacting with the shapes.

Lightspeed: Stereoscopic view samples.lightspeed.stereo.MainPanel

The sample demonstrates how to create and set up a 3d stereoscopic Lightspeed view with some background data and a 3D Collada model. The stereoscopic Lightspeed view can be used with active shutter glasses (e.g. Nvidia 3D vision glasses).

Note: A stereoscopic 3D view requires a GPU that supports quad buffering. For most GPUs this must be enabled in the driver settings.

Instructions

When the sample starts the default controls can be used to navigate.

Note: Should the eyes appear to be swapped, you can typically configure the driver to swap the eyes via the configuration panel of the driver.

Lightspeed: Editing the style of objects samples.lightspeed.style.editable.MainPanel

This sample is intended to illustrate the process of editing an object's style at runtime. It creates a setup in which a TLspEditableStyler is used to edit the styles of all the objects. To tweak the values of the provider at runtime, a widget was implemented which provides a GUI for editing the most prominent style properties (see StyleEditor and StyleEditorModel ).

Note that for simplicity, this sample focuses on editing line- and fill styles, but the concepts used in this sample can be applied to editing other styles as well.

Instructions
  1. Select an object in the view.
  2. Press the edit style button in the toolbar.
  3. In the style dialog that appears, change the desired settings.
  4. Press "OK" to apply the new settings and close the dialog (if you just want to apply the settings and keep the dialog open, press "Apply").
  • Line Width: use the spinner widget to change the line width.
  • Line Color: click on the color label to choose a different color.
  • Line Pattern: choose a different line pattern from the drop down.
  • Fill Color: click on the color label to choose a different color.
  • Fill Pattern: choose a different fill pattern from the drop down.

Lightspeed: Expression-based styling of objects samples.lightspeed.style.expressions.MainPanel

This sample demonstrates expression based-styling in a Lightspeed view using TLspParameterizedLineStyle , TLspParameterizedFillStyle and TLspParameterizedIconStyle

Instructions

Use the layer selection panel on the right to select different layers, demonstrating different kinds parameterized styles, ILcdExpression and shapes.

The first layer shows Flightradar tracks styled with a TLspParameterizedLineStyle . Only the segment of a track that is within a specified time interval is visible.

The second layer shows European countries styled with a TLspParameterizedFillStyle . The fill color of the countries is derived from the population property of each country.

The last layer visualizes cities using a TLspParameterizedIconStyle . An icon for a city is scaled based on the population property and the distance to the mouse cursor.

Lightspeed: Fill style samples.lightspeed.style.fillstyle.MainPanel

This sample demonstrates the capabilities of TLspFillStyle . It shows various layers with shapes with different fill styles:

  • Solid: the area is filled with one color, possibly transparent.
  • Stippled: the area is filled with a repeating pattern. A stipple pattern is created by using a TLspFillStyle.StipplePattern with convenience methods to draw lines or filled/outlined rectangles, ovals or polygons.
  • Textured: the area is filled based on an texture. This can be a BufferedImage , and can be scaled, rotated or translated. Additionally, the texture can be set to be applied relative to the bounds of the object or relative to the bounds of the world.
Instructions

The sample has various layers containing shapes with different fill styles.

Move around in 2D and 3D to see the effect.

Edit the shapes to see how the different fill styles adapt.

Lightspeed: Icon style samples.lightspeed.style.icon.MainPanel

The icon style sample demonstrates the icon styling functionality of TLspShapeLayerBuilder, i.e.: rotation and transparency of icons, drawing icons with a vertical line and drawing icons either with a size in world coordinates or in view coordinates. All this is accomplished using TLspIconStyle.

The sample contains three layers with icons, all located around San Francisco:

  • View sized icons: the icon size remains constant in view coordinates (i.e. pixels), regardless of the scale of the view.
  • World sized icons: the size of the icons remains constant in world coordinates (typically meters).
  • Rotatable icons: these icons use a custom styler (see RotatableIconStyler). They can be rotated using the slider in the upper left corner of the view. They also change color depending on the scale of the view. Finally, the icons use a third scaling mode which is a hybrid of view and world sized: the size of the icons is defined in world coordinates, but their size on screen will never exceed their native size in pixels.
Instructions

Zoom in on San Francisco and see how each icon layer resizes its icons differently. Also notice how the rotatable icons layer changes the color of its icons based on the scale of the view. Use the rotation slider to change the orientation of the rotatable icons.

Lightspeed: Raster style samples.lightspeed.style.raster.MainPanel

The Raster Style sample illustrates how the style of a raster can be changed on the fly:

  • Change the outline and fill of the raster's bounds.
  • Change brightness, contrast and opacity.
  • Set and change a custom filter (interactive raster layers only).
  • Change the color model for elevation layers.

The sample starts with a raster style with 100% brightness, 100% contrast, 100% opacity and no custom filter. For more detailed information on how to use raster styles and providers, see the developer's guide or the documented source code of this sample.

The sample shows 3 types of layers:

  • Interactive raster layers: the style of these layers can be changed interactively. They are marked with a [I] prefix.
  • Background raster layers: the style of these layers can be changed but not as smoothly as interactive layers. However they generally require less processing and memory for painting. These layers are marked with a [B] prefix.
  • Terrain layer: this layer is a proxy for the view's terrain. The view's terrain contains all background layers at the bottom of the view, hence changing its style will affect all those layers. Its style can be changed interactively.
Instructions

Select a raster layer in the layer control and change its style using the panel on the left.

Lightspeed: Stroked line styles samples.lightspeed.style.strokedline.MainPanel

This sample demonstrates how line data can be visualized using complex strokes. This is achieved by using TLspComplexStrokedLineStyle.

Instructions

The sample shows a number of shapes with different strokes. Use the layer selection panel on the right to select different layers, demonstrating different kinds of strokes. Select and edit the shapes to see how the stroke pattern adjusts itself. Switch to a 3D view to see how stroked lines appear when they are draped over the terrain.

Lightspeed: Touch Basic samples.lightspeed.touch.basic.MainPanel

This applet demonstrates the use of the touch-based ILspControllers . It features a single controller chain to navigate around the map, and select and edit objects.

The sample features large buttons to allow easy manipulation with fingers instead of a mouse as input device.

Instructions

Use one finger to pan around and to select or edit objects. Use two fingers to zoom.

Lightspeed: Custom touch controller samples.lightspeed.touch.customcontroller.MainPanel

This sample demonstrates how ALspController can be extended to implement a custom touch controller.

The first custom controller displays a tooltip for objects that are touched.

The second custom controller fits the view to the bounds of an object if a touch-and-hold action is performed on that object.

Instructions

Activate the first custom controller ("information panels"). While you touch an object on the map (e.g. a county), a tooltip will pop up showing some of that object's attributes.

Activate the second custom controller ("fit to object"). Touch and hold an object until a red circle visually notifies you that the touch-and-hold time has been reached. If you now release your finger, the view will fit to the bounds of that object.

Lightspeed: Touch Editing samples.lightspeed.touch.editing.MainPanel

This applet demonstrates the use of the touch-based ILspControllers for editing purposes.

Instructions

Navigate, select and edit objects. You can make a layer selectable by first tapping on its name in the layer list, and then tapping on the "Toggle layer selectable" button.

To edit one of the shapes, you just have to touch the shape and interact with one of its editing handles. Please refer to the javadoc of the different editor classes in the API to see what functionality is provided by each of the handles.

To create a new shape, activate one of the create controllers in the toolbar. Note that most of the controllers also have an extruded creation variant. This variant creates an extruded shape with the base shape that is created by the normal editor. For instance, the ellipse create controller creates an extruded ellipse when extrusion is activated. Extrusion can be activated by the extrusion button in the creation toolbar (right most button).

Some shapes like polylines, polygons, and complex polygons have different (dynamic) creation steps that can be ended by pressing the Commit button. For example, to create a complex polygon containing two triangular shapes, the sequence of interactions should be: tap-tap-tap, commit (to end first polygon), tap-tap-tap, commit (to end second polygon), commit (to end complex polygon creation).

Lightspeed: Simulation of touch events samples.lightspeed.touch.touchEvents.MainPanel

This sample demonstrates the effect of touch events on a touch enabled Lightspeed view. It contains a setup that simulates touch events and passes them to the Lightspeed view. The touch controller set on the view is a navigation controller by default and will interpret the incoming events by panning and zooming the view.

The simulation can be started by clicking the "Simulate touch events" button in the toolbar.

Instructions

Start a simulation of how touch events are handled in a Lightspeed view by clicking the button in the toolbar.

Lightspeed: Tracking camera samples.lightspeed.trackingcamera.MainPanel

This sample shows how different constraints can be added to the view's camera to automatically follow one or more moving objects.

The sample shows a model with three airplanes. Their position is constantly updated. The sample attaches a tracking constraint to the camera so the airplanes are always in view.

The different possible tracking constraints are:

  • TLspLookFromTrackingCameraConstraint3D : used to fix the camera at a certain position. Panning and zooming are not possible, but rotating still is. Optionally, the direction of the camera can be fixed as well, so rotating is also impossible.
  • TLspLookAtTrackingCameraConstraint3D : used to fix the camera in a certain direction. Panning is not possible, but zooming and rotating still is.
  • TLspLookAtTrackingCameraConstraint2D : same as above for 2D views.
Instructions

The combobox on the right shows the available tracking modes. It changes the world reference, view's camera, and the tracking mode.

Supported tracking modes for a 3D view are:

  • Look at target: the camera is always oriented towards the tracked objects. Panning is not possible, but zooming and rotating is.
  • Look from target: the camera is always positioned on the tracked objects, looking away from them. Panning and zooming are not possible, but rotating is.
  • Oriented like target: the camera is always positioned on the tracked objects, oriented like the objects (based on ILcdOriented). Panning, zooming and rotating is impossible.
  • Follow location: the camera is always oriented towards the tracked objects. Panning is not possible, but zooming and rotating is.
  • Follow location and orientation: the camera is always positioned on the tracked objects, oriented like the objects. Only zooming is possible.

Lightspeed: Vertical view samples.lightspeed.vertical.MainPanel

This sample demonstrates the use of the vertical view package. The 2D view in the upper part contains a flight layer with two flight routes. Each flight route is modeled as a list of 3D points.

The vertical view in the lower part is used to display the vertical profile of the flight that is selected in the 2D view. Apart from this profile, a number of sub-profiles associated to it can be shown in a vertical view. In this case, two sub-profiles are associated to the view: the terrain and the air route. FlightVVModel, an implementation of ILcdVVModel holds the main-profile points and the information about the sub-profile.

Instructions

Select a flight. A vertical marker is shown in both views. Change the height of the flight by dragging its points up or down. You can zoom the X and Y axes by using the sliders to the right and at the bottom. You can disregard flight points at the left or right of the flight using the sliders at the top. Finally, the panel at the right allows you to select the altitude unit.

Lightspeed: style layers using Symbology Encoding (SLD) samples.ogc.sld.lightspeed.MainPanel

The OGC Symbology Encoding (Styled Layer Descriptor) standard describes an XML format to describe the style of a layer. This sample demonstrates how to decode such a style from a file and how to apply it to a Lightspeed layer.

The application displays a number of layers and a set of styles. The styles can be applied to the layers. Some of the styles are specific for a particular layer, while others can be applied to any layer.

The text area at the right displays the description of the style as it is defined in the SLD file.

Instructions

Select a layer in the layer control and a style in the dropdown list. Selecting the style will automatically apply it to the selected layer.

Decoding ISO19139 metadata samples.metadata.MainPanel

This sample demonstrates the ability to load metadata encoded following the ISO 19139 standard schema.

Instructions

Click the open button and select a file from the LuciadLightspeed/samples/resources/Data/metadata folder. The central frame will display the metadata as encoded in the file.

Metadata gazetteer samples.metadata.gazetteer.MainPanel

This sample demonstrates a simple gazetteer functionality.

Some metadata files are loaded and the geographic extent of the data they describe is extracted from the metadata and displayed on the map as bounds.

Instructions

Double click on the bounds to display all metadata linked to the bounds.

Right click with the mouse to load the data which is described in the metadata. The location(s) of the file to load is extracted from the metadata.

Oculus: Navigation controls samples.lightspeed.oculus.controller.MainPanel

This sample demonstrates how to create an Oculus Rift view and add a controller to move the camera. The default LuciadLightspeed controllers cannot be used in an Oculus view. The controller used in this sample will always place the camera at a fixed height above the terrain.

Instructions

When the sample is started the camera will be positioned just above the terrain. You can move forwards and backwards by using the up and down arrow key. The camera will move along the direction the user is currently looking at. The left and right arrow key will rotate the camera.

GXY: Displaying dynamic data samples.realtime.gxy.tracksimulator.MainPanel

This sample shows how to visualize dynamic tracks in a GXY map.

The sample shows several random parabolic trajectories and animates 2000 dynamic tracks moving along these trajectories. The dynamic tracks layer is simulated using a TLcdSimulator with a custom ALcdSimulatorModel .

Each track has a label that displays its identifier, and the grounded state of the track.

Instructions

Press the "Play" button to start or the simulation. The tracks start moving across their individual trajectories.

As the tracks move around, the labels are gently repositioned to avoid overlap. If you hover the mouse over a label of a moving track, it stops moving. In the rare event labels get mixed up, you drag them to a new location. Labels move back automatically.

A time slider allows to see your progression in the simulation. When the simulation is not running, the slider also allows you to change the "simulation time" with your mouse.

You can adjust the replay speed factor using the "speed up" slider.

Lightspeed: Displaying dynamic data on a map and timeline samples.realtime.lightspeed.tracksimulator.MainPanel

This sample shows how to visualize dynamic tracks in a Lightspeed map and timeline.

The sample shows 2000 random parabolic trajectories and animates 2000 dynamic tracks moving along these trajectories. The dynamic tracks layer is simulated using a TLcdSimulator with a custom ALcdSimulatorModel .

Tracks are visualized with airplane icons. In 3D projections, a line connects each icon with its zero-elevation point. Each track also has a trail of grey dots indicating previous positions. The trail is added to the icons by using a custom ILspStyler . The track labels are decluttered using the TLspContinuousLabelingAlgorithm , a specialized algorithm for moving objects in a Lightspeed view.

The time line at the bottom is a non geo-referenced Lightspeed view that you can pan and zoom.

Instructions

Press the "Play" button to start the simulation. The tracks start moving across their individual trajectories. The time view is also updated. If you pan the time view, the simulation is also updated. You can adjust the replay speed by zooming in or out on the time line.

Select a plane in the main view. Its altitude over time is displayed in the time view along with the name of its landing and take-off city.

Zoom in and pan around the world to see how the labels of the dynamic tracks are automatically decluttered depending on the current situation. You can also select and move all of the track labels.

GXY: style layers using SymbologyEncoding (SLD) samples.ogc.sld.gxy.MainPanel

The OGC Styled Layer Descriptor standard describes an XML format to describe the style of a layer. This sample demonstrates how to decode such a style from a file and how to apply it to a layer.

The application displays a number of layers and a set of styles. The styles can be applied to the layers. Some of the styles are specific for a particular layer, while others can be applied to any layer.

The text area at the right displays the description of the style as it is defined in the SLD file.

Instructions

Select a layer in the layer control and a style in the dropdown list. Clicking the apply button will attempt to apply the style to the selected layer. Selecting 'Default' in the list resets the style of the layer.

GeoPackage Encoder Sample samples.encoder.sqlite.geopackage.Main

This is a command-line sample. Click More info for run instructions.

This application demonstrates how to encode spatial data to a GeoPackage file, using TLcdGeoPackageModelEncoder.

Run the sample using the shell script in the samples folder:

Pass two arguments to this sample: an input file and a (new or existing) .gpkg file.

Using WCS data in a 2D GXY view samples.ogc.wcs.client.MainPanel

This sample demonstrates how to use an OGC Web Coverage Service (WCS) in a client application equipped with a 2D GXY view, using the Luciad WCS client API.

Using the client API, applications can create a "proxy" ILcdModel that transparently obtains coverage data from the WCS.

When a connection is made with a WCS service, the combo box in the upper right of the sample is populated with the list of coverages offered by this WCS. These coverages can be selected and visualized on the map.

Instructions

During startup, the sample will try to connect to one of two default OGC WCS services:

  • a Luciad OGC WCS service sample running on localhost at port 8080 (http://localhost:8080/LuciadOGCServices/wcs). If the OGC Web Services Suite is available, this service can be started by running the samples.ogc.server.Main sample.
  • a public Luciad OGC WCS service (http://sampleservices.luciad.com/wcs).

Querying the list of available coverages: fill in a URL in the text field below the map and press the "Query WCS service" button. This will send a GetCapabilities request to the service and parse the list of available coverages. When successful, the coverages will be listed in the combo box in the upper right corner of the sample.

Retrieving and visualizing a coverage: select a coverage in the combo box in the upper right of the sample. Click the "Get coverage" button to send a GetCoverage request to the service and visualize the requested data on the map.

Using WFS data in a 2D GXY view samples.ogc.wfs.client.gxy.MainPanel

This sample demonstrates how to use an OGC Web Feature Service (WFS) in a client application equipped with a 2D GXY view, using the Luciad WFS client API.

Using the client API, applications can create a "proxy" ILcdModel that transparently obtains feature data from a WFS. This WFS proxy model can optionally be configured with an OGC Filter to be applied to the data and, as is done in the sample, a "maxfeatures" parameter to limit the number of features that are retrieved from the service.

When a connection is made with a WFS service, the combo box in the upper right of the sample is populated with the list of features types offered by this WFS. Selecting a feature types from the list retrieves and visualize the feature data on the map. You can also connect to other WFS services through the URL panel below the map.

Instructions

During startup, the sample will try to connect to one of two default OGC WFS services:

  • a Luciad OGC WFS service sample running on localhost at port 8080 (http://localhost:8080/LuciadOGCServices/wfs). If the OGC Web Services Suite is available, this service can be started by running the samples.ogc.server.Main sample.
  • a public Luciad OGC WFS service (http://sampleservices.luciad.com/wfs).

To query the list of available feature types, fill in a server and press the "Query" button. This will send a GetCapabilities request to the service and parse the list of available features types. When successful, the feature types will be listed in the combo box in the upper right corner of the sample.

To visualize a feature type, just select it from the combo box. This will send a GetFeature request to the service for the selected feature type, and create a layer to visualize the retrieved feature data.

Using WFS data in a 2D / 3D Lightspeed view samples.ogc.wfs.client.lightspeed.MainPanel

This sample demonstrates how to use an OGC Web Feature Service (WFS) in a client application equipped with a 2D / 3D Lightspeed view, using the Luciad WFS client API.

Using the client API, applications can create a "proxy" ILcdModel that transparently obtains feature data from a WFS. This WFS proxy model can optionally be configured By default, this results in a map loaded with:

  • the states and the rivers of the USA,
  • the roads and a raster background of Washington DC,
  • a blue polygon partially covering Canada.

When a connection is made with a WFS service, the combo box in the upper right of the sample is populated with the list of features types offered by this WFS. Selecting a feature types from the list retrieves and visualize the feature data on the map. You can also connect to other WFS services through the URL panel below the map.

Instructions

During startup, the sample will try to connect to one of two default OGC WFS services:

  • a Luciad OGC WFS service sample running on localhost at port 8080 (http://localhost:8080/LuciadOGCServices/wfs). If the OGC Web Services Suite is available, this service can be started by running the samples.ogc.server.Main sample.
  • a public Luciad OGC WFS service (http://sampleservices.luciad.com/wfs).

To query the list of available feature types, fill in a server and press the "Query" button. This will send a GetCapabilities request to the service and parse the list of available features types. When successful, the feature types will be listed in the combo box in the upper right corner of the sample.

To visualize a feature type, just select it from the combo box. This will send a GetFeature request to the service for the selected feature type, and create a layer to visualize the retrieved feature data.

Using ECDIS data from a LuciadFusion WMS in a 2D GXY view samples.wms.client.ecdis.gxy.MainPanel

This sample demonstrates how to query ECDIS data from a LuciadFusion OGC Web Map Service (WMS) in a WMS client application, taking into account S-52 display settings.

This sample requires a LuciadFusion WMS service supporting SLD-based S-52 styling.

You can use the S-52 customizer panel on the right side of the map to tweak the display settings for the ECDIS WMS layers. The WMS client will encode the S-52 display settings into an S-52 SLD extension, and embed this SLD in the GetMap request that is sent to the server. The Fusion WMS server will return the ECDIS image, rendered with the settings from the SLD.

Instructions

During startup, the sample will try to connect to a public LuciadFusion OGC WMS service (http://sampleservices.luciad.com/wms). Additionally, you can connect to other LuciadFusion WMS services through the URL panel.

Map interaction: the toolbar offers a set of actions to navigate on and interact with the map. This includes the ability to pan and zoom, to measure distances and to switch the projection. When the selection projection does not match the available projects in the WMS service, the data is automatically reprojected, fully transparent for the user.

S-52 display settings: The S-52 display settings customizer panel right of the map allows to modify the S-52 display settings. Any change to the settings will immediately trigger a new query to the WMS server with updated S-52 SLD styling parameters, and update the client view accordingly.

Using WMS data in a 2D GXY view samples.wms.client.gxy.MainPanel

This sample demonstrates how map data from an OGC Web Map Service (WMS) can be retrieved and visualized in a GXY (2D) view.

Using the client API, applications can create a "proxy" ILcdModel that transparently obtains map data from the WMS.

When a connection is made with a WMS service, the layer list in the upper right of the sample is populated with the list of layers offered by this WMS. These layers can be selected and visualized on the map.

You can switch between a tiled and a non-tiled painting strategy. Tiled painting typically offers better performance while non-tiled painting allows pixel-perfect results in a 2D view.

The sample also demonstrates the use of WMS feature info requests. If the WMS advertises GetFeatureInfo support, you can click on the map. This requests additional feature information for that location from the service. If feature information is available, it will be painted as an overlay label on the map at the clicked location.

The sample demonstrates making use of multi-dimensional data when selecting WMS layers for which the WMS server advertises them.

The check box "Auto-update WMS" is enabled by default, which means that the sample will check at each pan/zoom action whether the capabilities at the server have been updated. Any changes in the available layers are applied automatically if there are any new layers defined at the server, they will be added. Layers that are not available anymore at the server will be removed automatically.

Instructions

During startup, the sample will try to connect to one of two default OGC WMS services:

  • a Luciad OGC WMS service sample running on localhost at port 8080 (http://localhost:8080/LuciadOGCServices/wms). If the OGC Web Services Suite is available, this service can be started by running the samples.ogc.server.Main sample.
  • a public Luciad OGC WMS service (http://sampleservices.luciad.com/wms).

WMS layer selection: the list in the upper right of the samples shows the available WMS layers. Selecting and deselecting layers triggers a map refresh, taking into account the current WMS layer selection.

Map interaction: the toolbar offers a set of actions to navigate on and interact with the map. This includes the ability to pan and zoom, to measure distances and to switch the projection. When the selection projection does not match the available projects in the WMS service, the data is automatically reprojected, fully transparent for the user.

Painting settings: disable the tiled checkbox in the panel. The update latency will increase but the results are now pixel-perfect when the view is using a 2D reference that is supported by the WMS server.

Feature info: click on the crosshair button in the toolbar to activate the feature info controller. Clicking on the cities or rivers of the USA or on the streets of Washington DC shows a label with the feature information next to the clicked point, if available.

Enable the check box "Auto-update WMS" to let the application check for new/removed WMS layers at each pan or zoom action. When used with the sample Luciad WMS service, one can add data in the samples/resources/Data/dynamic folder to try this feature. The following data formats are supported: SHP, MIF, CADRG, DMED, DEM, GeoTIFF, raster (.rst), ETOPO and a custom format (.txt). This folder is monitored each 10 seconds. When new data is found or when data is removed, the advertised layers in the WMS capabilities are automatically updated, and the client sample will automatically pick up the changes. Newly added data should therefore soon become visible at the client, after a pan or zoom action.

Using WMS data in a 2D / 3D Lightspeed view samples.wms.client.lightspeed.MainPanel

This sample demonstrates how map data from an OGC Web Map Service (WMS) can be retrieved and visualized in a Lightspeed view.

Using the client API, applications can create a "proxy" ILcdModel that transparently obtains map data from the WMS.

When a connection is made with a WMS service, the layer list in the upper right of the sample is populated with the list of layers offered by this WMS. These layers can be selected and visualized on the map.

You can switch between a tiled and a non-tiled painting strategy. Tiled painting typically offers better performance while non-tiled painting allows pixel-perfect results in a 2D view.

The sample also demonstrates the use of WMS feature info requests. If the WMS advertises GetFeatureInfo support, you can click on the map. This requests additional feature information for that location from the service. If feature information is available, it will be painted as an overlay label on the map at the clicked location.

The sample demonstrates making use of multi-dimensional data when selecting WMS layers for which the WMS server advertises them.

Instructions

During startup, the sample will try to connect to one of two default OGC WMS services:

  • a Luciad OGC WMS service sample running on localhost at port 8080 (http://localhost:8080/LuciadOGCServices/wms). If the OGC Web Services Suite is available, this service can be started by running the samples.ogc.server.Main sample.
  • a public Luciad OGC WMS service (http://sampleservices.luciad.com/wms).

WMS layer selection: the list in the upper right of the samples shows the available WMS layers. Selecting and deselecting layers triggers a map refresh, taking into account the current WMS layer selection.

Map interaction: the toolbar offers a set of actions to navigate on and interact with the map. This includes the ability to pan and zoom, to measure distances and to switch the projection. When the selection projection does not match the available projects in the WMS service, the data is automatically reprojected, fully transparent for the user.

Painting settings: disable the tiled checkbox in the panel. The update latency will increase but the results are now pixel-perfect when the view is using a 2D reference that is supported by the WMS server.

Feature info: click on the crosshair button in the toolbar to activate the feature info controller. Clicking on the cities or rivers of the USA or on the streets of Washington DC shows a label with the feature information next to the clicked point, if available.


Family

Free format text: CORRECTIVE ASSIGNMENT TO CORRECT THE NAME OF THE ASSIGNOR, FILED ON 08-19-1998, RECORDED ON REEL 9399 FRAME 0694ASSIGNORS:KRAMER, JAMES F.ANANNY, JOHN M.BENTLEY, LOREN F.AND OTHERSREEL/FRAME:010248/0974SIGNING DATES FROM 19980729 TO 19980806

Free format text: PATENTED CASE

Owner name: IMMERSION CORPORATION, CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTERESTASSIGNOR:VIRTUAL TECHNOLOGIES, INC.REEL/FRAME:013211/0318


Planet OSGeo

Sur CARTO Blog: Human Mobility & Transport Analysis in the Canary Islands

Опубликовано: 17 December 2020, 10:00am CET

Sur Paul Ramsey: Waiting for PostGIS 3.1: GEOS 3.9

Опубликовано: 16 December 2020, 9:00am CET

This post originally appeared on the Crunchy Data blog.

While we talk about “PostGIS” like it’s one thing, it’s actually the collection of a number of specialized geospatial libraries, along with a bunch of code of its own.

  • PostGIS provides core functionality
    • bindings to PostgreSQL, the types and indexes,
    • format reading and writing
    • basic algorithms like distance and area
    • performance tricks like caching
    • simple geometry manipulations (add a point, dump rings, etc)
    • algorithms that don’t exist in the other libraries
    • geometry relationships, like “intersects”, “touches” and “relate”
    • geometry operations, like “intersection”, “union”
    • basic algorithms, like “triangulate”

    The algorithms in GEOS are actually a port to C++ of algoriths in the JTS Java library. The ecosystem of projects that depend on GEOS or JTS or one of the other language ports of GEOS is very large.

    Over the past 12 months, the geospatial team at Crunchy Data has invested heavily in JTS/GEOS development, overhauling the overlay engine that backs the Intersection, Union, Difference and *SymDifference functions in all the projects that depend on the library.

    The new overlay engine, “Overlay NG”, promises to be more reliable, and hopefully also faster for most common cases.

    One use of overlay code is chopping large objects up, to find the places they have in common. This query summarizes climate zones (bec) by watershed (wsa).

    The new implementation for this query runs about 2 times faster than the original. Even better, when run on a larger area with more data, the origin implementation fails, it’s not possible to get a result out. The new implementation completes.

    Another common use over overlay code is melting together areas that share an attribute. This query takes (almost) every watershed on Vancouver Island and melts them together.

    At the start, there are 1384 watershed polygons.

    At the end there is just one.

    The new implementation takes about 50% longer currently, but it is more robust and less likely to fail than the original.

    The way Overlay NG ensures robust results, is by falling back to more and more reliable noding approaches. “Noding” refers to how new vertices are introduced into geometries during the overlay process.

    • Initially a naive “floating point” noding is used, that just uses double precision coordinates. This works most of the time, but occasionally fails when noding “almost parallel” edges.
    • On failure, a “snapping” noding is used, which nudges nearby edges and nodes together within a tolerance. That works most of the time, but occasional fails.
    • Finally, a “fixed precision” routing nudges all of the coordinates in both geometries into a fixed space, where edge collapses can be handled deterministically. This is the lowest performance approach, but it very very rarely occurs.

    Sometimes, end users actually prefer to have their geometry forced into a fixed precision grid, and for overlay to use a fixed precision. For those users, with PostGIS 3.1 and GEOS 3.9 there are some new parameters in the intersection/union/difference functions.

    The new “gridSize” parameter determines the size of the grid to snap to when generating new outputs. This can be used both to generate new geometries, and also to precision reduce existing geometries, just be unioning a geometry with an empty geometry.

    As always, there are a few random algorithmic treats in each new GEOS release. For 3.9, there is the “inscribed circle”, which finds the large circle that can be fit inside a polygon (or any other boundary).

    In addition to making a nice picture, the inscribed circle functions as a measure of the “wideness” of a polygon, so it can be used for things like analyzing river polygons to determine the widest point.

    Sur Paul Ramsey: Waiting for PostGIS 3.1: Grid Generators

    Опубликовано: 16 December 2020, 9:00am CET

    This post originally appeared on the Crunchy Data blog.

    Summarizing data against a fixed grid is a common way of preparing data for analysis. Fixed grids have some advantages over natural and administrative boundaries:

    • No appeal to higher authorities
    • Equal unit areas
    • Equal distances between cells
    • Good for passing data from the “spatial” computational realm to a “non-spatial” realm

    Ideally, we want to be able to generate grids that have some key features:

    • Fixed origin point, so that grid can be re-generated and not move
    • Fixed cell coordinates for a given cell size, so that the same cell can be referred to just using a cell address, without having to materialize the cell bounds

    The ST_SquareGrid(size, bounds) function generates a grid with an origin at (0, 0) in the coordinate plane, and fills in the square bounds of the provided geometry.

    So a grid generated using Brazil as the driving geometry looks like this.

    The ST_HexagonGrid(size, bounds) function works much the same as the square grid function.

    Hexagons are popular for some cartographic display purposes and modeling purposes. Surprisingly they can also be indexed using the same two-dimensional indexing scheme as squares.

    The hexagon grid starts with a (0, 0) hexagon centered at the origin, and the gridding for a bounds includes all hexagons that touch the bounds.

    As with the square gridding, the coordinates of hexes are fixed for a particular gridding size.

    Here’s a 100km hexagon gridding of Germany.

    It’s possible to materialize grid-based summaries, without actually materializing the grids, using the generator functions to create the desired grids on-the-fly.

    Here’s a summary of population points, using a hex grid.

    It’s also possible to join up on-the-fly gridding to visualization tools, for very dynamic user experiences, feeding these dynamically generated grids out to the end user via pg_tileserv.

    Sur Paul Ramsey: Waiting for PostGIS 3.1: Performance

    Опубликовано: 16 December 2020, 9:00am CET

    This post originally appeared on the Crunchy Data blog.

    Open source developers sometimes have a hard time figuring out what feature to focus on, in order to generate the maximum value for end users. As a result, they will often default to performance.

    Performance is the one feature that every user approves of. The software will keep on doing all the same cool stuff, only faster.

    For PostGIS 3.1, there have been a number of performance improvements that, taken together, might add up to a substantial performance gain for your workloads.

    Spatial joins have been slowed down by the overhead of large geometry access for a very long time.

    PostgreSQL will plan and execute spatial joins like this using a “nested loop join”, which means iterating through one side of the join, and testing the join condition. This results in executions that look like:

    • ST_Intersects(A.geom(1), B.geom(1))
    • ST_Intersects(A.geom(1), B.geom(2))
    • ST_Intersects(A.geom(1), B.geom(3))

    So one side of the test repeats over and over.

    Caching that side and avoiding re-reading the large object for each iteration of the loop makes a huge difference to performance. We have seen 20 times speed-ups in common spatial join workloads (see below).

    The fixes are quite technical, but if you are interested we have a detailed write-up available.

    Header-only Geometry Reads

    The on-disk format for geometry includes a short header that includes information about the geometry bounds, the spatial reference system and dimensionality. That means it’s possible for some functions to return an answer after only reading a few bytes of the header, rather than the whole object.

    However, not every function that could do a fast read, did do a fast read. That is now fixed.

    It’s pretty common for web applications and others to generate text formats inside the database, and the code for doing so was not optimized. Generating “well-known text” (WKT), GeoJSON, and KML output all now use a faster path and avoid unnecessary copying.

    PostGIS also now uses the same number-to-text code as PostgreSQL, which has been shown to be faster, and also allows us to expose a little more control over precision to end users.

    For the specific use case of spatially joining, here is my favourite test case:

    Load the data into both versions.

    Run a spatial join that finds the sum of populated places in each country.

    This test is somewhat of a “worst case”, in that there are lots of very large countries in the admin data, but it gives an idea of the kind of speed-ups that are available for spatial joins against collections that include larger (250+ coordinates) geometries.

    Sur gvSIG Team: Taller SIG aplicado a gestión municipal

    Опубликовано: 15 December 2020, 4:35pm CET

    En las pasadas Jornadas GeoLIBERO se realizó un taller de SIG aplicado a gestión municipal, cuya grabación ya está disponible.

    En el propio vídeo se indica de dónde descargar los datos y software necesario para seguir y replicar los distintos ejercicios que se realizan durante el taller.

    Sur Lutra consulting: Mergin and PostGIS in action

    Опубликовано: 14 December 2020, 1:00am CET

    One of the challenges of data collection projects is consolidating all the data a central database, such as Postgres/PostGIS. Using PostGIS as a live survey layer is not usually recommended:

    • Security: exposing your database to the wider internet
    • Access and connectivity: internet connection is not always guaranteed for a field survey projects

    A more cumbersome way around this, is to convert your tables from PostGIS to a file based GIS layer (e.g. Geopackage) and take the files with you to the field. This will create a new problem: keeping all the tables (from multiple surveyors) and the PostGIS table up-to-date.

    During an XXX survey, our friends at Kartoz have commissioned us to extend the Mergin service to support PostGIS. The Mergin service already supports file-based data synchronisation. The aim was to bridge the gap between the Mergin service and PostGIS so that the changes from Mergin immediately appear on PostGIS and vice versa.

    To facilitate that, we further developed the Geodiff library to support Postgres driver. In addition, we developed a tool to sync the tables from Postgres database with the Mergin service.

    The above diagram, details how Postgres/PostGIS synchronisation works with the Mergin service via the DB-Sync tool.

    • Tables 1 and 2 from the Postgres/PostGIS server are set up to work with the Mergin service
    • DB-Sync tool runs on the server (same server as the Postgres) on a regular interval to sync with the Mergin service
    • An offline version of Tables 1 and 2 are provided within the QGIS survey project on Mergin
    • Several surveyors download the project and add their data mostly while offline. The data are then synced with the Mergin.

    Sur PostGIS Development: PostGIS 3.1.0rc1

    Опубликовано: 14 December 2020, 1:00am CET

    The PostGIS Team is pleased to release the release candidate of the upcoming PostGIS 3.1.0 release. This version is exposes some of the new performance and feature enhancements in GEOS 3.9 as well as numerous speed enhancements not requiring newer GEOS.

    Sur Markus Neteler: MapScaping podcast: GRASS GIS probably doesn’t get the attention it deserves

    Опубликовано: 13 December 2020, 9:49pm CET

    In episode 86 of MapScaping podcast, Markus Neteler talks about the functionality offered (the topological vector engine, 2D and 3D raster analysis, image processing and available programming interfaces), and whom GRASS GIS is for.

    Markus is the cofounder of mundialis, a Bonn based business. He is also the Chairman of the GRASS GIS Project Steering Committee.

    Enjoy the podcast and the transcript!

    Sur Free and Open Source GIS Ramblings: Spatial data exploration with linked plots

    Опубликовано: 13 December 2020, 1:56pm CET

    In the previous post, we explored how hvPlot and Datashader can help us to visualize large CSVs with point data in interactive map plots. Of course, the spatial distribution of points usually only shows us one part of the whole picture. Today, we’ll therefore look into how to explore other data attributes by linking other (non-spatial) plots to the map.

    This functionality, referred to as “linked brushing” or “crossfiltering” is under active development and the following experiment was prompted by a recent thread on Twitter launched by @plotlygraphs announcement of HoloViews 1.14:

    Turns out these features are not limited to plotly but can also be used with Bokeh and hvPlot:

    It'll even work for hvPlot output. Would definitely be interested to see how it interacts with the geometries you usually work with.

    — Philipp Rudiger (@PhilippJFR) December 4, 2020

    Like in the previous post, this demo uses a Pandas DataFrame with 12 million rows (and HoloViews 1.13.4).

    In addition to the map plot, we also create a histogram from the same DataFrame:

    To link the two plots, we use HoloViews’ link_selections function:

    That’s all! We can now perform spatial filters in the map and attribute value filters in the histogram and the filters are automatically applied to the linked plots:

    Linked brushing demo using ship movement data (AIS): filtering records by speed (SOG) reveals spatial patterns of fast and slow movement.

    You’ve probably noticed that there is no background map in the above plot. I had to remove the background map tiles to get rid of an error in Holoviews 1.13.4. This error has been fixed in 1.14.0 but I ran into other issues with the datashaded Scatterplot.

    It’s worth noting that not all plot types support linked brushing. For the complete list, please refer to [holoviews.org]

    Sur CARTO Blog: Our Thoughts as MapboxGL JS v2.0 Goes Proprietary

    Опубликовано: 11 December 2020, 11:00am CET

    Sur CARTO Blog: Announcing the CARTO Scientific Committee

    Опубликовано: 11 December 2020, 10:00am CET

    Sur gvSIG Team: 16th International gvSIG Conference: Recording of presentations and workshops available

    Опубликовано: 10 December 2020, 4:57pm CET

    The presentations given at 16th International gvSIG Conference, that were held from November 4th to 6th in online mode, are now available.

    Recording of presentations that were given in English, Spanish or Portuguese, as well as the workshop in Spanish about “Normalización radiométrica e índices de vegetación en mapeo de incendios” are available at the Conference website.

    If you couldn’t follow the live conference you can watch the videos of the different sessions and the workshop and download the presentations now.

    Don’t miss them and see you in the next gvSIG Conference!

    Sur gvSIG Team: 16as Jornadas Internacionales gvSIG: Disponible la grabación de las ponencias y el taller

    Опубликовано: 10 December 2020, 4:42pm CET

    Ya están disponibles las presentaciones realizadas en las 16as Jornadas Internacionales gvSIG, que se celebraron de forma online del 4 al 6 de noviembre.

    También está disponible la grabación, tanto de las ponencias que se realizaron en español, inglés y portugués, como del taller sobre “Normalización radiométrica e índices de vegetación en mapeo de incendios”que se impartió durante las jornadas.

    Si no pudiste seguir las jornadas en directo ahora puedes disponer de la grabación de las distintas sesiones, y también del interesante taller realizado.

    ¡Os esperamos en las siguientes jornadas!

    Sur Jo Cook: Simple, but not too simple

    Опубликовано: 10 December 2020, 1:00am CET

    A focus of mine over the last few years has been how new users for software are enabled by good documentation, or conversely how easy it is to inadvertently put people off with the language you use. There are countless articles on this, around the use of terms such as “just”, or “simply”, and I’ve made observations myself on other examples over the last couple of years. However, I recently read a series of articles (kicked off by this one from Julia Evans) that made me realise that the debate is actually more nuanced than I had considered, and that there are downsides to using language that’s too simple.

    You don’t want to put off complete beginners by overwhelming them with unfamiliar jargon, but avoiding necessary technical terms will be counter-productive in the long-term, as it will be a barrier to further searching and learning. A good balance would be to avoid unnecessary jargon, but introduce vital technical terms with a friendly explanation.

    For example, here are three ways of introducing the same concept, namely making a change to some documentation for a project that is hosted on GitHub. Note I have omitted some elements of the process in step three, for brevity. Don’t @ me.

    1) All jargon: Submit changes to our documentation by forking the repository and submitting a pull-request.

    2) No jargon: Submit changes to our documentation by copying the code and sending us a version with your changes in it.

    From the perspective of a beginner, the first approach would probably be off-putting as it assumes you already know what the terms ‘forking’ and ‘pull request’ means, so our beginner starts their journey by feeling stupid.

    Approach two is an attempt to simplify the language by using roughly equivalent non-technical terms but it doesn’t explain how to copy the code and send the changes, and our plucky beginner will be no better off when they do eventually meet the terms ‘forking’ and ‘pull request’.

    Approach three is more verbose, I admit, but it introduces all the terms, explains the process, and provides guidance if needed.

    When is plain language too plain?

    However, the level of plain language used does need to take into account the expected audience. Sumana Harihareswara writes of mixed reactions to a FAQ on sunsetting Python 2 that was written in a plain language style. When I read that, elements of it do make me cringe, though partly that’s to do with the same issue of repeating words, but also starting sentences with “And”. I think it ought to be possible to write in plain language without doing either of those things.

    Finally, I was recently introduced to Hemingwayapp, which does a good job of assessing the readability grade of your writing, and suggests appropriate changes. Not everyone uses a full-blown word-processing package so this is a useful service (and free). Writing for your audience, but also ensuring you don’t alienate or condescend, is a really fine balance to hit- and thinking about these two issues in depth has given me even more respect than I previously had for technical writers!

    Sur gvSIG Team: Análisis evolución COVID-19 en Uruguay con gvSIG Online

    Опубликовано: 9 December 2020, 11:02am CET

    Los que nos seguís habitualmente sabéis que la Infraestructura de Datos Espaciales de Uruguay utiliza gvSIG Online como base tecnológica. Aquí podéis ver una presentación sobre ello. Al final de dicha presentación se comenta que aprovechando las ventajas de gvSIG Online, sin límites de uso de ningún tipo al ser software libre, el Gobierno de Uruguay está generando distintos geoportales que van más allá del alcance inicial previsto de disponer de un Geoportal para la IDE de Uruguay, y que entre esos usos está el análisis de los casos del COVID-19.

    Pues bien, estos días la prensa generalista ha publicado noticias sobre la evolución de la pandemia, en las que se hacen eco de los mapas y animaciones generados por el Ministerio de Salud Pública con gvSIG Online.

    Aquí os dejamos un par de enlaces, de dos de los varios medios de prensa en los que se muestra está información:

    Y el vídeo con gvSIG Online mostrando información sobre los casos de COVID-19 en Montevideo:

    Sur Jackie Ng: My new rig

    Опубликовано: 9 December 2020, 10:30am CET

    This past week, I made the final decision to retire my old PC used for gaming and dev on my various open source projects and start shopping out for a new PC.

    The main reason for the decision was my daily YouTube feed being subliminally inserted with many videos praising the (just-released) AMD Ryzen 5000 series of CPUs and the AMD Radeon RX 6000 series of GPU and how they were absolutely trouncing Intel and Nvidia in their respective CPU and GPU performance.

    I also haven't been a fan of Intel CPUs since the advent of the meltdown and spectre vulnerabilities and Linus Torvalds' remarks about Nvidia have long stuck with me and my open source sensibilities, so I knew my next PC was going to have an AMD CPU and an AMD GPU. Now for me personally, I'm more of a coder than a gamer so while most of the competition-trouncing benchmarks thrown around were gaming-oriented, I was more interested in any benchmarks on developer-style workloads. One particular benchmark on one particular video caught my attention and told me that not only will my next PC be all AMD, I must get this next PC yesterday!


    That's right, the new top-of-the-line AMD Ryzen 5950x compiles the Chromium browser (the software whose C++ codebase is most notorious for long build times) in around 45 minutes! Since the C++ codebases I work with are way smaller than Chromium's, but still took a considerable time to build on my old 2012 rig I was salivating at the thought of being able to compile MapGuide/FDO/GDAL/etc in 5-10 minutes on my brand new Ryzen-powered beast.

    So then I started to look around to see who would offer such a beast of a PC in my home country of Australia. This eventually lead me to PC Case Gear (PCCG) which offered pre-built Intel and AMD Ryzen Gaming PCs at various pricing tiers. Some people may tell me that I should buy the components and build the PC myself, but I'm more of a software person than a hardware person so when it comes to a new PC, I prefer to go a with a pre-built one than risk screwing thing up building a new PC myself.

    My personal budget for this new PC was to be no more than $5000 AUD. This sadly put any pre-built systems with a Ryzen 5950x out of my price range, so I settled on their Elite 6800 XT gaming system, whose main components of interest were:

    • AMD Ryzen 9 5900x
    • AMD Radeon RX 6800 XT
    • 4TB (2x2) SSD
    • 32 GB of DDR4 RAM
    • Windows 10 Home pre-installed
    • FDO takes 17 minutes (release build, windows)
    • MapGuide takes 15 minutes (release build, windows)
    • Linux numbers TBD, but I'm expecting comparable numbers

    Sur Paul Ramsey: Mapbox and Morrison

    Опубликовано: 9 December 2020, 9:00am CET

    Yesterday, Mapbox announced that they were moving their Mapbox GL JS library from a standard BSD license to a new very much non-open source license.

    Joe Morrison said the news “shook” him (and also the readers of the Hacker News front page, well done Joe). It did me as well. Although apparently for completely different reasons.

    Mapbox is the protagonist of a story I’ve told myself and others countless times. It’s a seductive tale about the incredible, counterintuitive concept of the “open core” business model for software companies.
    – Joe Morrison

    There’s a couple things wrong with Joe’s encomium to Mapbox and “open core”:

    • first, Mapbox was never an open core business
    • second, open core is a pretty ugly model that has very little to do with the open source ethos of shared intellectual pursuit.

    Mapbox was never Open Core

    From the very start (well, at least from the early middle), Mapbox was built to be a location-based services business. It was to be the Google Maps for people who were unwilling to accept the downsides of Google Maps.

    Google Maps will track you. They will take your data exhaust and ruthlessly monetize it. They will take your data and use it to build a better Google Maps that they will then re-sell to others.

    If you value your data at all (if you are, say, a major auto maker), you probably don’t want to use Google Maps, because they are going to steal your data while providing you services. Also, Google Maps is increasingly the “only game in town” for location based services, and it seems reasonable to expect price increases (it has already happened once).

    Nobody can compete with Google Maps, can they? Why yes, they can! Mapbox fuses the collaborative goodness of the OpenStreetMap community with clever software that enables the kinds of services that Google sells (map tiles, geocoding, routing, elevation services), and a bunch of services Google doesn’t sell (like custom map authoring) or won’t sell (like automotive vision).

    But like Google, the value proposition Mapbox sells isn’t in the software, so much as the data and the platform underneath. Mapbox has built a unique, scalable platform for handling the huge problem of turning raw OSM data into usable services, and raw location streams into usable services. They sell access to that platform.

    Mapbox has never been a software company, they’ve always been a data and services company.

    The last company I worked for, CARTO, had a similar model, only moreso. All the parts of their value proposition (PostgreSQL, PostGIS, the CARTO UI, the tile server, the upload, everything) are open source. But they want you to pay them when you load your data into their service and use their software there. How can that be? Well, do you want to assemble all those open source parts into a working system and keep it running? Of course not. You just want to publish a map, or run an analysis, or add a spatial analysis to an existing system. So you pay them money.

    Is Mapbox an “open core” company? No, is there a “Mapbox Community Edition” everyone can have, but an “Enterprise Edition” that is only available under a proprietary license? No. Does Mapbox even sell any software at all? No. (Yes, some.) They (mostly) sell services.

    So what’s with the re-licensing? I’ll come back to that, but first…

    Open Core is a Shitty Model

    Actually, no, it seems to be a passable monetization model, for some businesses. It’s a shitty open source model though.

    • MongoDB has an open source core, and sells a bunch of proprietary enterprise add-ons. They’ve grown very fast and might even reach sufficient velocity to escape their huge VC valuation (or they may yet be sucked into the singularity).
    • Cloudera before them reached huge valuations selling proprietary add-ons around the open Hadoop ecosystem.
    • MySQL flirted with an open core model for many years, but mostly stuck to spreading FUD about the GPL in order to get customers to pay them for proprietary licenses.

    Easily the strangest part of the MySQL model was trash-talking the very open source license they chose to place their open source software under.

    All those companies have been quite succesful along the axes of “getting users” and “making money”. Let me tell you why open core is nonetheless a shitty model:

    • Tell me about the MongoDB developer community. Where do they work? Oh right, Mongo.
    • Tell me about the Cloudary developer community? Where do they work?
    • Tell me about the MySQL developer community? Where to they work? Oh right, Oracle. (There’s a whole other blog post to be written about why sole corporate control of open source projects is a bad idea.)

    A good open source model is one that promotes heterogeneity of contributors, a sharing of control, and a rising of all boats when the software succeeds. Open core is all about centralizing gain and control to the sponsoring organization.

    This is going to sound precious, but the leaders of open core companies don’t “care” about the ethos of open source. The CEOs of open core companies view open source (correctly, from their point of view) as a “sales channel”. It’s a way for customers to discover their paid offerings, it’s not an end in itself.

    We didn’t open source it to get help from the community, to make the product better. We open sourced as a freemium strategy to drive adoption.
    – Dev Ittycheria, CEO, MongoDB

    So, yeah, open core is a way to make money but it doesn’t “do” anything for open source as a shared proposition for building useful tools anyone can use, for anything they find useful, anytime and anywhere they like.

    Check out Adam Jacob’s take on the current contradictions in the world of open source ethics there are no hard and fast answers.

    I too was a little shook to learn of the Mapbox GL JS relicensing, but perhaps not “surprised”. This had happened before, with Tilemill (open) morphing into Mapbox Studio (closed).

    The change says nothing about “open source” in the large as a model, and everything about “single vendor projects” and whether you should, strategically, believe their licensing.

    I (and others) took the licensing (incorrectly) of Mapbox GL JS to be a promise, not only for now but the future, and made decisions based on that (incorrect) interpretation. I integrated GL JS into an open source project and now I have to revisit that decision.

    The license change also says something about the business realities Mapbox is facing going forward. The business of selling location based services is a competitive one, and one that is perhaps not panning out as well as their venture capital valuation (billions?) would promise.

    No doubt the board meetings are fraught. Managers are casting about for future sources of revenue, for places where more potential customers can be squeeeeezed into the sales funnel.

    I had high hopes for Mapbox as a counterweight to Google Maps, a behemoth that seems likely to consume us all. The signs that the financial vice is beginning to close on it, that the promise might not be fulfilled, they shake me.

    So, yeah, Joe, this is big news. Shaking news. But it has nothing to do with “open source as a business model”.

    Sur PostGIS Development: PostGIS 3.1.0beta1

    Опубликовано: 9 December 2020, 1:00am CET

    The PostGIS Team is pleased to release the first beta of the upcoming PostGIS 3.1.0 release. This version is exposes some of the new performance and feature enhancements in not yet relesed GEOS 3.9 as well as numerous speed enhancements not requiring newer GEOS. Requires GEOS 3.6+ and PostgreSQL 9.6+. To use MVT you will need protobuf-c 1.1. or higher.

    Sur Florentina Musat: Nyquil Memes Are Famous in Sky

    Опубликовано: 7 December 2020, 12:29pm CET

    Without better information on the human condition some time ago, when Siddhartha Gautama's representationalism more likely than not been in any event changing, the cognizance in itself is a reality, and the main reality when contrasted. We can't state the simple things and objects of the universe with conviction the profundities of enduring experienced at that time. In this manner, one of the establishing standards that life is enduring. That information in human awareness in their type of portrayals are in a consistent change and adjustment, along these lines being something close of being illusionary, are past the range of the advancement of however in that the truth where we make our inferences from has fundamentally modified since his reality.



    The authenticity of cosmology and its sister, quantum material science, has changed the human impression of presence and climate. The authenticity of human life systems has likewise changed the very pith of being. In an immense detail of such properties as DNA, cell cycles, and nervous system science, we currently know our feeling of the truth depends on. In this way, as the human condition has likewise improved because of clinical creations made since the logical upset of the 1920s, mental medical services, and so forth, the establishing standards of Buddhism, contrasted, and logical authenticity is subsequently overwhelmed the innovation of thought. Also Visit Nyquil Memes, Dayquil Memes And Funny Memes.

    Sur pycsw Team: pycsw turns 10!

    Опубликовано: 7 December 2020, 11:34am CET

    This year (02 December) marks the 10th anniversary of the pycsw project. From the initial commit on SourceForge, and subsequent announcement, of the project, pycsw has evolved into a stable, production ready and core spatial data infrastructure (SDI) component for disseminating metadata via the OGC CSW specification.

    pycsw powers numerous high profile open data / SDI activities, including US Data.gov, LINZ, Geodata.gov.gr, IOOS, NOAA, WMO WOUDC, UN WFP, Copernicus and GEOSS. The flexible nature of the project has also resulted in integration with leading open data management systems such as CKAN and GeoNode.

    From day one, pycsw has always strived to be OGC Compliant. The project continues to be a leading OGC Reference Implementation of CSW. In addition, pycsw continues as a long standing OSGeo project and a core component of the growing ecosystem of geopython projects for the open source geospatial community.

    The project will continue to evolve into the future. pycsw’s flexible nature will continue to support new metadata formats, as well as integration with downstream applications. To support OGC CSW as a baseline OGC web service specification, as well as the evolving OGC API efforts to modernize web service APIs, pycsw will continue to support CSW 2/3, as well as the emerging OGC API - Records specification.

    Thank you to the pycsw community, OSGeo, OGC and beyond for your support and use of our lightweight, flexible and OGC compliant metadata catalogue server – happy birthday pycsw!

    Sur Free and Open Source GIS Ramblings: Plotting large point CSV files quickly & interactively

    Опубликовано: 6 December 2020, 7:00pm CET

    Even with all their downsides, CSV files are still a common data exchange format – particularly between disciplines with different tech stacks. Indeed, “How to Specify Data Types of CSV Columns for Use in QGIS” (originally written in 2011) is still one of the most popular posts on this blog. QGIS continues to be quite handy for visualizing CSV file contents. However, there are times when it’s just not enough, particularly when the number of rows in the CSV is in the range of multiple million. The following example uses a 12 million point CSV:

    To give you an idea of the waiting times in QGIS, I’ve run the following script which loads and renders the CSV:

    The script output shows that creating the vector layer takes 02:39 minutes and rendering it takes over 05:10 minutes:

    Rendered CSV file in QGIS

    Panning and zooming around are no fun either since rendering takes so long. Changing from a single symbol renderer to, for example, a heatmap renderer does not improve the rendering times. So we need a different solutions when we want to efficiently explore large point CSV files.

    The Pandas data analysis library is well-know for being a convenient tool for handling CSVs. However, it’s less clear how to use it as a replacement for desktop GIS for exploring large CSVs with point coordinates. My favorite solution so far uses hvPlot + HoloViews + Datashader to provide interactive Bokeh plots in Jupyter notebooks.

    But first things first! Loading the CSV as a Pandas Dataframe takes 10.7 seconds. Pandas’ default plotting function (based on Matplotlib), however, takes around 13 seconds and only produces a static scatter plot.

    Loading and plotting the CSV with Pandas

    We only need two more steps to get faster and interactive map plots (plus background maps!): First, we need to reproject the lat/lon values. (There’s a warning here, most likely since some of the input lat/lon values are invalid.) Then, we replace plot() with hvplot() and voilà:

    Plotting the CSV with Datashader

    As you can see from the above GIF, the whole process barely takes 2 seconds and the resulting map plot is interactive and very responsive.

    12 million points are far from the limit. As long as the Pandas DataFrame fits into memory, we are good and when the datasets get bigger than that, there are Dask DataFrames. But that’s a story for another day.

    Sur pycsw Team: pycsw 2.6.0 released

    Опубликовано: 5 December 2020, 2:47pm CET

    The pycsw team announces the release of pycsw 2.6.0.

    This release brings various enhancements to OpenSearch temporal support, cloud enhancements, and 12 factor support. This release also drops all Python 2 support given the Python 2 end of life which occured on 01 January 2020. Users are strongly encouraged to update their deployments to Python 3 as soon as possible.

    Source and binary downloads:

    The source code is available at:

    PyPI packages are available at:

    [Bulleted list of enhancements / bug fixes]

    • fix GetRecords startposition empty parameter fixes
    • update OpenSearch temporal extent query support
    • add 12 factor support
    • support environment variables in configuration
    • add kubernetes and helm configurations
    • fix quoting for PostgreSQL backends
    • add logging switch to pycsw-admin.py CLI to stdout
    • safeguard XML as bytes to unicode
    • update core model xml column to Unicode on repository creation
    • handle different formats for CRS code input
    • add test for invalid gml:posList geometry
    • drop all Python 2 support

    Testers and developers are welcome.

    Sur Free and Open Source GIS Ramblings: Dashboards in QGIS

    Опубликовано: 5 December 2020, 2:21pm CET

    If you are following QGIS topics on social media, you may have already seen this but if you don’t, I recommend having a look at Tim Sutton’s most recent adventures in building dashboards with QGIS:

    The dashboard is built using labeling and geometry generator functionality. This means that they work in the QGIS application map window as well as in layouts. As hinted at in the screenshot above, the dashboard can show information about whole layers as well as interactive selections.

    Here’s a full walk-through Tim published yesterday:

    You can follow the further development via Tim’s tweets or the dedicated Github issue (where you can even find an example QGIS dashboard project in a GeoPacakge for download).

    Sur From GIS to Remote Sensing: Major Update: Semi-Automatic Classification Plugin v. 7.2.0

    Опубликовано: 5 December 2020, 1:24pm CET
    • the tool Classification dilation
    • the tool Classification erosion
    • the tool Cloud mask
    • the tool Class signature
    • the tool Mosaic
    • the tool PCA
    • the scatter plot calculation

    Also, the tool Band calc has been improved, and now it is possible to use the variable "bandset<LIST_OF_BANDSETS>bNUMBER_OF_BAND"for using a list of bands (for instance bandset<1,2>b1 is equivalent to ["bandset1b1","bandset2b1"]).For instance it can be used for calculating sum of bands:sum("bandset<1,2,3>b1")
    for the sum of the first bands of the bandsets 1, 2, and 3, or similarly using ranges:sum("bandset<1:3>b1")
    or list of rangessum("bandset<1:2, 3:4>b1")
    Please read the user manual for further details.
    For any comment or question, join the Facebook group about the Semi-Automatic Classification Plugin.

    Sur CARTO Blog: How to Create Maps from Snowflake using CARTO & SQL

    Опубликовано: 4 December 2020, 10:00am CET

    Sur CARTO Blog: Analyzing UK Covid Recovery & Mobility with Avison Young

    Опубликовано: 4 December 2020, 10:00am CET

    Sur Cameron Shorter: Halfway status - Cross-organizational glossary pilot

    Опубликовано: 2 December 2020, 11:46am CET

    This interim status report outlines achievements, early findings and outstanding tasks for our cross-organizational glossary pilot project.

    Glossaries are easy to set up for simple examples but extremely hard to scale - especially when a project wants to inherit terms from other organizations. This pilot has been set up to test cross-domain management of glossaries. We started in August 2020, and plan to have tested pilot goals by March 2021.

    We are testing glossary software, standards, and processes, and applying them to cross-organizational use cases within the geospatial mapping domain.

    For more details, refer to our manifesto.

    Pilot contributors: Cameron Shorter, Alyssa Rock, Ankita Tripathi, Naini Khajanchi, Ronald Tse, Reese Plews, Rob Atkinson, Nikos Lambrinos, Erik Stubkjær, Brandon Whitehead, Ilie Codrina Maria, Vaclav Petras

    Our interim status as the start of December 2020 is as follows:

    Task % Complete
    Define glossary goals 90%
    Establish implementation Plan 80%
    Establish a healthy community 70%
    Implement/adopt software platform 70%
    Establish schemas for terms 70%
    Define sentence structure for terms 70%
    Connect external glossaries 10%
    Collate and clean Open Source Geospatial (OSGeo) terminology 60%
    Document template governance processes 10%
    Goals

    Task: Define glossary goals.

    Understanding the problem is the first step needed to then address it.

    Figure: Connected glossaries, source

    • We feel we have articulated the problem and associated use cases reasonably well. Refer to the Glossary Pilot Manifesto and accompanying presentations.

    Task: Establish implementation Plan

    • Within the Glossary Pilot Manifesto we articulated steps for standing up a cross-organizational glossary pilot. We have been steadily working against this plan.

    Task: Establish a healthy community:

    Apache, one of the leading open source foundations prioritizes “community over code”. A strong community will solve any technical challenges faced.

    • We have attracted a motivated, competent, and cross-functional team of 5 to 10 people (depending on how you count), who are steadily working through our backlog of tasks. Collectively we have decades of experience with glossaries, tech writing, standards, software, and the geospatial domain we are initially focusing on.
    • We have a weekly status meeting, sometimes complemented by additional meetings, along with a slack channel, and email list.
    • We have only attracted one of the many OSGeo open source projects to sign up as a pilot. This is likely because we haven’t made the signup process easy enough yet, and our tools and processes need improving.
    • After completing the pilot and releasing an alpha version, we’d want to scale our community into other domains (beyond our current spatial domain focus).

    Task: Implement/adopt software platform

    • We’ve adopted the glossarist open source software to manage terminology. This provides terminology management of terms, and publishing of terms via a standards based web service.
    • Ribrose, who develop this software, has been working with us to update the software to address use cases and feedback we are finding during testing.
    • Extra functionality is expected to be included during the remainder of this pilot.

    Task: Establish schemas for terms

    Figure: Glossary schema, sourcing from upstream glossaries, source

    Task: Define sentence structure for terms.

    • For sentence structure, we’ve adopted 16.5.6 Definitions, ISO/IEC Directives, Part 2
      Principles and rules for the structure and drafting of ISO and IEC documents
      • “The definition shall be written in such a form that it can replace the term in its context. …”
      • Example: 2.1.17 die: metal block with a shaped orifice through which plastic material is extruded

      Task: Connect external glossaries

      • In theory, we are very close to connecting two glossaries. In practice, we still need to set this up, which is a focus for the rest of this pilot.

      Task: Document template governance processes

      Figure: Glossary governance, source

      While we have been discussing and making use of our own unwritten governance process, we are yet to write this down and provide it as template guidance.

      Task: Collate and clean Open Source Geospatial (OSGeo) terminology

      • We’ve collated OSGeo terminology from around ten OSGeo glossaries along with OGC and ISO terms.
      • These terms have been aligned with writing rules.
      • We’ve just started looking at terms from the GRASS project, and plan to integrate these too.

      Sur CARTO Blog: Predicting Traffic Accident Hotspots with Spatial Data Science

      Опубликовано: 2 December 2020, 10:00am CET

      Sur CARTO Blog: Lifesight Human Mobility & Footfall Data now available in CARTO

      Опубликовано: 1 December 2020, 10:00am CET

      Sur Jo Cook: On the many ways in which you can contribute to open source

      Опубликовано: 1 December 2020, 1:00am CET

      As a recipient of a Google Peer Bonus, I was given the opportunity to submit a guest post to the Google Open Source Blog, published on October 27th 2020. For my own archives, and because I didn’t particularly like some of the edits they made, here’s my original version.

      I was recently awarded a Google Open Source Peer Bonus, which was all kinds of awesome, but also proof that you can contribute things of value to open source projects, and indeed build a career in it, without being a hard-core coder. I can github, it’s true, but my actual coding skills are definitely limited to the occasional python or shell script! So how, as a non-coder can I, and others like me, contribute to open source in a meaningful way?

      This is incredibly valuable, particularly if you are new to a project! Firstly, developers and maintainers of projects are often focused, for good reason, on fixing bugs and improving the software. Documentation is harder for them to prioritise, and sometimes gets neglected. If you can help with this, then your contributions will be greatly appreciated. Secondly, if you’re very familiar with how to install and run a particular package, or even if you already have all the dependencies installed, then it’s very easy to miss a step, or for your instructions to be ambiguous. However, if you’re a beginner, you are best placed to ensure that instructions and step-by-step guides are easy to follow, don’t skip vital steps, and don’t use off-putting language.

      Also, if you have the opportunity to get involved in projects like Google Season of Docs as a mentor or a participant, as I did in 2019, go for it because it’s hugely rewarding!

      Get involved in the community!

      Can you help on mailing lists, or by organising events? One of the best things I have done was to get involved in the nascent Open Source Geospatial Foundation (OSGeo) back in 2006. I was persuaded to set up a local chapter in the United Kingdom, which is still going strong 14 years later at [https:]] . We’ve hosted a global conference (FOSS4G) and several UK events and an online-only event this year. We’ve also managed to financially support a number of open source projects by providing an annual sponsorship, or by contributing to the funding of a specific improvement. I’ve met so many great people because of my involvement in OSGeo, some of which have become colleagues and good friends.

      The view from the stage at FOSS4G 2013, photo by me, CC BY-NC-2.0

      Can you talk at a conference about your experiences with a project, or perhaps write a case study? Evidence that particular packages can be used successfully in real-world situations are incredibly valuable, and can help others put together business cases for considering an open source solution.

      Can you make things easier for people?

      When I first started using open source software, the packages I needed were often hard to install and configure on windows, and had to be started using the command prompt, which is intimidating for beginners. To scratch a problem-solving itch, I packaged them up onto a USB stick, added some batch files to make them load properly from an external drive, added a little menu for starting them, and Portable GIS was born. 12 years, a few iterations, a website and a GitLab repository later, it has been downloaded thousands of times, and is used in situations such as disaster relief, where installing lots of software rapidly on often old pcs is not really an option. I didn’t need any coding skills for this, beyond knowing how to refer to relative drive paths in windows.

      Once you get proficient in something, use your new knowledge to help others. Some areas of “modern” software use and development, such as online repositories like GitHub or GitLab are extremely intimidating to new users, and create a huge barrier to participation. If you can help people get over the fear-inducing first pull request, you will empower them to keep on contributing. I confess, my first pull request was a slightly puerile contribution to the Vaguely Rude Place-names map back in 2013! Since then, however, taking a leaf from the Python “Don’t be afraid to commit” workshop, I have run a few training events along a similar line at conferences and hopefully helped a few people take that first step.

      In summary, 16 years after I first found out about it, open source is now fundamental to my career, as well as being something that I am truly passionate about. It has shaped my life in many ways. I hope that my experiences might help some people who also consider themselves to be non-coders to get involved, and to realise that their contributions are equally as valuable as bug fixes and patches.

      Sur Andrea Antonello: SMASH 1.6.1 is out geo-tiffs and -fences

      Опубликовано: 30 November 2020, 11:40am CET

      Today we released SMASH 1.6.1 to the stores.

      The main reason we are doing this is because there was a startup bug that was freezing SMASH, mostly on Xiaomi devices. If you experienced something like this: [https:]

      . well, update and it will be gone.

      That said, we also have some significant additions:

      Up to now we had tiff support needing world files and projection file to be present. Now geotiff tag reading is supported, so "real" geotiffs can be read. This is quite handy, since the image file gets back to be a single one again. Same as for other imagery types it supports overall transparency and single color removal, which allows for some nice technical map overlays (for example):

      Since were we live the COVID lockdown imposed people to only walk a certain distance from home, we decided to lend a helping hand. You now can add fences and make them ring when you enter or exit the radius.

      The fence option is available from the bottom toolbar:

      Once you hit it, it inserts a new fence in the current map center:

      Defining the fence with no sound will result in a grey colored fence to show that it is "inactive":

      To modify an existing fence, just place the map center inside its circle and then long tap the fence button. The fence dialog will appear again, this time with an additional possibility to remove the fence.

      Now that the fence is active (on enter and exit sound set), the color is red and there are two borders. The green one reminds that on entering there will be a sound, and the blue one that on exit there will be a sound.


      Just so you know, fences are not saved into the project, but only in the application preferences. This means that on uninstall or app cache removal.. they will disappear.

      While this is possibly my favorite feature of this release, I have written about it in my last post here, so just check there for descriptions and images.

      Magnet icon for center on gps: if you are in automatic center on gps mode (double tap on gps icon), it will be visible through a small magnet:


      Location permission at startup now allows to access the settings to activate directly background gps usage even when the app is not in use.

      Note sharing now also contains the complete OSM url (not sure how that could have been missing up to now):

      Project browsing has been made more readable. Not sure how about you, but in my case I just create a new project and using the default proposed name, I simply add something meaningful at the end of it, after an underscore. This allows me to order my projects alphabetically also by timestamp. The problem is that when I want to load an older project, I find myself in this:

      The smash_timestamp take the whole line and makes everything unreadable. So now you can activate the upper right filter and the timestamp will be removed from the name and added as additional info ( day and time if available):

      I guess that is it for this release. Enjoy!

      Sur GeoNode: GeoNode 3.1 is out!

      Опубликовано: 30 November 2020, 1:00am CET

      This Post is gonna kick things off by summarizing the latest release GeoNode 3.1.

      The release fixes several minor, major and security issues. Further GeoNode 3.1 brings several new features you should not miss!

      • Python upgrade 3.7+
      • Django upgrade 2.2.16
      • GeoServer upgrade 2.17.2
      • MapStore2 Client Updates:
        • Save Search Services to the Map
        • Save Map Preferences into the adapter model
        • Advanced Style Editor with graphical UI
        • Improved Map Save Widget, specific for GeoNode

        For all other things which have been added, do not miss to read — the release notes for GeoNode 3.1!

        Last but not least in case you're planning a manual install of version 3, be sure to visit the updated docs. You can report any issues or feature requests at our Issue Tracker @ Github.

        Stay healthy & happy GeoNod'ing!

        Sur OTB Team: Please participate to our survey : How do you use OTB ?

        Опубликовано: 27 November 2020, 4:17pm CET

        Sur gvSIG Team: Integración de gvSIG Online con gestores de expedientes municipales

        Опубликовано: 26 November 2020, 5:51pm CET

        En la Asociación gvSIG siempre decimos que la realidad se manifiesta en el territorio, y en el caso de una administración local se estima que es más del 80% de la información que se gestiona sobre el municipio tiene atributo o dimensión espacial. Por tanto, herramientas que nos permitan gestionar la información geográfica, nos ayudarán a mejorar la gestión de la realidad municipal.

        Así, hablamos de Infraestructuras de Datos Espaciales aplicadas al ámbito municipal, y de su implantación mediante el software libre gvSIG Online. Una solución que nos permite catalogar, gestionar, localizar y compartir fácilmente información mediante visores de mapas web, tanto internamente (privados) como con los ciudadanos (públicos).

        Hay otra certeza cuando hablamos de gestión municipal, y es que en la gran mayoría de los casos la gestión de los procedimientos municipales pasan por la gestión de expedientes. Un gran volumen de los datos que maneja un ayuntamiento se introducen mediante el software de gestor de expedientes.

        Y ocurre que los expedientes tienen, en su mayoría, un atributo espacial.

        Integrando los gestores de expedientes municipales con las Infraestructuras de Datos Espaciales se dota al ayuntamiento de una herramienta de gestión realmente útil y potente. Y de eso hablamos en esta ponencia impartida en las pasadas Jornadas Internacionales de gvSIG.

        En ella, además, mostraremos ejemplos de integración de gvSIG Online con gestores de expedientes como Gestiona y OpenSea.

        Y si en tu ayuntamiento queréis dar el paso, como tantos otros lo han dado ya, ponte en contacto con nosotros ([email protected])

        Sur CARTO Blog: COVID-19 Vaccine: Optimizing Cold Chain Transportation

        Опубликовано: 26 November 2020, 10:00am CET

        Sur Ecodiv.earth: Access soilgrid data using the WCS protocol

        Опубликовано: 25 November 2020, 1:00am CET

        The website soilgrids.org provides access to grid layers representing the spatial distribution of soil properties across the globe. The SoilGrids maps are publicly available under the CC-BY 4.0 License. The soilgrids.org provides a convenient portal to explore the available data sets. The data can furthermore be accessed through various services, which are listed on the ISRIC site.

        One of the available services is the Web Coverage Service (WCS), which is a standard issued by the Open Geospatial Consortium (OGC). It allows easy remote access to raster layers from a web browser or any other (GIS) program that supports the protocol. What makes it convenient is that one can choose what part of the available data to download based on spatial constraints and other query criteria.

        QGIS has a native WCS provider. Downloading the data directly in QGIS is convenient if the goal is to visualize or explore few layers. But what if you use the data as input in e.g. a modeling pipeline in Python? In that case, being able to access the data from Python will greatly simplify your life. Below I’ll provide an example of how to access the data from Python using the OWSlib package.

        In this post I’ll use the Python OWSlib package. Full documentation about this package can be found here, including installation instructions. The example below is based/inspired on the examples provided in this collection of Jupyter notebooks. Note that there are two versions of the WCS standard, the 1.0.0 and 2.0 versions. The latest version introduces some important improvements. However, I couldn’t get it to work with my dataset, so I’ll use version 1.0.0. As soon as I have figured out what I am doing wrong using version 2.0, I’ll update this post.

        For each different soil property predicted in SoilGrids there is an independent service. Check the web page maps.isric.org for all the services available. In this post, we’ll use the service for the soil pH as example. First step is to check which grid layers are available using the WebCoverageService function, which issues a GetCapabilities request. As input we provide the URL and the variable.

        This gives us a service connection. From this the available coverages (maps) can be accessed with the contents property. This returns a dictionary of 24 coverages, combining six standard depth intervals with four quantiles. Below, this dictionary is converted to a list for easier printing. Below only the first 6 layers are shown.

        We can easily filter out specific layers. For example, with the code below we filter out the layers reporting the average predictions for each of the standard depth intervals.

        To download a layer for a specific region, we can use the getCoverage function. Note that we need to establish the coverage service connection first (we already did this above). The getCoverage function needs the following parameters: the variable (identifier), the coordinate reference systems (crs), the horizontal (resx) and vertical (resy) resolution, the bounding box (bbox) and the output format (e.g., GEOTIFF_INT16).

        The format for the crs is defined as follows: urn:ogc:def:crs:EPSG::4326 . So we only need to look up the EPSG identifier for the projection in which we want to have the data. The EPSG 4326 is the identifier for the World Geodetic System 1984 (in short WGS 84). For the Amersfoort / RD New projection, the EPSG identifier is 28992. So, we would use crs = 'urn:ogc:def:crs:EPSG::28992' .

        The resolution needs to be in the projection’s unit. So, for EPSG 4326 you define the resolution in degrees, while for EPSG 28992 the resolution should be given in meters. The bounding box is defined by the coordinates of the lower left and upper right corner of your region of interest. This takes the following form: bbox = (minimum x, minimum y, maximum x, maximum y) .

        In the example below, we download the layer for a 16 hectare site in the municipality of Meierijstad in the south of the Netherlands. A new forest garden was established here a few years back, and our students of the Applied Geo-information Science program are involved in a monitoring program as described here. The bounding box of this region is (159750, 403750, 160500, 404750). we’ll download the data in RD New projection and 250 meter resolution.

        Next step is to inspect and print the map. For that, we’ll use the rasterio library. We can open the file with rasterio.open() function and subsequently read the metadata with the profile method. By wrapping the latter in a with. statement, the statement is executed once the file is opened, and the file is closed when the context manager exits. This means there is no need to manually close the raster file. This use of a so-called context manager is further explained here.

        We can see that we are dealing with a single layer Geotiff (Gtiff) file, with a dimensions of 3x4 and that the projection is EPSG 28992. No surprise here of course. To learn more about getting raster properties and statistics, see here.

        To plot the file, we can use the rasterio.plot.show() function of rasterio. We first import the show function. This time, we do not use the with statement. That means that when we are done, we need to close the connection explicitly with the close() method.

        pH H20 for the top 5 cm layer, from soilgrid.org

        The show() function does not show the legend. If we want to plot the legend, we need to use matplotlib’s pyplot.imshow function to plot the raster layer, and use the pyplot.colorbar() to plot the legend.

        The result is shows below. On the x- and y-axes the column and row numbers are given, rather than the coordinates. I haven’t really tried to get it to print with the proper coordinates, as for me this only serves for a quick look at the data anyway.

        pH H20 (x 10) for the top 5 cm layer, from soilgrid.org

        The advantage of scripting is that one can combine different tools in one pipeline. In the example below, the same code as above is used to download the pH layer. However, the region of interest and resolution are set using the g.region function from GRASS GIS. And the raster layer is imported in the GRASS GIS database.

        Note that to run the examples above, you need to start GRASS GIS and use the integrated Python editor to run the code. Alternatively, you can start up your favorite Python IDE from the GRASS GIS console. This ensures that you can access the GRASS GIS functionality from within Python. For more information about using Python and GRASS GIS, see this wiki page. If you are new to GRASS GIS, you may want to start with this introduction.

        pH H20 (x10) for the top 5 cm layer, from soilgrid.org

        See also this site for more information about how to access the soilgrid data in Python. Of, if you want to use the data in R, see see here) for an explanation how to download the data using R and gdal.

        Sur Oslandia: (Fr) Oslandia recrute : ingénieur(e) développement C++ / Python – OSL2011B

        Опубликовано: 24 November 2020, 12:39pm CET

        Sorry, this entry is only available in French.

        Sur gvSIG Team: Novedades gvSIG Desktop 2.5.1: Buscador de herramientas

        Опубликовано: 23 November 2020, 11:58am CET

        Esta nueva funcionalidad, disponible en la versión recientemente publicada gvSIG Desktop 2.5.1, puede ser muy útil para ejecutar de forma rápida herramientas en gvSIG Desktop o localizar alguna que no sabemos exactamente dónde está.

        Su funcionamiento es muy sencillo y os quedará muy claro viendo el vídeo que acompaña a este post. Una vez lanzado el buscador de herramientas, que podemos tener siempre abierto, podemos filtrar y seleccionar entre todas las herramientas disponibles en gvSIG Desktop.

        Para mostrar el funcionamiento he aplicado el juego de iconos «Black», al que muchos no estaréis acostumbrados, pues no es el estilo por defecto de gvSIG Desktop. Y siguiendo este ejemplo, he utilizado el buscador de herramientas para ir ejecutando diversas acciones: abrir tabla, lanzar el buscador alfanumérico, activar el botón de información,…

        Otros post sobre las novedades de gvSIG Desktop 2.5.1:

        Sur GeoTools Team: GeoTools 24.1 released

        Опубликовано: 23 November 2020, 10:52am CET

        Sur GeoServer Team: GeoServer 2.18.1 Released

        Опубликовано: 23 November 2020, 1:00am CET

        This release is made in conjunction with GeoTools 24.1 and GeoWebCache 1.18.1. This is a stable release recommended for production systems.

        Thanks to everyone who contributed, and Alessandro Parma, Andrea Aime (GeoSolutions) for making this release.

        This release includes a number of improvements. Notable improvements:

        • New option allow to tile cache WMS requests that align to gridsets, even if tiled=true is not present.
        • New process grouping features by attribute, and then selecting a single one out of the group, in particular, the feature with the min or max value of a given attribute. Can be used either as a rendering transformation or a stand-alone WPS process.
        • GeoFence integrated UI allows to configure security rules by IP address ranges.

        Fixes included in this release:

        • Better WPS packaging, including the required CSV libraries.
        • Better support for WMS XML post requests in workspace local services.
        • Addressed incompatibility with macOS 11 preventing startup

        For more information check the 2.18.1 release notes.

        For developers building from source, our community modules are a great place to collaborate on functionality and improvements.

        Additional information on GeoServer 2.18 series:

        Sur From GIS to Remote Sensing: Major Update: Semi-Automatic Classification Plugin v. 7.1.0

        Опубликовано: 22 November 2020, 2:51pm CET

        I'm glad to release a new update of the Semi-Automatic Classification Plugin v. 7.1.0. This is the first version after the first release 7.0 and includes several bug fixing for several tools, therefore I recommend to update the plugin to the latest version.
        Also, a new feature allows to import the polygons in a GeoPackage vector directly to the training input calculating the spectral signature thereof.

        For any comment or question, join the Facebook group about the Semi-Automatic Classification Plugin.

        Sur gvSIG Team: Journées Internationales gvSIG 2020 – Présentation en français – Suite gvSIG : Solutions libres pour la gestion territoriale

        Опубликовано: 20 November 2020, 5:23pm CET

        Lors des journées internationales gvSIG ( du 4 au 6 Novembre dernier) a été effectuée une présentation en français sur l’importance actuelle de la géomatique et des données géographiques, et sur les solutions pouvant être apportées par l’Association gvSIG concernant la gestion territoriale, au travers de la Suite gvSIG, composée d’un logiciel SIG corporatif (gvSIG Desktop), d’une plateforme intégrale pour l’intégration d’Infrastructures de Données Spatiales (gvSIG Online) et d’applications SIG mobiles (gvSIG Mobile et gvSIG MApps).

        Voici le lien vers la vidéo de cette présentation !

        Sur gvSIG Team: Marco de topología en gvSIG Desktop y nuevas reglas topológicas

        Опубликовано: 20 November 2020, 8:50am CET

        En gvSIG Desktop 2.5.1 podéis acceder al marco de topología de gvSIG Desktop, una herramienta muy importante para realizar ciertos procesos de edición cartográfica. El marco de topología se está mejorando con la inclusión de nuevas reglas topológicas, y de todo eso se habla en la grabación de esta ponencia de las Jornadas Internacionales de gvSIG.

        Si aún no conoces el marco de topología de gvSIG Desktop, es hora de descubrirlo.

        Sur PostGIS Development: PostGIS 3.0.3

        Опубликовано: 20 November 2020, 1:00am CET

        The PostGIS Team is pleased to release PostGIS 3.0.3.

        Continue Reading by clicking title hyperlink ..

        Sur Paul Ramsey: Waiting for Postgis 3.1: Vector tile improvements

        Опубликовано: 19 November 2020, 9:00pm CET

        This is a guest post from Raúl Marín, a core PostGIS contributor and a former colleague of mine at Carto. Raúl is an amazing systems engineer and has been cruising through the PostGIS code base making things faster and more efficient. You can find the original of this post at his new personal tech blog. – Paul

        I’m not big on creating new things, I would rather work on improving something that’s already in use and has proven its usefulness. So whenever I’m thinking about what I should do next I tend to look for projects or features that are widely used, where the balance between development and runtime costs favors a more in depth approach.

        Upon reviewing the changes of the upcoming PostGIS 3.1 release, it shouldn’t come as a surprise then that most of my contributions are focused on performance. When in doubt, just make it faster.

        Since CARTO, the company that pays for my lunch, uses PostGIS’ Vector Tile functions as its backend for dynamic vector maps, any improvement there will have a clear impact on the platform. This is why since the appearance of the MVT functions in PostGIS 2.4 they’ve been enhanced in each major release, and 3.1 wasn’t going to be any different.

        In this occasion the main reason behind the changes wasn’t the usual me looking for trouble, but the other way around. As ST_AsMVT makes it really easy to extract information from the database and into the browser, a common pitfall is to use SELECT * to extract all available columns which might move a lot of data unnecessarily and generate extremely big tiles. The easy solution to this problem is to only select the properties needed for the visualization but it’s hard to apply it retroactively once the application is in production and already depending on the inefficient design.

        So there I was, looking into why the OOM killer was stopping databases, and discovering queries using a massive amount of resources to generate tiles 50-100 times bigger than they should (the recommendation is smaller than 500 KB). And in this case, the bad design of extracting all columns from the dataset was worsened by the fact that is was being applied to a large dataset this triggered PostgreSQL parallelism requiring extra resources to generate chunks in parallel and later merge them together. In PostGIS 3.1 I introduced several changes to improve the performance of these 2 steps: the parallel processing and the merge of intermediate results.

        Without getting into too much detail, the main benefit comes from changing the vector tile .proto such that a feature can only hold one value at a time. This is what the specification says, but not what the .proto enforces, therefore the internal library was allocating memory that it never used.

        There are other additional changes, such as improving how values are merged between parallel workers, so feel free to have a look at the final commit itself if you want more details.

        The best way to see the impact of these changes is through some examples. In both cases I am generating the same tile, in the same exact server and with the same dependencies the only change was to replace the PostGIS library, which in 3.0 to 3.1 doesn’t require an upgrade.

        In the first example the tile contains all the columns of the 287k points in it. As I’ve mentioned before, it is discouraged to do this, but it is the simplest query to generate.

        And for the second example, I’m generating the same tile but now only including the minimal columns for the visualization:

        We can see, both in 3.0 and 3.1, that adding only the necessary properties makes things 10 times as fast as with the full data, and also that Postgis 3.1 is 30-40% faster in both situations.

        Aside from speed, this change also greatly reduces the amount of memory used to generate a tile.

        To see it in action, we monitor the PostgreSQL process while it’s generating the tile with all the properties. In 3.0, we observe in the blue line that the memory usage increases with time until it reaches around 2.7 GB at the end of the transaction.

        We now monitor the same request on a server using Postgis 3.1. In this case the server uses around a third of the memory as in 3.0 (1GB vs 2.7GB) and, instead of having a linear increase, the memory is returned back to the system as soon as possible.

        To sum it all up: PostGIS 3.1 is faster and uses less memory when generating large vector tiles.

        Sur MapProxy: New MapProxy 1.13.0 release

        Опубликовано: 19 November 2020, 8:00pm CET

        We are pleased to announce the release of MapProxy 1.13.0.

        To upgrade within your virtualenv:

        MapProxy is now able to use the latest PROJ releases via pyproj.

        You can hide the source URLs in WMS exceptions with the new globals [http.hide_exception_url] option.

        Tile sources can contain @ characters in the path of the URL (e.g. for HiDPI tile URLs like /0/0/[email protected]).

        There are a lot more changes and improvements, especially regarding Python 3.8 compatibility.

        For a complete list of see: [github.com]

        Sur Fernando Quadro: Série: Como desenvolver seu WebGIS

        Опубликовано: 19 November 2020, 4:03pm CET

        No mês de outubro e novembro produzi a série intitulada “Como desenvolver seu WebGIS” com o intuito de elucidar alguns pontos referentes a escolha de ferramentas (open source) para tal fim.

        A série está disponível no canal do YouTube da Geocursos e foi dividida em 6 episódios:

        1. Banco de dados espacial

        Sur gvSIG Team: Taller disponible: Normalización radiométrica e índices de vegetación en mapeo de incendios con gvSIG

        Опубликовано: 19 November 2020, 12:47pm CET

        Ya tenéis disponible la grabación del taller «Normalización radiométrica e índices de vegetación en mapeo de incendios», que fue impartido en las pasadas Jornadas Internacionales gvSIG.

        En el taller se trabaja con un método de normalización, mediante la sustracción de píxeles oscuros basado en el histograma de la imagen. Se utilizan imágenes Sentinel 2 de la Agencia Espacial Europea (ESA) con la siguiente secuencia o flujo de trabajo:

        Preprocesamiento de las imágenes

        Transformación a formato tif de las bandas

        Reasignación de los valores No Data

        Conversión a valores enteros de 16 bits

        Procesamiento o calibración a valores de reflectancia

        Sustracción del píxel oscuro

        Generación de índices de vegetación.

        La cartografía para poder seguir el taller puede descargarse en el siguiente enlace.

        Sur gvSIG Team: Disponible el programa de las Jornadas GeoLIBERO (online) con inscripciones gratuitas

        Опубликовано: 19 November 2020, 10:40am CET

        Ya está disponible el programa de las 1as Jornadas Iberoamericanas GeoLIBERO. ¡Y no te las puedes perder!

        Las jornadas que se celebrarán del 23 al 27 de noviembre son online, permitiendo a cualquier persona interesada acceder a cualquiera de las actividades que contempla el evento: ponencias, talleres y una interesantísima mesa redonda sobre ética y datos geográficos.

        Las inscripciones son gratuitas y pueden realizarse para cada webinar desde la página web del programa del evento.

        Estas Jornadas están organizadas por GeoLIBERO, una Red CYTED, formada por cerca de un centenar de investigadores, cuyo objetivo es consolidar y hacer sostenible en el tiempo una red temática de intercambio de conocimientos y de cooperación entre diferentes grupos de I+D+i de la región Iberoamericana relacionados con el ámbito de la Geomática y su aplicación a las necesidades y estudio de los problemas principales en Iberoamérica. Todo ello trabajando con software libre, impulsando la soberanía tecnológica de la región, y maximizando la transferencia tecnológica y de conocimiento.

        Sur gvSIG Team: gvSIG en cálculo de riesgos de inundación y prevención de incendios

        Опубликовано: 19 November 2020, 9:21am CET

        La Suite gvSIG se utiliza en los más diversos sectores, siendo aquellos que están relacionados con la seguridad y emergencias algunos de los más relevantes por las implicaciones que tienen. Entidades como la Dirección General de Emergencias y Protección Civil de España o el Consorcio Provincial de Bomberos de Valencia utilizan gvSIG desde hace ya unos años.

        Más allá de los grandes proyectos, hoy os traemos un par de ponencias muy interesantes presentadas en las pasadas Jornadas Internacionales de gvSIG y que cuentan como utilizar, de forma sencilla, la Suite gvSIG tanto para el cálculo del riesgo de inundación como para la gestión de datos e infraestructuras de prevención de incendios.

        gvSIG como herramienta auxiliar para el cálculo del riesgo de inundación

        Suite gvSIG para gestión de datos e infraestructuras de prevención de incendios

        Sur PostGIS Development: PostGIS 3.1.0alpha3

        Опубликовано: 19 November 2020, 1:00am CET

        The PostGIS Team is pleased to release the third alpha of upcoming PostGIS 3.1.0 release. This version is exposes some of the new performance and feature enhancements in not yet relesed GEOS 3.9 as well as numerous speed enhancements not requiring newer GEOS. Requires GEOS 3.6+ and PostgreSQL 9.6+. To use MVT you will need protobuf-c 1.1. or higher.

        PostgreSQL 13.1, GEOS 3.7 or higher is recommended.

        Continue Reading by clicking title hyperlink ..

        Sur XYCarto: Static Vector Tiles for Small Projects

        Опубликовано: 18 November 2020, 10:32am CET

        The following covers a method for visualizing a complex vector tile dataset using a static server. This particular blog is more for beginners and reduces the technical terms as much as possible. I wouldn’t recommend this method for large complex vector tile data sets, but instead for quick one-off sites that are looking to incorporate a small number of vector tiles where the GeoJSON might be too large/complex to handle.

        If you just want to skip to the map and code, visit the Github page created for this blog.

        Here is the big reveal at the beginning. If you want to serve a basic vector tile locally or with a static server:

        1. Create an tile cache with uncompressed .pbf files
        2. Place that tile cache on something like GitPages, e.g. embed the tile cache directly along with your website or embed the cache on your localhost along with the other site files
        3. In Leaflet, access the tile cache using ‘L.vectorGrid.protobuf()’

        If you’d like to read more in depth:

        I work on a Ubuntu OS however, the methods below will just as easily work with iOS and Windows environments. The parts for building the site, e.g. the HTML, JS, CSS and GitPages, are OS agnostic.

        If you want to follow the steps outlined you will need to have installed:

        You will also need a Github account and a basic knowledge of building a webpage .

        Here are the two stacks depending on your needs:

        • Web Mercator: GDAL, OGR2OGR, Tippecanoe, Leaflet, GitPages
        • NZTM: GDAL, OGR2OGR, PostGIS, T-Rex, Leaflet, GitPages

        The basic premise is this: with your vector file, you need to construct a tile cache with uncompressed PBF files. The tile cache is the same as any XYZ tile cache you would use for raster tiles, except you are filling it with .pbf files. That tile cache will need to reside in a location accessible by your Leaflet application. In this example we are using GitPages as our server and embedding our tiles directly along with the website we built. Technically, Gitpages is acting as the server. If you are testing and serving on localhost, just embed your tile cache with your web files.

        I am going to keep the code light for this blog and instead layout the steps. You can find full code examples in my Github repository here.

        Building Your Own Contours

        If you download the entire dataset, you can create the contour lines from the VRT. This saves a lot of time by not creating a mosaic.

        If you are building a Web Mercator site, you can use Tippecanoe to render the tile cache. You need to create a GeoJSON of your shapefile first

        If you are building an NZTM site you will need to use T-Rex to generate the NZTM tile cache for the vector tiles. T-Rex likes best if you can give it a PostGIS table to work from. I’d also recommend simplifying complex contour data sets. Your tile generation will be much faster.

        Upload to PostgreSQL (you can upload the original NZTM shapefile)

        Note the tile size you are setting. You will need this later for your Leaflet application

        Important bit for Leaflet

        See the GitPages site for how to set up the Leaflet JS in NZTM

        Sur Jackie Ng: Experimental Azure PaaS support in the SQL Server FDO provider

        Опубликовано: 18 November 2020, 10:01am CET

        Do you use MapGuide? Do you also use SQL Server on Azure and have lamented for the longest time the inability of the SQL Server FDO provider to read/write data to a Azure-PaaS-hosted SQL Server db?

        Then boy, do I have news for you!

        Thanks to some day-job dogfooding of FDO Toolbox and a test Azure account on hand I have finally tackled this 7 year old FDO ticket and landed experimental support for SQL Server on Azure PaaS.

        You can download the 7zip archive of the patched provider from here.

        Download, extract and overwrite the existing provider dll in your MapGuide Open Source 4.0 preview or FDO Toolbox 1.5.1 installation.

        I have so far verified this provider can perform most provider operations needed for use in a MapGuide context.

        The only operation I couldn't verify was whether the FDO CreateDataStore API worked for this provider in Azure PaaS due to insufficient permissions in the test account I was given. The CreateDataStore API is not used in the MapGuide context, so if this API doesn't work properly on Azure PaaS, it is not a deal breaker for use in MapGuide.

        I'd be interested from anyone who tries this patched provider to let me know if this particular API works on Azure PaaS (ie. You can create a new FDO data store on Azure PaaS via FDO Toolbox with this patched provider)

        Many thanks to Crispin Hoult of TrueViewVisuals (FKA LinkNode) for the original patch, which I had tweaked so the azure db detection is a runtime check instead of support you have to explicitly compile into the provider dll. If we had been using Azure PaaS earlier, the patch wouldn't have taken 7 years to finally be applied!

        Sur CARTO Blog: 7 Reasons Why CPG Marketers Are Turning To Location Analytics

        Опубликовано: 18 November 2020, 10:00am CET

        Sur gvSIG Team: GIS for appropriate flood risk planning in Sudan

        Опубликовано: 18 November 2020, 8:46am CET

        The benefit of this project is to map flood hazard and to determine flood risk zones for early warning system in state of Khartoum, Sudan as the pilot project In order to use the same method to identify the flood hazard in other states of Sudan, using Geographic Information System gvSIG to reduce the vulnerability of people and public and private property for sustainable economic development.

        In mid-July 2020 Floods have ravaged Sudan.

        Climate changes are responsible for flood occurrence in Sudan which are result of high temperature , precipitation, heavy rain and seasonal variations.

        At least 100 people have died and more than 110,000 homes destroyed, residents take refuge in high places, and some families were forced to take shelter and protect themselves in schools and other local building.

        The Sudanese government declared a state of emergency for three months and designated the country a natural disaster zone.

        GIS is powerful tool for identifying and mapping of potential flood risk zones. To determine flood risk zones for early warning.

        Some researchers applied a GIS-based approach to conduct flood hazard mapping with different parameters (i.e. land use, land cover, DEM, soil, river network, and slop).

        The Open Source Geographic Information System gvSIG has become a reliable alternative for many users, especially for less development countries like Sudan, where limited budgets projects cannot provide the cost of installing and maintaining the commercial software.

        The present pilot project proposes technique of flood sensitivity mapping using Geographic Information system gvSIG and factors as elevation, slope , land use, flow accumulation, surface roughness, topographic wetness index and curvature of the topography were digitized and then contributed in the mapping of flood.

        Sur gvSIG Team: Sistema Estadual de Informações Geográfica do Estado do Tocantins

        Опубликовано: 17 November 2020, 1:30pm CET

        O principal objetivo deste trabalho é apresentar o desenvolvimento e a implementação da Infraestrutura de Dados Espaciais do Estado do Tocantins. Para alcançar este objetivo, foi necessário catalogar, integrar e harmonizar os dados geoespaciais existentes para que pudessem ser facilmente localizados, explorados e acessados por qualquer usuário através da Internet. O sistema é utilizado para armazenamento, visualização, análise e disponibilização (download) de dados/ informações geoespaciais e estatísticas geradas na área do Zoneamento Ecológico-Econômico do Estado do Tocantins, integrando vários repositórios de dados geográficos na interface WebGIS.

        O projeto foi desenvolvido utilizando software livre, baseado no gvSIG Online, uma plataforma para a implementação de Infraestruturas de Dados Espaciais que integra componentes como o servidor de mapas GeoServer, o cliente WebGIS OpenLayers e o banco de dados espacial PostgrSQL/PostGIS.

        O Sistema de Informações Geográficas do Estado do Tocantins dispõe de um conjunto de Geoportais e serviços padrão (WMS, WMTS,…) que permitem consultar todas as informações geográficas e estatísticas relacionadas com cada um dos projetos desenvolvidos para o Estado e diferentes regiões (Sudeste e Norte do Estado). Para a gestão dos metadados foi utilizado o GeoNetwork utilizando a estrutura da CONCAR com a ISO 19115.

        Entre as capacidades mais destacadas do gvSIG Online está a possibilidade de gerar tantos geoportais públicos quanto privados, como forem necessários e em apenas poucos minutos, aplicação de múltiplas legendas, acesso a atributos associados as informações geográficas, impressão através de modelos pré-definidos de layouts, download de dados e ferramentas de seleção gráfica e alfanumérica. Além disso, para usuários com o papel de editor, o geoportal permite as modificações de informações (gráficas e alfanuméricas) a partir do próprio Sistema Online.

        Como uma parte relevante do projeto, todas as informações geoespaciais disponíveis foram adaptadas para sua integração na SDI e seu armazenamento no banco de dados espacial. Para este fim, trabalhamos com o SIG (também software livre) gvSIG Desktop, aplicando processos de mudanças de formato, reprojecções e geoprocessamentos dos diversos dados fornecidos pela SEFAZ.

        Entre os diferentes geoportais gerados nesse projeto, existe um projeto relacionado a dados estatísticos que inclui informações tais como demografia (estimativa população, população residente por situação do domicilio, população censitária municipal e população residente por cor, raça e situação), econômicas (PIB e PIB per capita), Educação (professores, instituições, taxas de abandono, matrículas, …), lavoura permanente e temporária, pecuária e saúde (taxa de mortalidade infantil, casos confirmados de várias doenças, …). A fim de proporcionar ao sistema uma maior funcionalidade geoestatística, foi desenvolvida uma série de ferramentas que integram as capacidades dos geoportais com painéis de controle que permitem a visualização e download de diferentes tipos de gráficos (barras, círculos e linhas).

        Sur CARTO Blog: Short Term Rental Data from Transparent now available in CARTO

        Опубликовано: 17 November 2020, 10:00am CET

        Sur gvSIG Team: Spatial Data Infrastructure and Central Address System of Uruguay

        Опубликовано: 17 November 2020, 9:40am CET

        Two projects that have allowed to evolve the geographic information management in the Government of Uruguay are presented. Both projects are based on the gvSIG Suite technologies, a catalog of open source software solutions where gvSIG Online is included, a product aimed at the Spatial Data Infrastructures implementation.

        The first of these projects is the implementation of the Uruguay Spatial Data Infrastructure, highlighting the volume of data that it is composed of and the technological improvements developed to meet the project requirements. The second one is the project for the implementation of a new Central Address System in the country, also based on gvSIG Online where a system for the maintenance of street maps by the municipalities (local administrations) has been implemented.

        Sur Paul Ramsey: BC IT Outsourcing 2019/20

        Опубликовано: 15 November 2020, 8:00am CET

        Way back in the 1980s, the Vander Zalm government privatized BC highways maintenance. They let out big contracts to private companies (fortunately this was before the era of international infrastructure firms, so they were local companies) and sold off the government road building machinery. The government employees union was naturally apoplectic and very much wanted the decision reversed. An NDP government took power at the next election, and… nothing changed.

        The omlette was unscramblable. The expense and disruption of re-constituting the old highways maintenance department outweighed the cost. The machinery was all sold. The government had other fish to fry. It didn’t happen then. It hasn’t happened yet. Highways maintenance is still outsourced.

        With that out of the way, here’s the latest data on BC information technology outsourcing.

        The political economy of changing the trend was never good. On the side of change, was a line in the Minister of Citizens Services 2017 mandate letter:

        Institute a cap on the value and the length of government IT contracts to save money, increase innovation, improve competition and help our technology sector grow.

        On the side of more of the same, are:

        • Existing relationships between civil servants and service providers.
        • Contractual obligations that still have multiple years to run.
        • Fear of change, including risk of service disruptions amidst big organizational changes.
        • Comfort of stasis, just renew contracts and keep slowly growing budgets.
        • Deep lack of political sexiness of internal IT issues.
        • No one at the political level who is invested in the issue. (See previous.)

        The UK IT reform experience, which is still ongoing in fits and starts, got off to a fast start because of the enthusiastic backing of the Cabinet Office Minister, Sir Francis Maude. It quickly hit the rocks after Maude retired and they lost his political cover.

        Getting out from under these contracts is the right thing to do, but it’s the right thing to do in very abstract and theoretical ways:

        • We want government to be more nimble and able to react to changes in society and policy.
        • The machinery of government runs on information.
        • The closer the people who work on the information are to the people working the policy, the easier it is for them to understand and react to their needs.
        • Outsourced IT places a contractual buffer between the people who need the information services and the people who provide those services. It optimizes for the predictable and charges heavily for the novel.

        There’s no easy big guaranteed win, and no press conference, and no glory. Just more reactive information services with incentives that align more closely to those of the people trying to deliver value to the people of BC. It’s technocratic, dull, worth doing, and probably not going to happen.

        Anyways, back to the horse race.

        The big surprise for me continues to be Maximus. Still billing strong, even with MSP premiums phased out? The MSP premium elimination date was January 1, 2020, so maybe this year will finally be the one we see a big drop in Maximus billings.

        The continued growth of local companies is a positive trend. These aren’t Mom’n’Pop shops, I don’t track those, but companies with revenues north of several millions. Altogether they are still doing less business than IBM alone, but it’s a solid 10% of the total now.

        It’s possible I’m being overly pessimistic. The biggest components of the IT outsourcing budget are the Telus and ESIT contracts, both of which end in 2021. But the easy thing is to just renew and move on, and in a world of Covid and recessions and many other issues much nearer to the daily lives of citizens I would not be surprised to see this issue languish.

        Sur Jackie Ng: MapGuide dev diary: The beginnings of clearing the final hurdle

        Опубликовано: 14 November 2020, 5:54pm CET

        I've stated many times in this long and arduous MapGuide Open Source 4.0 development cycle that the final hurdle that must be cleared before 4.0 could ever be considered final is when we can finally generate language bindings for .net, Java and PHP with a vanilla and un-modified version of SWIG.

        The reasons for needing to do this were already explained in my previous introductory post to these new bindings, but to re-iterate the cliff notes version:

        • We need to support and bundle PHP 7. This is non-negotiable. The current bundled PHP 5.6 is too old and long past EOL and it is a bad look to have to bundle this version of PHP for a production MapGuide deployment/installation.
        • The latest release of SWIG can generate bindings for PHP 7
        • The cross-platform .net core has grown in leaps and bounds over traditional windows-only .net Framework in terms of adoption. The just released .net 5.0 is a sign that the current windows-only .net Framework is dead/legacy and the future of .net is a cross-platform one.
        • As a result, if we're going to be supporting .net in MapGuide, we should be generating a .net binding that can work in both Windows and Linux.
        • And if we need to do that, we might as well do it with the latest release of SWIG
        • And if 2/3 languages require vanilla SWIG, we might as well go for the trifecta and generate our Java binding with it as well!

        As this final hurdle involves many steps, I figure this journey is worth documenting with its own mini dev diary series.

        So what has changed since the initial announcement of these experimental bindings?

        Firstly, I have decided to bring the current binding work into the official MapGuide source in a new vanilla_swig sandbox branch. All development work will continue in this branch. The previous GitHub repo housing this work will no longer be maintained and I will eventually archive/delete this repo. Going from Git back to SVN might sound like a downgrade (technically yes), but my developer "inner loop" has sped up a lot by having everything in the same repo and not having to coordinate files/changes across 2 different repos in 2 different locations. Maybe one day we'll permanently migrate the MapGuide source on GitHub, but today is not that day.

        Secondly, before I tackle the PHP 7 support, I wanted to see whether the .net/Java bindings were still functional and what other final improvements we can make before all attention is fully diverted to the PHP 7 binding.

        For Java, after some minor fix ups, the binding and its test suite were still A-OK. So onto the .net binding.

        When I introduced these new experimental bindings, the .net one was back to a single monolithic assembly (MapGuideDotNetApi). I wasn't fully comfortable with the monolithic assembly as it would hamper any attempts to write code that could work in both MapGuide and mg-desktop. The mg-desktop .net support was hanging off of the currently Foundation/Geometry/PlatformBase split assemblies. Having our new .net binding go back to a monolithic assembly would hamper our ability to write such shared code, so if it was possible we should try to replicate the Foundation/Geometry/PlatformBase/MapGuideCommon/Web split layout in the new .net binding.

        Using the current .net binding as a point of reference, splitting the monolithic MapGuideDotNetApi assembly back to the 5 constituent parts was a relatively simple affair. Thanks to the dramatically simplified csproj format we now have 5 hand-crafted C# projects targeting netstandard2.0 that reference each other and that SWIG dumps all its generated C# source into (without having to add each .cs file into the project itself) for easy compilation that automatically publishes out to respective nuget packages like so.

        And because our 5 projects reference each other, those dependencies are also expressed in the nuget packages themselves. That is to say, if you install the MapGuideCommon package, it will automatically install the PlatformBase, Geometry and Foundation packages as well as they were defined as project dependencies of the MapGuideCommon C# project file.

        And the final cherry on top? These nuget packages are still self-contained and bundle the native dlls that the .net binding is wrapping. The current nuget packages are already self-contained, but they are only consumable in legacy .net Framework, are windows-only and require kludgy powershell hacks to make sure all the native dlls are copied out to the project's output directory. Our new nuget packages take advantage of the fact that native libraries are now first class citizens in the .net core packaging world.

        By adding such dlls to the runtimes/win-x64/native folder of a C# project, they will automatically be bundled into any nuget package created and the .net core project system knows to automatically copy these dlls out to the right location where the .net assembly can P/invoke them.

        Now for a multi-platform .net binding to work, we have to get SWIG to generate the same C++ glue code, but this time to be compiled on Linux but with the same library names so our SWIG-generated C# code will correctly P/Invoke into the respective Windows .dll or Linux .so, and pack those compiled .so files into the runtimes/linux-x64/native folder of our 5 C# projects.for automatic bundling into our nuget package.

        How we are able to do this will be the topic of a future post once I've figured it all out.

        Sur Stefano Costa: Replacing the battery of Huawei P10 Lite with iFixit

        Опубликовано: 13 November 2020, 11:32pm CET

        A few months ago the battery of my smartphone, a regular Huawei P10 Lite, started acting abnormally. Not only battery life had become very short, but some activities like trying to take a photograph would make the phone shutdown immediately. The phone is now 3 years old and I was not happy about buying a new one just because the battery is damaged. Still, I was almost ready to buy a Fairphone 3+ when I decided I could try replacing the battery. After all, I have some experience with hardware repair!

        The iFixit guide is very detailed and, most importantly, you can buy the replacement battery and all repair tools for 25 euro. It’s worth trying!

        As many commenters point out, the most time consuming part is removing the battery after all other parts have been moved, since there’s a lot of glue. It took me more than one hour and despite my best efforts it came out slightly bended. I didn’t break it though, which seems more important. The iOpener is quite effective however, as are the other tools.

        Putting back enough adhesive to keep everything together is also a long operation, because you will need to cut small pieces of the right length and width. The tools work well even for this part of the repair.

        At the end I was not even sure the phone would turn on, but it did, and what a satisfaction. I only had to throw away the old battery (at the correct collection place) and the “old” phone is almost like new. The battery now lasts for 36 hours or more, and I can hope to keep it running for a few more years.

        I could have asked a repair shop, but even though it’s a pure hardware repair, I was not comfortable leaving my personal phone to someone else. And it would have been more expensive, of course.

        I wanted to write this short post to let everyone know that repairing your phone is possible, thanks to great communities like iFixit, and you should avoid throwing away a literal goldmine just because it’s slightly damaged.

        The crucial moment before putting the new battery in place Here you can see the old battery that came out slightly bent I put back lots of adhesive myself – at least I hope so The new battery is in place and the back lid is about to be closed

        Sur gvSIG Team: gvSIG Desktop 2.5.1: Herramienta de búsqueda avanzada

        Опубликовано: 13 November 2020, 6:26pm CET

        Una de las novedades más llamativas de gvSIG Desktop 2.5.1 son las denominadas fichas de búsqueda o herramienta de búsqueda avanzada. En las pasadas Jornadas Internacionales de gvSIG se presentó un caso de uso de las fichas de búsqueda cuya grabación tenéis aquí mismo y que os servirá para entender todo el potencial de esta nueva herramienta.

        Seguid leyendo, porque lo que viene es una breve descripción de una herramienta de consulta mucho más potente de lo que podrías imaginar…

        La herramienta de búsqueda avanzada la podremos aplicar a cualquier tabla de nuestro proyecto, tanto para ficheros como para bases de datos. Lo más interesante es que está ficha de búsqueda es fácilmente personalizable y adaptable a nuestras necesidades de consulta (en el vídeo hay ejemplos muy claros de cómo realizar estas adaptaciones con unos pocos clics).

        Por un lado, podremos utilizar una búsqueda simplificada, que nos permitirá seleccionar los campos por los que queremos realizar la búsqueda y que nos puede llegar a permitir el seleccionar, para nuestras búsquedas, campos de otras tablas a través de claves ajenas (ejemplos en el vídeo).

        Mediante la búsqueda simplificada se pueden configurar búsquedas mediante operadores entre campos, definir el comportamiento de las búsquedas ante valores nulos, trabajar con valores en diccionarios, etc. (de nuevo, ejemplos de todo esto en el vídeo).

        Por otro lado podemos utilizar la búsqueda avanzada que permite generar expresiones de búsqueda más elaboradas. Y ya os contamos que en gvSIG Desktop 2.5.1 la capacidad de generar expresiones tiene un potencial enorme.

        A estas se suman otras herramientas como la búsqueda personalizada, la acumulación de filtros, histórico de búsquedas, búsquedas favoritas, uso de etiquetas y/o nombres, etc.

        La herramienta de búsqueda es de esas novedades que por si solas contiene decenas y decenas de mejoras, y que amplían considerablemente el potencial de gvSIG Desktop.

        Todo esto no es más que una pincelada del potencial de la herramienta, así que lo mejor es que veáis el vídeo e inmediatamente después os descarguéis gvSIG Desktop 2.5.1 (¡si aún no lo habéis hecho!) y os pongáis a probarla.

        Sur Fernando Quadro: Novidades do GeoServer 2.18.0

        Опубликовано: 12 November 2020, 9:11pm CET

        Há aproximadamente um mês atrás, a equipe do GeoServer disponibilizou sua nova versão, a 2.18.0. Caso você ainda não saiba quais são as novidades dessa versão, nós preparamos um vídeo explicando tudo pra você:

        Sur gvSIG Team: Infraestructura de Datos Espaciales del Ayuntamiento de Cullera con gvSIG Online: del urbanismo a la gestión de aforos en playas

        Опубликовано: 12 November 2020, 12:01pm CET

        Cullera es uno de los municipios turísticos más conocidos de la Comunidad Valenciana, con una población de 22.000 habitantes que se multiplica por cinco en época estival. Estas características hacen que la gestión de la información con dimensión geográfica abarque numerosas áreas, desde las más frecuentes, como urbanismo y medio ambiente, a la de turismo. Dentro de un proceso de digitalización y apuesta por las nuevas tecnologías para optimizar la gestión y el servicio público a los ciudadanos, se planteó la puesta en marcha de una Infraestructura de Datos Espaciales. La tecnología seleccionada fue gvSIG Online, la solución en software libre de la Suite gvSIG para implantación de IDEs y generación de geoportales.

        Os traemos una presentación sobre el proyecto que se impartió en las pasadas Jornadas Internacionales de gvSIG, cuya grabación está disponible y recomendado visualizar a cualquier gestor municipal. Es un ejemplo por muchos motivos, entre otros el convertir la IDE en una herramienta transversal que implica los distintos departamentos municipales. También por como gracias a gvSIG Online, solventaron en cuestión de horas el disponer de un geoportal informativo del aforo de playas, necesidad derivada de la situación que el COVID ha generado en relación al distanciamiento social.

        Lo dicho, no os la perdáis, un ejemplo que seguro servirá a otras administraciones locales a sumarse a las cada vez más numerosas entidades que apuestan por gvSIG Online, para todo tipo de temáticas y en las más diversas geografías (aquí podéis contactarnos: [email protected]):

        Sur CARTO Blog: React to the Changing Face of Retail DIY with Behavioral Data

        Опубликовано: 12 November 2020, 10:00am CET

        Sur gvSIG Team: gvSIG Desktop 2.5.1: improvements related to advanced editing

        Опубликовано: 11 November 2020, 5:59pm CET

        In the recently published gvSIG Desktop 2.5.1, you can find a great number of novelties related directly or indirectly to editing tools, which, added to the existing tools, allow us to affirm that gvSIG is one of the most advanced applications for carrying out cartographic editing.

        Here you can see the list of novelties related to editing tools:

        Options in the View menu and in the ToC context menu have been added to be able to send a layer to front or back quickly.

        Possibility to select intersecting elements or contained elements, using “Shift” key.

        Possibility to choose which elements we want to select from a list when several elements are selected with the simple selection tool at the same time (very useful when we have several geometries at the same coordinates).

        New tool that allows to measure the angle between two segments from both line and polygon layer.

        About it you will find a post in the next days because it involves a lot of improvements by itself.

        Possibility to copy alphanumeric data from one geometry, and paste them into another one (including data from another table).

        Possibility to copy geometries on an insertion point, copying alphanumeric data too.

        Possibility to use the points saved with the coordinate capture tool in the editing tools has been added.

        Possibility to insert formulas when inserting points. It allows to insert points with relative coordinates, use saved points with the coordinate capture tool or work with polar coordinates.

        New functionalities in the ‘insert circle’ tool have been added, from two tangent lines and a point, and from the tangents to two geometries and their radius

        New functionalities in the ‘insert circumference’ tools have been added, from two tangent lines and a point, and from the tangents to two geometries and their radius

        Possibility to insert arcs from the center and start and end points, and from three points (start, middle and end). Optional parameters have been added: radius, starting angle, sweep angle, and direction (CW and CCW).

        Possibility to add ellipses from the center and the axies has been added.

        Possibility to add filled ellipses from the center and the axies has been added.

        Possibility to apply snapping to objects on active layers, not only on layers that we have indicated in the properties of the View.

        Possibility to enter the distance value graphically by measuring on the View, to select the side on which we want to make the parallel geometry graphically when the distance has been entered by value and multiple parallel (several parallels at the same distance) has been added.

        At the latest International gvSIG Conference there was a presentation where these novelties about advanced editing tools were shown:

        Sur gvSIG Team: gvSIG Desktop 2.5.1: mejoras relacionadas con edición avanzada

        Опубликовано: 11 November 2020, 1:41pm CET

        En la recientemente publicada gvSIG Desktop 2.5.1, podéis encontrar un buen número de novedades relacionadas directa o indirectamente con la edición, que sumadas a las herramientas ya existentes, permiten afirmar que gvSIG es una de las aplicaciones más avanzadas para realizar edición cartográfica.

        Vamos con el listado de novedades relacionadas con edición:

        Se han añadido opciones en el menús Vista y en el menú contextual del ToC para poder cambiar el orden de las capas de forma rápida.

        Se añade la posibilidad de seleccionar elementos que intersecten o elementos contenidos, utilizando la tecla de «mayúsculas».

        Se añade la posibilidad de elegir qué elementos queremos seleccionar de un listado, en el caso de que se seleccionen varios elementos a la vez al utilizar la herramienta de selección simple (muy útil cuando hay varias geometrías en las mismas coordenadas).

        Nueva herramienta que permite medir el ángulo entre dos segmentos, tanto en capas de líneas como de polígonos.

        Sobre esto tenéis un post aparte, ya que conlleva muchas mejoras por si mismo.

        Copia de datos alfanuméricos

        Posibilidad de copiar los datos alfanuméricos de una geometría y pegarlos en otra, incluso entre tablas/capas distintas.

        Se añade la posibilidad de copiar las geometrías a partir de un punto de inserción, copiando también los datos alfanuméricos.

        Se añade la posibilidad de utilizar los puntos guardados con el capturador de coordenadas en las herramientas de edición.

        Posibilidad de utilizar expresiones para la inserción de puntos, lo que permite insertar puntos por coordenadas relativas, utilizar en las expresiones puntos guardados con el capturador de coordenadas y trabajar con coordenadas polares.

        Se ha añadido la posibilidad de insertar círculos a partir de dos tangentes y un punto, y a partir de las tangentes a dos geometrías y su radio.

        Se ha añadido la posibilidad de insertar circunferencias a partir de dos tangentes y un punto, y a partir de las tangentes a dos geometrías y su radio

        Se ha añadido la posibilidad de insertar arcos bien a partir del centro y los puntos de inicio y final, bien a partir de tres puntos (inicial, medio y final). Se han incorporado parámetros opcionales: radio, ángulo inicial, ángulo de barrido y dirección.

        Se ha añadido la posibilidad de dibujar elipses a partir del centro y los ejes.

        Se ha añadido la posibilidad de dibujar elipses rellenas a partir del centro y los ejes.

        Referencia a objetos (Snapping)

        Se ha añadido la posibilidad de hacer referencia a objetos sobre capas activas, no solo sobre capas que tengamos indicadas en las propiedades de la Vista.

        Se ha añadido la posibilidad de introducir el valor de la distancia gráficamente mediante la medición sobre la Vista, la posibilidad de seleccionar gráficamente el lado en el que se quiere hacer la geometría paralela cuando la distancia se ha introducido por valor y la posibilidad de realizar paralelas múltiples.

        En las pasadas Jornadas Internacionales de gvSIG se realizó una ponencia con demostración del funcionamiento de estas herramientas y cuya grabación ya está disponible:

        Sur CARTO Blog: Using Data & Maps to Analyze England's Response to COVID-19

        Опубликовано: 11 November 2020, 10:00am CET

        Sur GeoSolutions: Upcoming Free Webinar: From Esri Geodatabase to PostGIS and GeoServer, tips and tricks

        Опубликовано: 10 November 2020, 4:14pm CET

        We are excited to invite you to a new GeoSolutions free webinar "From Esri Geodatabase to PostGIS and GeoServer, tips and tricks" to be held on December 3rd at 11:00 AM ET. The Webinar will cover tips and tricks to export Esri Geodatabases to PostGIS and serving them via GeoServer.

        The Esri Geodatabase is the native structure of how Esri's products are store and share among and Esri's based infrastructure. Making a Geodatabase available to GeoServer so it can be access through WFS, without loosing any data, can be a little bit tricky. There are sophisticate tools that can help move the data from Esri sources to PostGIS. For example, FME, is such a tool that provides the ability to extract transform and load (ETL) data from one system to another. At GeoSolutions, we try to embrace and use open source solutions as much as possible in conjunction with open standards. The approach we usually follow consists of custom Python scripts using the QGIS Graphical Modeler to guide the process.

        [caption align="aligncenter"] Process to publish Geodatabase data to GeoServer[/caption]

        The process starts by exporting the Geodatabase to GeoPackage. Also, the workspace definition is exported so the PostGIS tables can be configured properly. We use scripts guided by QGIS Modeler to process the workspace definition and create the tables in PostGIS. Once the tables are available in PostGIS, the data can be published via GeoServer and available via WFS, Vector tiles, etc. Our process deals with the common blockers such as dealing with domain and subtypes that are instinct constructs of the Esri's geodatabase.

        Domains are used to create rules regarding the value of attributes. Let's say I'm modeling the results the US Elections per state, where I'm only going to store the result of the winning party.

        [caption align="aligncenter"] Domains[/caption] I can define a table State to capture these information. And, I can also define a rule regarding the values that the Winning_Party can take, by creating a Domain for the Winning_Party Attribute. The trick is making these information available to a Client Application that can, for example, use this information to restrict values for a web form. The other common issues is subtypes. From Esri's documentation, here is an example of subtypes used in conjunction with domains. [caption align="aligncenter"]
        Attribute domains and subtypes [bit.ly] Esri Geodatabases allows the creation of subtypes allowing to define entities that might have different domain in their attributes to better enforce the integrity of the data. At GeoSolutions we use declarative partitioning to model the Esri's subtypes constructs. [caption align="aligncenter"] Subtypes Modeling[/caption] Following the Streets example. A table Streets is created with an attribute subtype. The attribute subtype can have value Local_Subtype or Highway_Subtype. Then the following SQL statement are executed for each subtype tables -- Parent table CREATE TABLE Streets (id INTEGER, subtype INTEGER, code INTEGER, name VARCHAR(100)) PARTITION BY LIST(subtype) -- 'Local' partition CREATE TABLE Local_Streets PARTITION OF Streets FOR VALUES IN (1) ALTER TABLE Local_Streets ADD CONSTRAINT Streets_Local_FK FOREIGN KEY(code) REFERENCES Domain_Local_streets(code) -- 'Highway' partition CREATE TABLE Highway_Streets PARTITION OF Streets FOR VALUES IN (2) ALTER TABLE Highway_Streets ADD CONSTRAINT Streets_Local_FK FOREIGN KEY(code) REFERENCES Domain_Highway_streets(code)

        If done properly, all the data that is transferred that has domains and subtypes will be available in PostGIS and can properly be used by tools like GeoServer.

        If you want to learn more about this topic and see a demo, I invite you to join the free webinar, which will be given one of our lead engineers, Christian Picone. Register now so you will have the opportunity to hear more about this topic and ask anything you want to Christian.

        Hope to see you virtually on December 3th, meanwhile stay safe and keep strong!

        Sur Andrea Antonello: A better view on GPS logs in SMASH

        Опубликовано: 10 November 2020, 10:37am CET

        It is a while now that I am collecting gps logs done by car and bike to get a better idea on how to "correct" a bit jumping points. This is how the Kalman filter was added to the GPS points pipeline as additional information of choice (not always you want the corrected information).

        As usual, when working on stuff, you need to get a better view over things, which usually means also to get a qualitative idea of what is going on. This is how we got to gradient coloring of the gps lines.

        The result is actually quite cool and gives a good insight of what happened and when. So we decided that this will enter the next release of SMASH.

        The GPS log properties panel now has an additional combobox that permits the selection of a color palette for a particular information.


        If a palette is selected it overrides the solid color of the log, applying the palette to the line.

        The result in the case of elevation is something like:


        Which gives a pretty good idea about where the peak is. Also, assuming the temporal direction of the log, the downhill parts of the log are drawn with dotted border.

        You might want to know where the steep parts are, right? That is what slope can help you in:

        A maybe less interesting vision is the one colored by speed:

        And last but not least, it is possible to view the log by its accuracy. This can be quite interesting for surveyors, if they decide to pair to the survey a complete log, which will then tell them where accuracy was better. Obviously in the below map it is simple to see where the galleries are:


        I find this view of the GPS logs quite intriguing. Some might say that it would be better to have this information before a trip. and they are right. Which is why we added this coloring option also to gpx data layers. If the gpx contain the elevation information, then the elevation and slope palette are available:


        I hope you'll also enjoy it. in the next release :-)

        Sur CARTO Blog: CARTO BigQuery Tiler Upgrade Gives Speed & Feature Boost

        Опубликовано: 10 November 2020, 10:00am CET

        Sur gvSIG Team: gvSIG Desktop 2.5.1: Explorando el potencial del generador de expresiones

        Опубликовано: 10 November 2020, 9:58am CET

        Entre las novedades más importantes de gvSIG Desktop 2.5.1 se encuentran todas las mejoras que se han introducido en el generador de expresiones, que permiten aumentar de forma exponencial el potencial de gvSIG Desktop como herramienta para analizar la información.

        Una expresión es una operación con la que se obtiene un resultado y estas expresiones pueden ser tan simples o complejas como necesitemos, pudiendo utilizar una gran variedad de operadores de todo tipo y variables como valores de campos, coordenadas, etc.

        Mediante el generador de expresiones, entre otras múltiples utilidades, podemos obtener resultados similares a los producidos cuando ejecutamos ciertos geoprocesos.

        También se puede utilizar para operar y realizar búsquedas entre tablas relacionadas (desde una tabla, buscar valores que están en otra tabla).

        La interfaz del generador de expresiones nos permite acceder a cientos de operadores, previsualizar resultados, informarnos de posibles errores en nuestras expresiones, guardar nuestras expresiones, acceder al histórico de expresiones, etc. Todo un potencial que vale la pena explorar.

        ¿Dónde podemos utilizar/encontrar el generador de expresiones?

        • Selección alfanumérica (filtro)
        • Calculadora de campo
        • Formularios/fichas de búsqueda (otra novedad de gvSIG Desktop 2.5.1)
        • Exportación de capas (para selección de valores a exportar y en ruta de capa)
        • Geoprocesos
        • Información rápida (QuickInfo)
        • Añadir en bases de datos
        • Edición
        • Etiquetas
        • Campos virtuales o calculados
        • Scripting

        En las pasadas Jornadas Internacionales de gvSIG Desktop hubo una ponencia donde se explica con todo detalle el funcionamiento del generador de expresiones, con ejemplos de uso. Vale mucho la pena que le dediquéis un momento. Lo tenéis disponible en el canal de YouTube de gvSIG:

        Sur gvSIG Team: Tutorial: Geoproceso Kernel con gvSIG Desktop para análisis de robos en transporte público

        Опубликовано: 9 November 2020, 5:10pm CET

        Como comenté en un post anterior, desde hace un tiempo alumnado de (cada vez más) universidades está realizando prácticas con la Asociación gvSIG, teniendo además la posibilidad de ser 100% en modalidad online. Y parte de esas prácticas está resultando en diversa documentación, que puede ser de interés compartir.

        Hoy os compartimos un pequeño tutorial para analizar la distribución de los robos en transporte público, mediante el uso del geoproceso Kernel con gvSIG Desktop, que podéis descargar aquí:
        [downloads.gvsig.org]

        Como podéis ver son tareas muy sencillas, fáciles de replicar y enormemente útiles para interpretar un determinado hecho.

        Y de complemento, un pequeño documento que la misma alumna ha generado sobre las ventajas que ha encontrado en el uso de gvSIG Desktop y Online, explicadas con un ejemplo práctico de análisis de la problemática de violencia familiar en la zona metropolitana del Valle de Toluca:
        [downloads.gvsig.org]

        Rosario García Ramírez, de la UAEMEX es la estudiante que ha realizado los documentos de este post.

        Sur Jackie Ng: MapGuide 4.0 Showcase: Making WFS/WMS support beyond a box ticking exercise

        Опубликовано: 5 November 2020, 10:34am CET

        For the longest time, MapGuide's support for WFS and WMS was nothing too special. The level of support was the bare-minimum enough so that we could say "We support WFS/WMS"

        For MapGuide 4.0, the WFS and WMS support has been enhanced in the following areas:

        As I've previously mentioned, if we're going to serve feature data in a JSON format, we should just go straight to GeoJSON and not bother with anything else.

        This setting is only applicable if the Layer Definition itself has been set to be queryable for WMS.
        WFS Support for hit count
        The spec for WFS GetFeatures defines a special mode where one can request a hit count (ie. A raw total) instead of the actual raw feature data. MapGuide did not implement this part of the WFS spec (it is optional). For MapGuide 4.0, this is now implemented.
        If you pass resultType=hits to your WFS request, you now get a total instead of the feature data.

        As an aside, if you use VSCode on the regular, I highly recommend you install the REST client extension. It has replaced Postman for my [HTTP] API testing. As evidenced by the above screenshot, testing HTTP requests is dead simple.
        Special thanks to OpenSpatial for their assistance in testing out this feature.Viewer representation for WMS GetMapAs of the 4.0 preview 2 release, the mapagent now also supports a new viewer representation for WMS layers, giving you a built-in way to easily preview any published WMS layer in MapGuide by simply specifying a format of application/openlayers, which is a new option in the GetMap test page

        In this format, a HTML page is returned which contains an OpenLayers viewer set up to the WMS layer(s) in question.

        No more needing to fire up a client GIS application like Gaia or QGIS to preview such layers, MapGuide now provides the means to preview such layers out of the box!

        Sur gvSIG Team: Progetto GSOC 2020: Nuove regole per il framework di topologia in gvSIG Desktop (2)

        Опубликовано: 4 November 2020, 8:48am CET

        Fare compiti ripetitivi che non aggiungono valore, non ci incoraggiano a crescere, ci sfiniscono, sembrano essere compiti che non sono adatti a persone creative con un atteggiamento critico riflessivo. Quindi, automatizzare queste attività e garantire la qualità delle nostre sforzo o dedicare il nostro tempo a facere quello che può fare un automi programmabili?

        Rispondere a questa domanda è ciò che mi ha spinto a partecipare al progetto, New Rules for the Topology Framework in gvSIG desktop è stato sviluppato all’interno del programma GSoC in collaborazione con l’organizzazione OSGeo e l’Associazione gvSIG.

        L’obiettivo è sviluppare una serie di strumenti che consentano il trattamento degli errori topologici, automatizzando le attività di confronto della geometria attraverso regole di integrità che verificano e convalidano la relazione delle geometrie con i dati.

        Mentre avanzavamo nel progetto, era necessario correggere gli errori, sviluppare miglioramenti, generare nuove regole e azioni. L’automazione è stata effettuata tramite la tecnica di scripting, viene sviluppato un algoritmo che fornisce una soluzione alla logica definita dalla regola, permettendoci di ottimizzare l’utilizzo del tempo e per l’utente di concentrarsi sulla logica da risolvere mentre l’algoritmo si occupa dell’analisi e valutazione dei dati.

        La parte più impegnativa è stata la ricerca richiesta dal progetto e allo stesso procedere secondo i piani e raggiungere la qualità richiesta.

        Una di queste sfide era la regola Must not have gaps, in cui era necessario sviluppare funzioni accessorie che permettessero di svolgere un processo secondo quanto stabilito dalla norma e allo stesso tempo efficiente, per questo era necessario creare un metodo personalizzato per la pulizia del errori, che elimina le incongruenze nel risultato.

        Illustrazione 1. Risultato con metodo di differenza predefinito.

        Illustrazione 2. Risultato con metodo di differenza + metodo di pulizia personalizzato.

        Quest’anno oltre ad aver sviluppato le seguenti 6 nuove regole:

        Anche la qualità è stata migliorata sulla base dell’esperienza del 2019.

        Inoltre, spicca il miglioramento fornito dall’implementazione delle mark actions.

        Illustrazione 1. Mark point action. Regola Must not intersect with (linea)

        Illustrazione 2. Mark point action. Regola Must not intersect with (linea)

        Questa nuova implementazione migliora notevolmente la visualizzazione degli errori e restituisce le geometrie di questi in un nuovo layer, le mark actions velocizzano il processo di identificazione e correzione degli errori. Con il progetto è possibile automatizzare le attività ripetitive, ridurre gli errori e dare la possibilità all’utente di concentrarsi sull’obiettivo del progetto e non sulla parte tecnica, si ottiene semplicità nell’analisi dei dati e si ottimizza l’utilizzo del tempo.

        Penso che la cosa più importante sia vedere come attualmente abbiamo tutto pronto per garantire che il lavoro svolga la funzione che dovrebbe, essere un’attività che ci incoraggia a svilupparci come esseri umani, ora dipende da noi come decidiamo di svolgere le nostre attività.

        Per me è stato un orgoglio aver potuto qualificar per i periodi 2019 e 2020 di GSoC, apprezzo la fiducia ricevuta per permettermi di contribuire a gvSIG e alla comunità del software aperto. Il lavoro si è potuto svolgere grazie allo sviluppo del team con i tutor, principalmente Carlos Colombana, Óscar Martínez e con la communita degli sviluppatori, per me è stata un’esperienza arricchente e molto piacevole.

        Infine, voglio ringraziare Marisa Boggio per avermi aiutato a migliorare il mio italiano.

        La synergy generata nella collaborazione in team fa la differenza.

        Per me è un privilegio poter condividere il progetto con voi, grazie mille a tutti.

        Articolo scritto da Mauro Carlevaro

        Sur gvSIG Team: GSOC 2020 Project: New rules for the Topology Framework in gvSIG Desktop (2)

        Опубликовано: 4 November 2020, 8:47am CET

        Do repetitive tasks that do not add value, do not encourage us to grow, wear us out, they seem to be tasks that are not proper for creative people with a reflective critical attitude. So, automate tasks and ensure the quality of our activities or spend our time doing what a machine?

        Answering this question is what motivate me to participate in the project New Rules for the Topology Framework in gvSIG desktop, which was developed within the GSoC program in conjunction with the OSGeo organization and the gvSIG Association.

        The objective is to develop a set of tools that allow the treatment of topological errors, by automating the tasks of geometry comparison through integrity rules that verify and validate the relationship of geometries with the data.

        As we progressed, it was necessary to correct errors, develop improvements, generate new rules and actions. The automation was carried out through the scripting technique, an algorithm is developed that provides a solution to the logic defined by the rule, allowing save time and for the user to focus on the logic to be solved while the algorithm is in charge of the analysis and data evaluation.

        The most challenging part was the research required by the project and at the same time progressing according to plan and meeting the required quality.

        One of these challenges was the Must not have gaps rule, in which it was necessary to develop accessory functions that would allow a process to be carried out according to what is established in the rule and at the same time efficient, for this, a personalized method had to be made for cleaning errors, which eliminates inconsistencies in the result.

        Illustration 1. Result with default difference method.

        Illustration 2. Result with difference method + custom cleaning method.

        This year in addition to having developed the following 6 new rules:

        Also, was improved the quality of the development based on the experience of 2019. Furthermore, one of the improvement that stands out is the implementation of mark actions stands out.

        Illustration 3. Mark point action. Rule must not intersect with (line)

        Illustration 4. Mark point action. Rule must not intersect with (line)

        This new implementation significantly improves the display of errors and returns the geometries of these in a new layer, the mark actions speed up the process of identification and correction of errors.

        With the project it is possible to automate repetitive tasks, reducing errors, and give the user the possibility to focus on the project objective and not on the technical part, simplicity in data analysis is achieved and the use of time is optimized.

        I think the most important thing is to be aware that nowadays we have everything ready to ensure that work fulfills the function it should, be an activity that encourages us to develop as human beings, now it depends on us how we decide to carry out the tasks.

        I have been proud to have been able to qualify for the 2019 and 2020 periods of GSoC, I appreciate the trust received to allow me to contribute to gvSIG and the open software community. The work could be carried out thanks to team development with the tutors, mainly Carlos Colombana, Óscar Martínez and with the developer community, it was an enriching and very enjoyable experience. Furthermore, I want to thanks Luis Boggio for his suggestions to improve the article.

        The synergy generated in team cooperation makes the difference.

        For me it is a privilege to be able to share the project with you, thank you very much .

        Article written by Mauro Carlevaro

        Sur gvSIG Team: Proyecto GSOC 2020: Nuevas reglas para el Marco de Topología de gvSIG Desktop (2)

        Опубликовано: 4 November 2020, 8:47am CET

        El hacer tareas repetitivas que no nos aportan valor, no nos impulsa a crecer, nos desgasta, parecerían ser tareas no propias para personas creativas y con actitud crítica reflexiva. Entonces, Automatizar tareas y Asegurar la Calidad de nuestras actividades o pasar nuestro tiempo haciendo lo que una máquina?

        Dar repuesta a esta pregunta es lo que me atrajo para participar en el proyecto New Rules for the Topology Framework in gvSIG desktop, el cual se desarrollo dentro del programa de GSoC en conjunto con la organización OSGeo y la asociación gvSIG.

        El objetivo es desarrollar un conjunto de herramientas que permiten el tratamiento de errores topológicos, mediante la automatización en las tareas de comparación de geometrías mediante reglas de integridad que verifican y validan la relación de geometrías con los datos.

        A medida que fuimos avanzando fue necesario corregir errores, desarrollar mejoras, generar nuevas reglas y acciones. La automatización se realizó por medio de la técnica de scripting, se desarrolla un algoritmo que da solución a la lógica definida por la regla, permitiéndonos ahorrar tiempo y que el usuario se centre en la lógica a resolver mientras que el algoritmo se encarga del análisis y evaluación de los datos.

        La parte más desafiante fue la investigación que requirió el proyecto y a la vez avanzar acorde a lo planificado y cumpliendo con la calidad requerida.

        Uno de estos desafíos fue la regla Must not have gaps, en la cual fue necesario desarrollar funciones accesorias que permitieran realizar un proceso acorde a lo establecido en la regla y al mismo tiempo eficiente, para esto se tuvo que confeccionar un método personalizado para la limpieza de errores, el cual elimina inconsistencias en el resultado.

        Ilustración 1. Resultado con método difference predeterminado.

        Ilustración 2. Resultado con método difference + método de limpieza personalizado.

        Este año además de haber desarrollado las siguientes 6 nuevas reglas:

        También se mejoró la calidad en base a la experiencia del 2019. Además, destaca la mejora que aporta la implementación de las mark actions.

        Ilustración 3. Mark point action. Regla Must not intersect with (line)

        Ilustración 4. Mark point action. Regla Must not intersect with (line)

        Esta nueva implementación mejora significativamente la visualización de los errores y devuelve las geometrías de estos en una nueva capa, las mark actions aceleran el proceso de identificación y corrección de errores.

        Con el proyecto se posibilita automatizar tareas repetitivas, reducir errores y dar la posibilidad que el usuario se centre en el objetivo del proyecto y no en la parte técnica, se logra sencillez en el análisis de datos y se optimiza el uso del tiempo.

        Creo que lo más importante es ver como actualmente tenemos todo dispuesto para lograr que el trabajo cumpla la función que debería, ser una actividad que nos impulse para desarrollarnos como seres humanos, ahora depende de nosotros la forma en que decidamos llevar adelante las tareas.

        Ha sido un orgullo haber logrado calificar para los periodos 2019 y 2020 de GSoC, agradezco la confianza recibida para permitirme aportar a gvSIG y a la comunidad de software abierto. El trabajo se pudo realizar gracias al desarrollo en equipo con los tutores, principalmente Carlos Colombana, Óscar Martínez y con la comunidad de desarrolladores, fue una experiencia enriquecedora y muy disfrutable. También quiero agradecer a la Lic. en Psicología Mirtha de Sosa por compartir conmigo sus inspiradores puntos de vista de los cuales aprendo mucho.

        La sinergía generada en la cooperación de equipo hace la diferencia.

        Para mi es un privilegio poder compartir el proyecto con ustedes, muchas gracias.


        Watch the video: GeoServer. OpenLayers. Apache (September 2021).