OSGeo Planet

Petr Pridal: Streets: new OpenMapTiles map style

OSGeo Planet - Tue, 2018-05-15 11:00

OpenMapTiles has always encouraged the development of map services by giving an option to build a self-hosted map with open-source tools and by providing free non-commercial hosting. For those who support us with their paid plan, we introduce another premium service: a new Street map style.

Map with a clear roads’ hierarchy

Each map style should highlight only the information relevant to its primary objective. When we were designing new map style, we focused on transportation. Therefore the name Streets.

Streets style is a base map highlighting different transportation methods. Therefore we include roads, railway network, ferry routes, and airports. Moreover, it also shows all relevant POIs like bus stops, petrol stations or subway stations. 

Street style is a fresh alternative to Google Maps default style.

To highlight the roads’ hierarchy, each type of road is represented by different color. While the most saturated colors are representing major roads like highways, more pale colors are used in combination with thin lines for minor roads. By looking at the map, you can at the first look easily judge the overall network and make a quick decision.

Different types of transportation in Hong Kong and bilingual labels Different types of transportation in Hong Kong and bilingual labels

Only relevant information for quick decision

When looking at a map, you want to capture all necessary information as fast as possible. On the other hand, placing too many details decreases the readability and it takes you longer to get oriented on a map. Therefore we carefully picked only relevant information for each zoom level like POIs, labels, minor roads, and others. As you zoom in, more details appear they disappear as you zoom out to give you clear overlook. Since this is our first version, there could still be some missing or redundant items, especially POIs. Any comments on this topic are very welcomed.

A good map should also help the person who is using it recognize the features of the real world on the map. On lower zoom levels, we are displaying the land use information which can be seen from a global satellite image. On the higher zoom levels, we show transparent 3D buildings to help a person with orienting in an urban jungle. The buildings can be turned off.

The map is fully customizable as our MapTiler TileHosting supports creating own styles or derivatives of the existing ones with built-in WYSIWYG design tool.

As each of our map, the Streets style also includes a possibility to change the language. Currently, there are more than 50 languages supported.

Different types of transportation in Hong Kong and bilingual labels Land use information which can be seen from a satellite image from a global satellite image.

All the map styles including Streets are visible as a browsable map on the MapTiler TileHosting main page or in the administration.

Categories: OSGeo Planet

gvSIG Team: Certificación curso gratuito de Mapeo del delito. SIG en criminología

OSGeo Planet - Tue, 2018-05-15 05:05

Tras la buena recepción del curso de SIG aplicado a la criminología muchos de vosotros nos habéis preguntado por la posibilidad de obtener un certificado de aprovechamiento del curso.

Hemos preparado un ejercicio que debéis resolver y enviarnos para su evaluación y poder así obtener dicho certificado. El coste de la certificación lo hemos reducido al máximo, con el objetivo de que cualquier interesado en obtenerlo pueda acceder a él.

Toda la información sobre el ejercicio, la dirección del envío y el pago la podéis encontrar en el PDF accesible desde este enlace.

Categories: OSGeo Planet

Markus Neteler: PDAL 1.7 packaged for Fedora including vertical datums and grids

OSGeo Planet - Mon, 2018-05-14 20:47

 openNRW Germany)In order to simplify the installation of the latest PDAL release (Point Data Abstraction Library, https://pdal.io/, version 1.7.0 1.7.2) on Fedora, I have created an updated set of RPM packages, again including the vertical datums and grids available from OSGeo (i.e., .gtx files from here).

The installation is as simple as this (the repository is located at Fedora’s COPR):

# enable extra repos to satisfy dependencies sudo dnf copr enable neteler/pdal-hexer sudo dnf copr enable neteler/points2grid sudo dnf copr enable neteler/laszip # install minimal dependencies sudo dnf install hexer sudo dnf install points2grid # enable and install PDAL sudo dnf copr enable neteler/pdal sudo dnf install PDAL PDAL-vdatums # run it pdal-config --version pdal --help

Enjoy!

The post PDAL 1.7 packaged for Fedora including vertical datums and grids appeared first on GFOSS Blog | GRASS GIS and OSGeo News.

Categories: OSGeo Planet

Paul Ramsey: PostGIS Talks @ FOSS4G North America

OSGeo Planet - Mon, 2018-05-14 16:00

I presented my “PostGIS for Managers” talk for the last time (at least in this form) today at FOSS4G North America. The reason it’s for the last time is that the central conceit it’s built around, that a core decision is between a proprietary and an open source database, isn’t really operative anymore. The real decisions are now being driven by other considerations, like cloud platforms, and the services available there. So, it’s not really PostgreSQL versus Oracle anymore.

I also presented my “SQL Festival” talk, for the first time! New material is always a little challenging: will it work, is it the right level for the audience? It seemed to be well received, a mix of generic SQL tidbits, and some specific interesting queries you can do with PostGIS.

Categories: OSGeo Planet

Andrea Antonello: Geopaparazzi 5.6.0 is out - work with cloud profiles to handle surveys and data!

OSGeo Planet - Mon, 2018-05-14 13:13
This release brings a ton of fixes and compatibility enhancements for newer Android versions.

And then it brings cloud profiles. And I think this one is huge! :-)

Cloud ProfilesIn the last months a new company entered the geopaparazzi community and they have been doing nice contributions. The guys from Geoanalytic were working with us on the implementation of a more structured version of the cloud projects synchronization: Cloud Profiles!

We have been working on this already at the Bonn code sprint together with Cesar from the company Scolab. And now we are finally at a first release that supports this concept.

Cloud Profiles are a great way of easing Geopaparazzi’s data handling tasks. When a web server is configured to serve Cloud Profiles, Geopaparazzi can automatically download Projects, Basemaps, Spatialite Overlays, forms for Notes, and other files. When a user activates a downloaded Profile, Basemaps are made available, Overlays are attached to the Map View and layers are set to display.

Read more about it here.

The Geoanalytic guys have also been so nice to write a reference geopaparazzi profile server that can be used as a starting point. You can read more about it and download it from here.

The real power behind cloud profiles is that you can use your own server for this, but you could also make it much simpler by using Generic Cloud Server. You can set up your own Cloud Profile server by putting your files on a generic cloud file server like Dropbox or Google Drive, and editing a Cloud Profiles list like the one above and putting it on the cloud file server as well.

The very important fixThe most important fix (in my opinion) is the one resolving the GPS Location Limitations on Android Oreo. Basically it wasn't possible to log gps tracks with the screen off.

Technically it has been necessary to create a notification icon for geopaparazzi, so you will now have that visible when geopaparazzi is active.


The positive side is that:
  1. you will always know when geopaparazzi is active
  2. you can always see information about your position directly in the notification area

Other features and fixesValues in settings. The settings screen now shows the actual values:


Buttons size. Small buttons are hard to see and press while on the trail. While it can be difficult to show a lot of information on a small screen, where there is room, you can now change the button and text size. This applies to the notes view for now:

Dynamic hints. Dashboard button hints are dynamic where possible. You can now see from there how many notes and logs you have in store. Just long-tap on the buttons:




Notes settings. The notes settings view is now accessible from the notes list (it was hidden in the gps data list menu). Access it from the palette icon:

PDF export. The PDF export now allows to export a subset of notes instead of everything contained in the project. The user can select the notes he/she likes to export and those will be converted in the pdf version.
Linked resources. It is now possible to view not only images stored in a Spatialite database when they are related to (geospatial) features but also for example PDF. 

Note that while a user can take pictures in the field and link them to a feature, in the case of PDF, the resource has to be linked before, i.e. it can be just viewed only from geopaparazzi.
Remove all. In the basemaps view it is now possible to remove all maps in one tap. This is really helpfull for those that are used to load maps through the load-folder option and then need a lot of time to remove them to have things more readable.

Mapurl service. One sad note is that the Tanto Mapurl service, which was used to download automagically configured mapurls based on WMS services, is no longer maintained and has therefore been removed also from geopaparazzi.


Fixes for:
  • images taken within Geopaparazzi are not geotagged.
  • unable to open form image thumbnails. 
  • many other fixes have been done, the complete list is here.




Categories: OSGeo Planet

CARTO Inside Blog: A SQL approach to graph coloring applied to maps

OSGeo Planet - Mon, 2018-05-14 11:00

At CARTO we challenge ourselves to use our platform as our users do. For us, this serves several purposes:

  • Because we care a lot about our users experience, this way we understand better the pains and gains of using our platform.
  • We still keep learning a lot: from SQL to React, going through WebGL to projections, spatial algorithms and mapping in general.

Since use cases at CARTO go from very simple visualizations to complex geospatial solutions, one of the challenges I set for myself was to solve the graph coloring problem with CARTO.

Graph coloring is a technique to assign colors to the vertices of a graph such that no two adjacent vertices share the same color.

But what does graph coloring have to do with maps?

Map coloring is an application of graph coloring so each two adjacent polygons (countries, provinces, etc.) are assigned different colors.

Map coloring helps to better understand maps and solve other kind of problems like mobile radio frequency assignment or other scheduling problems.

Having said that, graph coloring is a very interesting topic covered by several theorems and algorithms, like the 4-color theorem which basically states that any map can be colored using 4 colors.

Coloring the world map in 4 colors

Let’s put ourselves in the boots of a CARTO user that wants to draw the world map in 4 colors. We don’t have much programming skills, but we know a bit of SQL and spatial concepts.

For this case we’ll work with the world_borders layer that can be imported into any CARTO account from our Data Library.

Modelling a graph in PostGIS

The graph coloring problem needs two mathematical artifacts to be solved: a model and an algorithm.

So we have to model a PostGIS table into a graph. This may sound like complex stuff but it can be actually solved in less than 10 lines of SQL by creating an adjacency list:

SELECT DISTINCT a.name, array_agg(b.name) over (PARTITION BY a.cartodb_id) AS adjacent, count(b.*) over (PARTITION BY a.cartodb_id) AS valence, 0 AS color FROM world_borders a, world_borders b WHERE ST_INTERSECTS(a.the_geom, b.the_geom) AND a.cartodb_id != b.cartodb_id ORDER BY valence DESC, a.name ASC

With this query we obtain the world map adjacency list having for each country, the list of adjacent countries and its valence (the number of adjacent countries).

Learning point: Note the use of PostgreSQL Window functions to aggregate and count the adjacent countries in a single column. Window functions are a really handy resource to have in your SQL tool box.

We can generalize this query by wrapping it as a PostgreSQL function so that it can be executed for any of our datasets and store the results in a table:

CREATE OR REPLACE FUNCTION adjacency_list(table_name regclass, user_name text) RETURNS void AS $$ BEGIN EXECUTE format('DROP TABLE IF EXISTS %s_adjacency_list; CREATE TABLE %s_adjacency_list AS SELECT DISTINCT a.cartodb_id, array_agg(b.cartodb_id) over (PARTITION BY a.cartodb_id) AS adjacent, count(b.*) over (PARTITION BY a.cartodb_id) AS valence, 0 AS color FROM %s a, %s b WHERE ST_INTERSECTS(a.the_geom, b.the_geom) ORDER BY valence DESC, a.cartodb_id ASC; SELECT CDB_CartoDBFyTable(''' || user_name || ''',''' || table_name || '_adjacency_list'');', table_name, table_name, table_name, table_name); END $$ LANGUAGE plpgsql;

Learning point: By wrapping a query into a function we are able to re-use it and even provide of a geospatial framework to the users in our CARTO organization.

Note as well the use of the EXECUTE and format functions to avoid missusing of the function or SQL injection issues.

The Welsh-Powell algorithm: a greedy coloring approach

Let’s start by implementing the most simpler algorithm for graph coloring, the Welsh-Powell one. This algorithm is as follows:

  • Find the adjacency list and valence for each vertex (in this case for each country)
  • List the vertices in order of descending valence
  • Color the first vertex in the list with color 1
  • Go down the list and color every vertex not connected to the colored vertices above the same color. Then cross out all colored vertices in the list.
  • Repeat on the uncolored vertices with a new color, always working in descending order of valence until all the vertices have been colored.

Let’s see how we can implement the Welsh-Powell algorithm as a PostGIS function.

CREATE OR REPLACE FUNCTION greedy(table_name regclass, user_name text) RETURNS void AS $$ DECLARE item RECORD; current_color int = 1; cc int; guard int; BEGIN PERFORM adjacency_list(table_name, user_name); EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = 0', table_name) INTO guard; WHILE guard > 0 LOOP EXECUTE format('UPDATE %s_adjacency_list SET color = $1 WHERE cartodb_id = (SELECT cartodb_id FROM %s_adjacency_list WHERE color = 0 ORDER BY cartodb_id ASC LIMIT 1);', table_name, table_name) USING current_color; FOR item IN EXECUTE format('SELECT * FROM %s_adjacency_list WHERE color = 0', table_name) LOOP EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = $1 AND $2 = ANY(adjacent)', table_name) INTO cc USING current_color, item.cartodb_id; IF cc = 0 THEN EXECUTE format('UPDATE %s_adjacency_list SET color = $1 WHERE cartodb_id = $2;', table_name) USING current_color, item.cartodb_id; END IF; END loop; current_color = current_color + 1; EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = 0', table_name) into guard; END loop; END; $$ LANGUAGE plpgsql; A deep view on the Welsh-Powell algorithm implementation

In this case we have two different sections in our function. First we DECLARE temporary variables needed to store results and second we have the actual algorithm implementation between a BEGIN and END clause.

DECLARE item RECORD; current_color int = 1; cc int; guard int;

Since we need to model our dataset as an adjacency list we start by calling our adjacency_list function:

PERFORM adjacency_list(table_name, user_name);

Then we need to know the number of rows in the dataset and start an iterative algorithm:

EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = 0', table_name) INTO guard; WHILE guard > 0 LOOP

Let’s color the first vertex in the list with color 1

EXECUTE format('UPDATE %s_adjacency_list SET color = $1 WHERE cartodb_id = (SELECT cartodb_id FROM %s_adjacency_list WHERE color = 0 ORDER BY cartodb_id ASC LIMIT 1);', table_name, table_name) USING current_color;

Go down the list and color every vertex not connected to the colored vertices above the same color

FOR item IN EXECUTE format('SELECT * FROM %s_adjacency_list WHERE color = 0', table_name) LOOP EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = $1 AND $2 = ANY(adjacent)', table_name) INTO cc USING current_color, item.cartodb_id; IF cc = 0 THEN EXECUTE format('UPDATE %s_adjacency_list SET color = $1 WHERE cartodb_id = $2;', table_name) USING current_color, item.cartodb_id; END IF; END loop;

Finally, repeat on the uncolored vertices with a new color, always working in descending order of valence until all the vertices have been colored.

current_color = current_color + 1; EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color = 0', table_name) into guard;

Now we have two functions that can be stored in our CARTO account by running them into the SQL console in our BUILDER dashboard, but how do we run this map coloring algorithm?

Best option here is using our batch SQL API, this allows us to run any SQL that could take several seconds or minutes safely. In this case we just have to do a SELECT to our greedy function passing the table_name and our user_name. We can do this directly from a terminal:

curl -X POST -H "Content-Type: application/json" -d "{ \"query\": \"SELECT greedy('world_borders', 'aromeu')\" }" https://aromeu.carto.com/api/v2/sql/job?api_key={api_key}

The resulting table world_borders_adjacency_list contains a color assigned for each cartodb_id, now we just can join this table with the original world_borders table and apply a category thematic to visualize the result (plus a bit of CartoCSS magic):


In this case we have colored every adjacent country with a different color, in a total of 5 colors, but can we do it better?

Note: for the sake of simplicity in the examples above and below, we are not working with multipolygons; so that, countries composed of several polygons are assigned different colors to each polygon.

The Kempe’s graph coloring algorithm

In 1879, Alfred B. Kempe tried to prove the 4-color theorem and while years later it was demonstrated that it didn’t solved the problem for all cases, the algorithm he designed still can be used to color the world map using just 4 colors.

The Kempe’s graph color algorithm is as follows:

  • Convert the map to a graph (in this case an adjacency list)
  • Choose a vertex (polygon) with less than five neighbors and remove it from the graph. This may cause some vertices that previously had five or more neighbors to now have less than five.
  • Choose another vertex from the updated graph with less than five neighbors and remove it.
  • Continue until you’ve removed all the vertices from the graph.
  • Add the nodes back the graph in reverse order from which you removed them.
  • Color the added node with a color that is not used by any of its current neighbors.
  • Continue until you’ve colored in the entire graph.

This is a little bit more complex algorithm that still can be solved using a pure PostgreSQL function:

CREATE OR REPLACE FUNCTION kempe(table_name regclass, user_name text) RETURNS void AS $$ DECLARE item RECORD; cc int; count int = 1; d int; temp_cartodb_id int; guard int; BEGIN PERFORM adjacency_list(table_name, user_name); EXECUTE format('DROP TABLE IF EXISTS %s_temp', table_name); EXECUTE format('CREATE TABLE %s_temp (cartodb_id integer, ord integer);', table_name); EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE valence < 5 AND valence > 0', table_name) INTO guard; WHILE guard > 0 LOOP EXECUTE format('SELECT cartodb_id FROM %s_adjacency_list WHERE valence < 5 AND valence > 0 ORDER BY valence DESC LIMIT 1', table_name) into temp_cartodb_id; EXECUTE format('INSERT INTO %s_temp (cartodb_id, ord) VALUES ($1, $2)', table_name) USING temp_cartodb_id, count; count = count + 1; EXECUTE format('UPDATE %s_adjacency_list SET valence = 0 WHERE cartodb_id = $1', table_name) USING temp_cartodb_id; FOR item IN EXECUTE format('SELECT * FROM %s_adjacency_list WHERE $1 = ANY(adjacent)', table_name) USING temp_cartodb_id LOOP EXECUTE format('UPDATE %s_adjacency_list SET valence = valence - 1 WHERE cartodb_id = $1', table_name) USING item.cartodb_id; END LOOP; EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE valence < 5 AND valence > 0', table_name) INTO guard; END LOOP; EXECUTE format('UPDATE %s_adjacency_list set valence = array_length(adjacent, 1)', table_name); EXECUTE format('UPDATE %s_adjacency_list set color = 0', table_name); FOR item IN EXECUTE format('SELECT * FROM %s_temp ORDER BY ord DESC', table_name) LOOP EXECUTE format('SELECT COUNT(*) FROM %s_adjacency_list WHERE color != 0 AND $1 = ANY(adjacent)', table_name) INTO cc USING item.cartodb_id; IF cc = 0 THEN EXECUTE format('UPDATE %s_adjacency_list SET color = 1 WHERE cartodb_id = $1', table_name) USING item.cartodb_id; ELSE EXECUTE format('select (array_agg(elements))[1] from ( select unnest(array[1, 2, 3, 4, 5]) except SELECT unnest(ARRAY_AGG(color)) FROM %s_adjacency_list WHERE color != 0 AND $1 = ANY(adjacent) ) t (elements)', table_name) INTO d USING item.cartodb_id; EXECUTE format('UPDATE %s_adjacency_list SET color = $1 WHERE cartodb_id = $2', table_name) USING d, item.cartodb_id; END IF; END LOOP; EXECUTE format('DROP TABLE IF EXISTS %s_temp', table_name); END; $$ LANGUAGE plpgsql;

Again we can create the function from the SQL console, execute it for the world_borders dataset using the batch SQL API and then map it with BUILDER. Let’s see the result:


In this case we have colored the world map in 4 colors, challenge accomplished!

Learning point: We have not only learned how to solve the graph coloring problem with CARTO but we have ended up creating the basis for a geospatial framework by creating PostgreSQL functions into our CARTO account.

More map coloring

So, let’s finish by applying these map coloring functions that now are part of our own geospatial framework inside CARTO to some other of our datasets.

The 4 color theorem applied to the US states dataset


A greedy approach to map color the US counties dataset


Another greedy example with the Spain municipalities


Note that the map coloring algorithm implementations presented in this blog post are totally naive and don’t pretend to be exact or to be used under a production environment, they just pretend to showcase a user workflow to solve a geospatial problem with CARTO.

For reference, all these functions are available here. Feel free to add any comment or improve them.

If you like the kind of stuff we are involved in you may want to join us :)

Categories: OSGeo Planet

Stefano Costa: IOSACal 0.4

OSGeo Planet - Fri, 2018-05-11 22:47

IOSACal is an open source program for calibration of radiocarbon dates.

A few days ago I released version 0.4, that can be installed from PyPI or from source. The documentation and website is at http://c14.iosa.it/ as usual. You will need to have Python 3 already installed.

The main highlight of this release are the new classes for summed probability distributions (SPD) and paleodemography, contributed by Mario Gutiérrez-Roig as part of his work for the PALEODEM project at IPHES.

A bug affecting calibrated date ranges extending to the present was corrected.

On the technical side the most notable changes are the following:

  • requires NumPy 1.14, SciPy 1.1 and Matplotlib 2.2
  • removed dependencies on obsolete functions
  • improved the command line interface

You can cite IOSACal in your work with the DOI https://doi.org/10.5281/zenodo.630455. This helps the author and contributors to get some recognition for creating and maintaining this software free for everyone.

Categories: OSGeo Planet

gvSIG Team: Creating new colour ramps in gvSIG Online

OSGeo Planet - Thu, 2018-05-10 13:42

As you knew a raster image could be represented using a ‘colour table’. These colour tables are generated from the colour ramps. In gvSIG Online we have a series of colour ramps but for customized cases that may be interesting to create a new one. There is no problem, gvSIG Online allows us to do it.

We show you how to do it through a video-tutorial. In this video we follow these steps:

  1. We have a geoportal with a raster image where we can apply a concrete symbology (colour table). Let’s imagine that any of the existing colour ramps is what we want to apply.
  2. We access to the dashboard and we see that in our gvSIG Online there are several symbol libraries that have a series of colour ramps.
  3. We add a new symbol library that has two new colour ramps. For each ramp it indicates the colours that configure it.
  4. Finally, we apply a colour table to our raster image, using the new available colour ramps.

As you can see, gvSIG Online is growing in functionalities day by day and it is becoming a reference when implementing Spatial Data Infrastructures.

Categories: OSGeo Planet

gvSIG Team: gvSIG aplicado a Medio Ambiente. Tema 7 (y último): Salida de mapas.

OSGeo Planet - Thu, 2018-05-10 08:13

Finalizamos la parte teórico-practica del curso gratuito gvSIG aplicado a Medio Ambiente aprendiendo a generar mapas imprimibles.

1

En este tema trabajaremos sobre el “layout”, es decir, el mapa impreso como resultado de todos los análisis y geoprocesos que hemos realizado durante el curso y que realizaremos en nuestro trabajo cotidiano.

Si bien es cierto que la impresión de mapas es cada vez menor desde la aparición de las plataformas de webmapping y las plataformas para la gestión de Infraestructuras de Datos Espaciales (como gvSIG Online) no está de más aprender a manejar esta herramienta para utlizarla en informes técnicos, publicaciones, etc.

Aprenderemos a realizar una plantilla de mapas, a establecer los elementos necesarios para que el mapa sea comprensible y a insertar las vistas de nuestros proyectos para imprimir nuestro trabajo.

Podéis acceder al nuevo tema en el siguiente enlace:

http://www.geoalternativa.com/gvsig-training/course/view.php?id=3&section=9

Como siempre, si tenéis dudas, os animamos a escribir en la lista de usuari@s de gvSIG: http://osgeo-org.1560.x6.nabble.com/gvSIG-usuarios-f4118557.html

Categories: OSGeo Planet

Jackie Ng: Announcing: MapGuide Maestro 6.0m9

OSGeo Planet - Wed, 2018-05-09 23:56
Here's a new milestone release of MapGuide Maestro. Here's what's new in this release.

mapguide-react-layout support

One of the design goals of mapguide-react-layout viewer was to be highly compatible with existing Web and Flexible layout documents ensuring for the same authoring experience as the existing AJAX and Fusion viewer offerings.

However, the authoring experience in Maestro knows nothing about mapguide-react-layout, so any authoring experience still assumes the use of AJAX or Fusion viewers.

With this release, we have a new preference for specifying the base URL of a mapguide-react-layout installation.


Once this is set, the Web and Flexible Layout editors light up with additional viewer URLs allowing you to load the Web/Flexible Layout with a mapguide-react-layout template of your choice. 



Since the UI for this has changed from a read-only text box to a combo box, once cannot easily select the URL to copy/paste. To workaround this, a convenience "Copy to Clipboard" button is included to easily copy the current viewer URL for pasting elsewhere.

The other authoring experience change is that a new Flexible Layout will no longer include Fusion widgets that are not supported by mapguide-react-layout. These widgets are really esoteric ones, so most authors won't probably notice any differences.

MgTileSeeder improvements

The new MgTileSeeder tool has been improved with the following changes:
  • A new --failed-requests parameter for specifying a log file to log failed requests to
  • A new --max-parallelism parameter for controlling the max degreee of parallelism when sending tile requests
  • New xyz_replay and mapguide_replay commands for re-requesting failed requests from a log file previously logged via the new --failed-requests parameter
Improved OGR Feature Source support

The OGR provider has been the primary recipient of my continued developer attention since the release of MapGuide Open Source 3.1.1 as there are many things in the provider with room for improvement. Given this, it was time to also give the OGR provider equivalent treatment in Maestro, so with this release, feature sources using the OGR provider now has its own specialized editor.



Most of the UI here should be self-explanatory, but the Other Properties section deserves some explanation. This is a future-proof data grid for editing connection properties that may be introduced in future builds/releases of the OGR provider.

Another case where the OGR provider gets better treatment is the support in the SHP feature source editor to convert it across to use the OGR provider. 



This feature was added to improve the SHP story for MapGuide on 64-bit Linux where the current dedicated SHP provider has unresolved 64-bit portability problems making it unusable. However, the OGR provider has no such issues making it a viable alternative FDO provider for SHP files on 64-bit Linux. This conversion feature helps facilitate this transition in an easy manner. However, there's still some glaring problems with the converted OGR feature source, such as the FDO provider using a hard-coded schema name of "OGRSchema". Nothing some python scripting elbow grease can't fix afterwards. Or you can watch this space :)

Other fixes/changes
  • Fix: Rename resource with "update references" checked will disregard overwrite flag
  • Fix: NullReferenceException when ticking a new geometry type and adding a rule to the grid for the first time in Layer Definition editor
  • Fix: MgInvalidRepositoryTypeException when validating layers. Previous workaround was to disable validation on save. With this release you can safely re-enable this if you so choose.
  • Fix: Editing default path in line usage context in Symbol Definition editor does nothing
  • Fix: Cannot browse symbol definiton parameters in any field of the Path editor dialog 
Download 
Project Web Site
Categories: OSGeo Planet

EOX' blog: Explore GeoTIFFs like Landsat 8 scenes with COG-Explorer in the browser

OSGeo Planet - Wed, 2018-05-09 21:10
In our previous blog post about visualizing raster data we demonstrated a use case for client side browser based visualization of GeoTIFFs using modern web techniques and the geotiff.js library. The application uses GeoTIFFs derived from Sentinel-2 data and visualizes either single […]
Categories: OSGeo Planet

Free and Open Source GIS Ramblings: Movement data in GIS #13: Timestamp labels for trajectories

OSGeo Planet - Wed, 2018-05-09 18:08

In Movement data in GIS #2: visualization I mentioned that it should be possible to label trajectory segments without having to break the original trajectory feature. While it’s not a straightforward process, it is indeed possible to create timestamp labels at desired intervals:

The main point here is that we cannot use regular labels because there would be only one label for the whole trajectory feature. Instead, we are using a marker line with a font marker:

By default, font markers only display one character from a given font but by using expressions we can make it display longer text, including datetime strings:

If you want to have a label at every node of the trajectory, the expression looks like this:

format_date( to_datetime('1970-01-01T00:00:00Z')+to_interval( m(start_point(geometry_n( segments_to_lines( $geometry ), @geometry_part_num) ))||' seconds' ), 'HH:mm:ss' )

You probably remember those parts of the expression that extract the m value from previous posts. Note that – compared to 2016 – it is now necessary to add the segments_to_lines() function.

The m value (which stores time as seconds since Unix epoch) is then converted to datetime and finally formatted to only show time. Of course you can edit the datetime format string to also include the date.

If we only want a label every 30 seconds, we can add a case statement around that:

CASE WHEN m(start_point(geometry_n( segments_to_lines( $geometry ), @geometry_part_num) )) % 30 = 0 THEN format_date( to_datetime('1970-01-01T00:00:00Z')+to_interval( m(start_point(geometry_n( segments_to_lines( $geometry ), @geometry_part_num) ))||' seconds' ), 'HH:mm:ss' ) END

This works well if the trajectory sampling interval is fairly regular. This is not always the case and that means that the above case statement wouldn’t find many nodes with a timestamp that ends in :30 or :00. In such a case, we could resort to labeling nodes based on their order in the linestring:

CASE WHEN @geometry_part_num % 30 = 0 THEN ...

Thanks a lot to @JuergenEFischer for providing a solution for converting seconds since Unix epoch to datetime without a custom function!

Note that expressions using @geometry_part_num currently suffer from the following issue: Combination of segments_to_lines($geometry) and @geometry_part_num gives wrong segment numbers

This post is part of a series. Read more about movement data in GIS.

Categories: OSGeo Planet

Petr Pridal: OpenMapTiles gives you freedom of SDKs

OSGeo Planet - Wed, 2018-05-09 11:00

The possibility to select your favorite mobile map SDK, JavaScript library for your web and server for raster tiles increase your freedom of choice with the OpenMapTiles project. Three new map styles from one of the leaders in map industry, CARTO, demonstrates this power of diversity while using OpenMapTiles.

Open-source stack, usable on multiple SDKs

Whenever you work on a map, you need to define how each geographical feature will look like. This definition is described using a styling language and it says, for example, that rivers should be rendered starting zoom level 10, with blue color and it should be 8px bold line.

The styling languages differ in the syntax used for defining the final look and in the implementation by various software tools (mobile SDKs, raster servers, web APIs).

These are the most popular styling languages today:

GL JSON, which is the main styling language of OpenMapTiles, is based on JSON file format defined originally by Mapbox and adopted by ESRI and others - and it supports Mapbox mobile SDKs, ArcGIS Pro and OpenMapTiles Server or TileServer GL raster server.

Tangram YAML uses the markup style popular in Python programming language and can be used with Tangram SDK and Tangram Paparazzi.

CartoCSS is similar to CSS used to style websites and is implemented with tools using Mapnik map renderer (the primary OpenStreetMap.org toolkit for rendering raster map tiles) and is also usable with the Carto mobile SDK. There is no native vector tile viewer for web implementing CartoCSS directly.

OGC SLD standard based on XML. This language is hard to write directly by humans, so it is typically created by converting from other styling languages or using a visual editor - such as desktop GIS tools like QGIS.

All of these styling languages are compatible with the OpenMapTiles.

JavaScript for web applications

For displaying map data in a web browser as slippy maps, different JavaScript libraries can be used. They provide APIs for building geographic web application similar to Google Maps or Bing Maps but allow you to load the map data from your own server or provider of choice.

OpenLayers supports vector as well as raster tiles and is most advanced in handling coordinate systems and map projections.

Mapbox GL JS is another web mapping library. Supports both raster tiles and vector format used by OpenMapTiles.

Leaflet is the lightweight and simple JavaScript library, which can be used either for viewing raster tiles or vector tiles through mapbox-gl-leaflet or VectorGrid plugin.

Tangram is another rendering client for web applications which supports OpenMapTiles vector tile schema.

To inspect different JavaScript libraries next to each other, see the comparison. All of them are ready for HiDPI retina displays.

Multiple mobile map SDKs

For bringing your map into a mobile device you need an SDK, which is a kit allowing the development of applications for the mobile operating system. With OpenMapTiles, you have a choice of several SDK for different platforms.

GL JSON is closely tied to Mapbox mobile SDKs, which support both Android and iOS and in addition the Unity game engine.

Tangram YAML is connected to Tangram SDK, which allows you to create mobile apps for iOS and Android.

CartoCSS can be best used in Carto mobile SDK, which has in-built support for Android, iOS and Windows Phone platforms.

Raster tiles on the server side

The freedom of choice is also kept on the server side with a variety of servers rendering raster as well as vector tiles.

OpenMapTiles Server or TileServer GL provides both raster and vector tiles from a GL style.

Mapnik library is the toolkit used for rendering maps on the main OpenStreetMap site.

Tangram Paparazzi has its roots in Tangram-ES but serves raster tiles.

Desktop GIS

Users of desktop GIS software are not left behind. The compatibility with ESRI’s ArcGIS Runtime SDK compatibility is achieved for OpenMapTiles. 

Opening raster tiles in QGIS is straightforward and there is also a plugin for loading vector tiles under development.

Voyager, Positron and Dark Matter styles for OpenMapTiles © CARTO Voyager, Positron and Dark Matter styles for OpenMapTiles © CARTO

New styles: Voyager, Positron and Dark Matter

With the release of three new map styles, CARTO shows the commitment to the OpenMapTiles project. The styles are available for web and mobile, both raster and vector. The styles are based on OpenMapTiles data schema, use the project’s vector tiles and are implemented in three different styling languages while keeping the same look and feel across the different software tools.

  1. Voyager - colored map with clear road hierarchy
  2. Positron - light gray map for further displaying of data
  3. Dark Matter - dark gray map for displaying data of bigger size

The code is fully open-source and can be found on GitHub.

You can see our implementation of these styles with several others beautiful styles such as Streets and Topo in MapTiler Cloud hosting.

Categories: OSGeo Planet

Petr Pridal: OpenMapTiles gives you freedom of SDKs

OSGeo Planet - Wed, 2018-05-09 11:00

The possibility to select your favorite mobile map SDK, JavaScript library for your web and server for raster tiles increase your freedom of choice with the OpenMapTiles project. Three new map styles from one of the leaders in map industry, CARTO, demonstrates this power of diversity while using OpenMapTiles.

Open-source stack, usable on multiple SDKs

Whenever you work on a map, you need to define how each geographical feature will look like. This definition is described using a styling language and it says, for example, that rivers should be rendered starting zoom level 10, with blue color and it should be 8px bold line.

The styling languages differ in the syntax used for defining the final look and in the implementation by various software tools (mobile SDKs, raster servers, web APIs).

These are the most popular styling languages today:

GL JSON, which is the main styling language of OpenMapTiles, is based on JSON file format defined originally by Mapbox and adopted by ESRI and others - and it supports Mapbox mobile SDKs, ArcGIS Pro and OpenMapTiles Server or TileServer GL raster server.

Tangram YAML uses the markup style popular in Python programming language and can be used with Tangram SDK and Tangram Paparazzi.

CartoCSS is similar to CSS used to style websites and is implemented with tools using Mapnik map renderer (the primary OpenStreetMap.org toolkit for rendering raster map tiles) and is also usable with the Carto mobile SDK. There is no native vector tile viewer for web implementing CartoCSS directly.

OGC SLD standard based on XML. This language is hard to write directly by humans, so it is typically created by converting from other styling languages or using a visual editor - such as desktop GIS tools like QGIS.

All of these styling languages are compatible with the OpenMapTiles.

JavaScript for web applications

For displaying map data in a web browser as slippy maps, different JavaScript libraries can be used. They provide APIs for building geographic web application similar to Google Maps or Bing Maps but allow you to load the map data from your own server or provider of choice.

OpenLayers supports vector as well as raster tiles and is most advanced in handling coordinate systems and map projections.

Mapbox GL JS is another web mapping library. Supports both raster tiles and vector format used by OpenMapTiles.

Leaflet is the lightweight and simple JavaScript library, which can be used either for viewing raster tiles or vector tiles through mapbox-gl-leaflet or VectorGrid plugin.

Tangram is another rendering client for web applications which supports OpenMapTiles vector tile schema.

To inspect different JavaScript libraries next to each other, see the comparison. All of them are ready for HiDPI retina displays.

Multiple mobile map SDKs

For bringing your map into a mobile device you need an SDK, which is a kit allowing the development of applications for the mobile operating system. With OpenMapTiles, you have a choice of several SDK for different platforms.

GL JSON is closely tied to Mapbox mobile SDKs, which support both Android and iOS and in addition the Unity game engine.

Tangram YAML is connected to Tangram SDK, which allows you to create mobile apps for iOS and Android.

CartoCSS can be best used in Carto mobile SDK, which has in-built support for Android, iOS and Windows Phone platforms.

Raster tiles on the server side

The freedom of choice is also kept on the server side with a variety of servers rendering raster as well as vector tiles.

OpenMapTiles Server or TileServer GL provides both raster and vector tiles from a GL style.

Mapnik library is the toolkit used for rendering maps on the main OpenStreetMap site.

Tangram Paparazzi has its roots in Tangram-ES but serves raster tiles.

Desktop GIS

Users of desktop GIS software are not left behind. The compatibility with ESRI’s ArcGIS Runtime SDK compatibility is achieved for OpenMapTiles. 

Opening raster tiles in QGIS is straightforward and there is also a plugin for loading vector tiles under development.

Voyager, Positron and Dark Matter styles for OpenMapTiles © CARTO Voyager, Positron and Dark Matter styles for OpenMapTiles © CARTO

New styles: Voyager, Positron and Dark Matter

With the release of three new map styles, CARTO shows the commitment to the OpenMapTiles project. The styles are available for web and mobile, both raster and vector. The styles are based on OpenMapTiles data schema, use the project’s vector tiles and are implemented in three different styling languages while keeping the same look and feel across the different software tools.

  1. Voyager - colored map with clear road hierarchy
  2. Positron - light gray map for further displaying of data
  3. Dark Matter - dark gray map for displaying data of bigger size

The code is fully open-source and can be found on GitHub.

You can see our implementation of these styles with several others beautiful styles such as Streets and Topo in MapTiler Cloud hosting.

Categories: OSGeo Planet

QGIS Blog: Reports from the winning grant proposals 2017

OSGeo Planet - Tue, 2018-05-08 19:45

While we are waiting for this year’s grant proposals to come in, it is time to look back at last year’s winning proposals and their results. These are the reports on the work that has been done within the individual projects:

QGIS 3D – Martin Dobias

Results are included in the QGIS 3.0 release. As proposed in the grant, a new 3D map view has been added together with GUI for easy configuration of 3D rendering. The 3D view displays terrain (either from a DEM raster layer or a simple flat area) with 2D map rendered on top of the terrain. In addition to that, vector layers can be rendered as true 3D entities: points may be visualized as simple geometric shapes or as 3D models (loaded from a file), polygons and linestrings are tessellated into 3D geometries. 2D polygons can be turned into 3D objects using extrusion, possibly with data-defined height – an easy way how to display buildings, for example. Data with 3D coordinates have the Z values in geometries respected. Although the 3D view is still in its early stages, it is already usable for many use cases. Hopefully this functionality will help to attract even more users to QGIS!

More details: https://github.com/qgis/QGIS-Enhancement-Proposals/issues/105

Improvements to relations – Régis Haubourg

Various improvements for deep relations with PostgreSQL were successfully added in QGIS 3.0:

Add consistency to UI controls – Nyall Dawson

We’ve unified all the various opacity, rotation and scale controls to use the same terminology and numeric scales. We’ve also updated ALL methods for setting opacity, rotation and scale within the PyQGIS API to use consistent naming and arguments, making the API more predictable and easy to use. Lastly, we’ve also added a new reusable opacity widget (QgsOpacityWidget) to the GUI library so that future code can (and 3rd party scripts and plugins) can follow the new UI conventions for opacity handling.

Extend unit test coverage for geometry classes – Nyall Dawson

We’ve extended the unit testing coverage for all the underlying geometry primitive classes (points, lines, polygons, curves, collections, etc) so that all these classes have as close to 100% unit test coverage as possible. In the process, we identified and fixed dozens of bugs in the geometry library, and naturally added additional unit tests to avoid regressions in future releases. As a result QGIS’ core geometry engine is much more stable. Furthermore, we utilised the additional test coverage to allow us to safely refactor some of the slower geometry operations, meaning that many geometry heavy operations will perform much faster in QGIS 3.0.

Processing algorithm documentation – Matteo Ghetta & Alexander Bruy

The new Help system is landed and already available: when opening a Processing algorithm and clicking on the Help button, the guide of the algorithm will be showed in the default browser.

Many of the QGIS Processing algorithm guides have been enhanced with pictures and new or enhanced descriptions. A consistency number of Pull Requests have been already merged and many others are in review. Just a few descriptions need to be still enhanced.

Currently all the QGIS algorithms have been described and all the PR in the doc repository have been merged (kudos to Harrissou for all the reviews!).

Right now the Help button of each Processing dialog will open the related page of the algorithm, BUT:

  • if the name of the algorithm is made by only ONE word (e.g. clip, intersection…), the help button will open the browser to also the correct section (that is, the user will see directly the description of the related algorithm)
  • if the name of the algorithm has >1 words (e.g. split polygon with lines, lines to polygon, ecc.) the Help button will open the correct page (so the algorithm GROUP) but is not able to go to the correct algorithm anchor. This is because sphinx converts “split with lines” in “split-with-lines” while QGIS system will always cast the words “split-with-lines” in “splitwithlines”. Not a big deal, but IMHO a pity.
    We are really too close to the solution.

So Processing Help system right now consists of:

  • QGIS algs -> documented
  • GDAL algs -> documented
  • GRASS -> documented (own docs)
  • Orfeo -> documented (own docs)
  • SAGA -> nothing documented

Thanks to QGIS Grants to provide this chance to give a big improvement to the Processing framework even if not in a coding way!

Last but not least, we had another project that was not part of the grant programme but was also funded by QGIS.ORG in 2017:

Python API documentation – Denis Rouzaud

QGIS Python API Documentation is created using Sphinx and this work is available on Github. The repo is a fork of QGIS’ one and has been merged in the meantime. The docs are available at qgis.org/pyqgis. It uses a new theme (sphinx_rtd_theme aka ReadTheDocs theme). Some improvements were brought in (not exhaustive):

  • QGIS theming with colors and icon
  • Foldable toctree
  • Summary of methods and attributes for classes
  • Module index (not available before)
  • Correct display of overloaded methods

Full Python signature in Docstring

In former SIP versions, it was not possible to use the auto generated signature if a Docstring already existed. This means any documented method could not have a signature created. Unfortunately for this project, the vast majority of methods in QGIS API are documented!

The source code of SIP was modified and theses changes got merged upstream. See rev 1788 to 1793 in SIP changelog. It will be released in upcoming 4.19.7 version. QGIS source code was modified accordingly to prepend auto generated Python signatures to existing Docstrings. Using a CMake configuration file for each module (core.sip.in, gui.sip.in, etc.) was required to avoid syntax errors when using former version of SIP (since bumping minimum version is not realistic).

Sipify adjustments

Many things were fixed in sipify script :

  • Creation of links to classes, methods
  • Handling/fixing of Doxygen annotations \see, \note, \param
  • Handling of code snippets: c++ vs Python. Only Python are shown.

Thank you to everyone who participated and made this round of grants a great success and thank you to all our sponsor and donors who make this initiative possible!

Anita

Categories: OSGeo Planet

gvSIG Team: gvSIG Desktop plugin to create forms for field data gathering with gvSIG Mobile

OSGeo Planet - Tue, 2018-05-08 08:48

The gvSIG Desktop plugin to create forms for field data gathering with gvSIG Mobile in an easy way is now available.

Through this plugin we can create custom forms for censuses, surveys, inventories, inspections …, with the different type of fields that we want (drop-down, multi-selection, date, true-false …).

The main advantage of working with these forms is that we can create different sections, which cover different topics, and each of them with their customized forms.

We can also send the file containing these forms to the different teams that do the field work so that everyone works with the same types of data.

In order to use this new extension it is necessary to install it previously in gvSIG Desktop, and if we want to import the field data in gvSIG Desktop then we must also install the extension that allows us to do it.

In the following video we can see how to install both extensions, how to create the forms, how to take the field data with them and how to load this data in gvSIG Desktop later for analyze them:

More information about how to work with gvSIG Mobile at this post.

Categories: OSGeo Planet

gvSIG Team: Extensión que permite crear formularios fácilmente para toma de datos en campo en gvSIG Mobile

OSGeo Planet - Tue, 2018-05-08 08:34

Ya está disponible la extensión para gvSIG Desktop que permite crear formularios para toma de datos en campo en gvSIG Mobile de una forma sencilla.

Mediante esta extensión podemos crear formularios personalizados para censos, encuestas, inventarios, inspecciones…, con los campos que deseemos de diferentes tipos (desplegables, multiselección, fecha, verdadero-falso…).

La principal ventaja de trabajar con estos formularios es que podemos crear diferentes secciones, que abarquen temáticas diferentes, y cada una de ellas con sus formularios personalizados.

Además podemos enviar el fichero que contiene dichos formularios a los distintos equipos que hagan el trabajo de campo para que todos trabajen con los mismos tipos de datos.

Para poder utilizar esta nueva extensión es necesario instalarla previamente en gvSIG Desktop, y si deseamos importar los datos de campo en gvSIG Desktop después también deberemos instalar la extensión que nos permite hacerlo.

En el siguiente vídeo podéis ver cómo instalar ambas extensiones, cómo crear los formularios, cómo tomar los datos en campo con ellos y como cargar dichos datos en gvSIG Desktop después para su posterior análisis:

Más información sobre cómo trabajar con gvSIG Mobile en este post.

Categories: OSGeo Planet

gvSIG Team: Free course about crime mapping. GIS for criminology

OSGeo Planet - Mon, 2018-05-07 12:58

gvSIG Crime is the solution offered by the gvSIG Association to organize, analyze and maintain information related to security and crime. A platform adapted to the needs of each organization and territory, that includes several components, an important web part that establishes the necessary computer infrastructure to organize, share and access spatial information, with all types of spatio-temporal analysis tools, support for field tasks, …, and components that are more oriented to advanced analysis such as the desktop Geographic Information System (GIS).

It is precisely in this last part where this crime analysis course is focused, which is intended as an introduction to the use of gvSIG Desktop, an open source GIS software, as fundamental software to optimize the analysis of criminal information.

The course does not intend to make an exhaustive tour of all the gvSIG Desktop tools, and it’s focused on carrying out through practical exercises an invitation to explore the potential of its use in criminology.

The objectives of the course are:

    • Gain a better understanding of geospatial technology applied to crime mapping.
    • Perform queries based on attribute and location information to get accurate information.
    • Use crime databases to produce customized datasets and density maps, or for hot-spot analysis and other geoprocesses.
    • Learning basic programming concepts (scripting) to develop new analysis tools.
    • Gain a better understanding of Geostatistics applications for crime analysis.

The course starts with basic modules, in which the student can access the spatial information and the complexity will increase, showing the most advanced possibilities of using gvSIG Desktop in the last modules, through the development of scripts in Python and R.

Here we present the links to the different modules of the course:

  1. Introduction to gvSIG Desktop: interface, add-ons manager and preferences
  2. Working with Views and Data
  3. Navigation and selection tools
  4. Creating layers
  5. Data visualization and geoprocessing
  6. Creating symbol libraries
  7. Population calculator
  8. Rossmo Algorithm
  9. Geoprocessing: Mean and median center
  10. Study of events by quadrant
  11. Analysis of events by blocks
  12. Kernel density
  13. Space-time analysis: 4D
  14. Use of Street View from gvSIG
  15. New scripting tools for data analysis
  16. Visualization of crime data with R in gvSIG

The material necessary to follow the course and do the exercises shown in each module is:

  • gvSIG Desktop, that you can download in portable or installable versions and for Windows, Linux and Mac from here.
  • Data. Data downloaded from the open data portal of the city of New York have been used. You can download them from here.
  • Development. For the final modules about Python and R you have the scripts available in the following package. You must install it from the gvSIG Desktop Add-ons Manager.

Finally here you have a series of links to complementary material that will allow you to improve your gvSIG Desktop training:

We hope that you like this initiative and that this course will serve to extend the use of gvSIG in the security sector.

Categories: OSGeo Planet

gvSIG Team: Curso gratuito de Mapeo del delito. SIG en criminología.

OSGeo Planet - Mon, 2018-05-07 11:12

gvSIG Crime es la solución que ofrece la Asociación gvSIG para organizar, analizar y mantener la información relacionada con la seguridad y la delincuencia. Una plataforma adaptada a las necesidades de cada organización y territorio, y que incluye diversos componentes, una importante parte web que establece la infraestructura informática necesaria para organizar, compartir y acceder a la información espacial, con todo tipo de herramientas de análisis espacio-temporal, soporte para tareas de campo, …, y componentes más orientados al análisis avanzado como el Sistema de Información Geográfica (SIG) de escritorio.

Es precisamente en esta última parte en la que se centra este curso de análisis del delito que pretende servir de introducción al uso de gvSIG Desktop, un SIG en software libre y gratuito, como software fundamental para optimizar el análisis de información delictual.

El curso no pretende hacer un recorrido exhaustivo por todas las herramientas de gvSIG Desktop y se centra en realizar mediante ejercicios prácticos una invitación a explorar el potencial de su uso en criminología.

Los objetivos del curso son:

  • Obtener una mejor comprensión de la tecnología geoespacial aplicada a la mapeo del crimen
  • Realizar consultas basadas los atributos de la información y su localización para obtener información precisa
  • Utilizar bases de datos de delitos para generar conjuntos de datos personalizados, mapas de densidad, análisis de puntos calientes (hot-spots) y ejecutar geoprocesos
  • Aprender conceptos básicos de programación (scripting) para poder desarrollar nuevas herramientas de análisis.
  • Introducirse en la aplicación de la Geoestadística para el análisis del crimen.

El curso comienza con módulos básicos, en los que el alumno aprenderá a visualizar información espacial e irá aumentando en complejidad, llegando a mostrar en los últimos módulos las posibilidades más avanzadas de utilización de gvSIG Desktop, mediante el desarrollo de scripts en Python y R.

A continuación os presentamos los enlaces a los distintos módulos que componen el curso:

  1. Introducción a gvSIG Desktop
  2. Trabajar con datos y Vistas
  3. Selección y Navegación
  4. Crear nuevas capas
  5. Visualización de datos y Geoprocesamiento
  6. Crear nueva simbología
  7. Calculador de población
  8. Algoritmo de Rossmo
  9. Centro medio y mediano
  10. Análisis por retícula
  11. Análisis del crimen por bloques (cuadras / manzanas)
  12. Kernel density
  13. 4D. Análisis espacio-temporal
  14. Uso de Street View desde gvSIG
  15. Nuevas herramientas de Scripting para análisis de datos
  16. Visualización de datos de crimen con R

El material necesario para realizar el curso y replicar los ejercicios mostrados en cada módulo es:

  • gvSIG Desktop, que podéis descargar en sus distintas versiones portable o instalable y para Windows, Linux y Mac de aquí.
  • Datos. Se han utilizado datos descargados del portal de datos abiertos de la ciudad de Nueva York. Podéis descargarlos de aquí.
  • Desarrollo. Para los módulos finales de Python y R tenéis los scripts utilizados disponibles en el siguiente paquete. Deberéis instalarlo desde el Administrador de Complementos de gvSIG Desktop.

Por último os dejamos con una serie de enlaces a material complementario al curso que os pueden venir bien para mejorar vuestro aprendizaje de gvSIG Desktop:

  • Manual de gvSIG Desktop.
  • Curso de SIG aplicado a gestión municipal (contiene un buen número de vídeo-tutoriales que recorren gran parte de las herramientas disponibles en gvSIG Desktop…por lo que podéis consultar aquel que os interese de forma especifica).
  • Lista de usuarios. Donde podéis lanzar consultas sobre el uso de gvSIG Desktop a la Comunidad gvSIG.
  • Grupo de Facebook. Hemos creado un nuevo grupo de Facebook orientado a los alumnos del curso y personas interesadas en el uso de los SIG en criminología.
  • Información sobre gvSIG Crime.
  • Para soporte profesional, contactar con la Asociación gvSIG: info@gvsig.com

Esperamos que os guste esta iniciativa y que este curso sirva para extender el uso de gvSIG en el sector de la seguridad.

Categories: OSGeo Planet

Narcélio de Sá: QGIS: Simbologias para uso da terra.

OSGeo Planet - Mon, 2018-05-07 09:21

Qual simbologia eu devo usar em um mapa de uso da terra? Nós temos a solução definitiva.

Para resolver essa questão, e facilitar a vida de pesquisadores de todo o Brasil o IBGE, lançou a terceira edição do Manual Técnico de Uso da Terra . O manual técnico oferece uma perspectiva sintonizada com as questões contemporâneas. Esta nova edição situa os estudos de uso da terra no contexto evolutivo do pensamento geográfico, contempla uma reflexão sobre os conceitos mais atuais que envolvem o tema, em especial sobre aqueles que tratam da sua posição no contexto da globalização da economia, dos problemas ambientais e da questão da equidade, e apresenta o Sistema de Classificação de Uso da Terra para mapeamentos em nível exploratório

Manual Técnico de Uso da TerraManual Técnico de Uso da Terra

O manual nos apresenta uma tabela com as cores, nos sistemas PANTONE, CMYK e RGB, que deve ser utilizadas no mapeamento da cobertura e do uso da terra de todo o Brasil, levando em consideração o Sistema de Classificação de Uso da Terra – SCUT . Para facilitar o uso dessa simbologia para mapeamento eu tomei a liberdade de criar um arquivo .xml com os dados dos estilo de cores retirados da tabela das Classes da cobertura e do uso da terra Níveis I e II.

Esse arquivo, que pode ser facilmente importado para o QGIS, carrega as informações de todas as classes suas respectivas simbologias agregando os símbolos ao biblioteca do software.

Faça o download das simbologias para mapas de classes de cobertura e do uso da terra.

A instalação de uma nova simbologia no QGIS é bem simples, basta seguir os seguintes passos:

  1. Faça o Download do arquivo: “sistema_de_classificacao_de_uso_ da_terra_ibge.xml”
  2. Feito o download do arquivo, abra o QGIS e abra a aba Configurações > Gerenciador de Estilos > procure o botão Compartilhar > Importar
  3. Navegue até a pasta onde se encontra o arquivo sistema_de_classificacao_de_uso_ da_terra_ibge.xml que você baixou.
  4. Feito isso você verá todas as novas simbologias que serão adicionadas a biblioteca do QGIS. Clique na opção selecionar tudo e depois em importar.

Pronto agora você tem todas as classes da cobertura e do uso da terra e suas respectivas simbologias no seu QGIS, agora é só começar a mapear. Aproveite e instale também as simbologias para mapeamento pedológico.

Fonte: Publicações Manual Técnico de Uso da Terra

The post QGIS: Simbologias para uso da terra. appeared first on Narcélio de Sá.

Categories: OSGeo Planet
Syndicate content