News aggregator

gvSIG Team: GIS audiovisual course audiovisual with Game of Thrones cartography

OSGeo Planet - Mon, 2019-04-08 14:39

Some days ago we launched an idea: what if we celebrate the broadcast of the Game of Thrones final season with a GIS course? The enthusiastic response that we obtained in social networks has encouraged us to record a new course to learn SIG using the Game of Thrones cartography. The collaboration between the gvSIG Association and the Miguel Hernández University has made it possible. Video-quality tutorials, easy to follow and replicate. Of course the course is totally free of charge. You only have to follow each of the modules/videos of the course, and use the free and open source gvSIG Desktop software to be able to replicate the exercises shown at the videos. The files with the necessary cartography to follow the course are also available.

All the videos are available in a Youtube playlist, which you can access by clicking on the following link: Playlist. For those who prefer it, the course is also available in Spanish.

Syllabus

The course is formed by these modules:

  • Loading data in a GIS
  • Attribute tables
  • Navigation in a GIS
  • Selection by attributes
  • Table editing
  • Hyperlink
  • Adding coordinates
  • Field calculator
  • Exporting view to image
  • Legends and symbology
  • Labelling
  • Graphical editing
  • Geoprocessing
  • Layouts
Software

The software that we will use during the course is gvSIG Desktop 2.5. For newcomers, gvSIG Desktop is a free and open source Geographical Information System, available in more than thirty languages and with distributions for Windows and Linux (distribution for Mac will be available at the final version).

Those who regularly follow the gvSIG project news, you will know that the latest version of gvSIG Desktop is 2.4, and that 2.5 is in the stabilization phase. And why do we launch the course on gvSIG 2.5, if it is not a final version? On the one hand because it brings some very interesting novelties that can be used during the course and, on the other hand, because in exchange for enjoying this course you can help us to test gvSIG 2.5 and detect bugs.

Categories: OSGeo Planet

gvSIG Team: Curso audiovisual de SIG con cartografía de Juego de Tronos

OSGeo Planet - Mon, 2019-04-08 14:39

Hace unos días lanzamos una idea, ¿y si celebramos la emisión de la temporada final de Juego de Tronos con un curso de SIG? La entusiasta respuesta que obtuvimos en las redes sociales, nos ha animado a grabar un nuevo curso para aprender SIG utilizando la cartografía de Juego de Tronos. La colaboración entre la Asociación gvSIG y la Universidad Miguel Hernández lo ha hecho posible. Vídeo-tutoriales de calidad, fáciles de seguir y de replicar.

Por supuesto el curso es totalmente gratuito. Simplemente debéis ir siguiendo cada uno de los módulos/vídeos del curso, y utilizar el software libre y gratuito gvSIG Desktop para poder replicar los ejercicios mostrados en los vídeos. Los ficheros con la cartografía necesaria para seguir el curso también los tenéis disponibles.

Todos los vídeos están disponibles en una lista de reproducción de Youtube, a la que podéis acceder pulsando en el siguiente enlace: Lista de reproducción

Para aquellos que lo prefieran, el curso también está disponible en inglés.

Temario

El curso está dividido en los siguientes módulos:

  • Cargar datos en un SIG
  • Tablas de atributos
  • Navegación en un SIG
  • Selección por atributos
  • Edición de tablas
  • Hiperenlace y herramientas de información
  • Añadir coordenadas
  • Calculadora de campos
  • Exportar Vista a imagen
  • Leyendas y simbología
  • Etiquetado
  • Edición gráfica
  • Geoprocesamiento
  • Mapas
Software

El software que utilizaremos durante el curso es gvSIG Desktop en su versión 2.5. Para los recién llegados, gvSIG Desktop es un Sistema de Información Geográfica libre y gratuito, disponible en más de una treintena de idiomas y con distribuciones para Windows y Linux (habrá portable para Mac en la distribución final).

Los que sigáis habitualmente las novedades del proyecto gvSIG, sabréis que la última versión de gvSIG Desktop es la 2.4, y que la 2.5 está en fase de estabilización. ¿Y porqué lanzamos el curso con gvSIG 2.5, si no es una versión final? Por un lado porque trae algunas novedades muy interesantes que ya se pueden usar durante el curso y, por otro, porque a cambio de poder disfrutar de este curso nos podéis ayudar a testear gvSIG 2.5 y a detectar errores.

Categories: OSGeo Planet

Fernando Quadro: Introdução ao Leaflet – Calculando distância

OSGeo Planet - Mon, 2019-04-08 10:30

Hoje vamos usar o Turf.js para calcular a distância entre dois pontos ao longo da trilha. O Turf.js é classificado como “Análise geoespacial avançada para navegadores e Node.js.” A distância calculada é uma distância em linha reta em vez de quilômetros de trilha reais.

1. Incluindo o Turf.js

Para calcular a distância, precisamos incluir o Turf.js em nosso projeto. Em vez de instalá-lo localmente, basta adicionar essa linha ao cabeçalho do seu HTML:

  <script src='https://npmcdn.com/@turf/turf/turf.min.js'></script>

O Turf.js vem como um único arquivo JavaScript e é bem grande. Se você planeja usá-lo regularmente, considere fazer uma compilação personalizada que contenha apenas os recursos necessários. Você pode encontrar informações sobre como fazer isso no site do Turf.js.

2. Configurando o HTML

Precisamos adicionar dois dropdowns (selecionados): uma para o local “de” e outra para o local “para”. Também criamos um botão “calcular” e um div para conter o resultado:

Calculate distance from:      <select id='fromBox'>     </select> to:      <select id='toBox'>     </select>     <input type="button" id="calculate" value="Calculate">     <div id="distanceResult"></div>

3. Calculando e exibindo a distância

Primeiro, configuramos os dois campos dropdown com a lista de marcos (markers). Para calcular a distância, obtemos as informaçõe “De” e “Para” e passamos as coordenadas como objetos turf.point para a função de distância do Turf.js.

  fromBox = document.getElementById('fromBox');   toBox = document.getElementById('toBox');   var featuremap = {};   for (var i = 0; i < trail_stops['features'].length ; i++){       feature = trail_stops['features'][i];       //console.log(feature['properties']['name']);       featuremap[feature['properties']['name']] = feature['properties'];       var fromopt = document.createElement('option');       fromopt.value = feature['properties']['name'];       fromopt.innerHTML = feature['properties']['name'];       fromBox.appendChild(fromopt);       var toopt = document.createElement('option');       toopt.value = feature['properties']['name'];       toopt.innerHTML = feature['properties']['name'];       toBox.appendChild(toopt);   }   document.getElementById('calculate').onclick = calculateDistance;   function calculateDistance(){       from = fromBox.value;       to = toBox.value;       fromobj = featuremap[from];       toobj = featuremap[to];       var fromPt = turf.point([fromobj['prim_lon_1'], fromobj['prim_lat_d']]);       var toPt = turf.point([toobj['prim_lon_1'], toobj['prim_lat_d']]);       var distance = turf.distance(fromPt, toPt, {units: 'kilometers'});       console.log(distance)       var distanceMiles = distance * 0.6214               document.getElementById('distanceResult').innerHTML = 'Distance is: ' + distance.toFixed(2) +           ' kilometers (' + distanceMiles.toFixed(2) + ' miles)';   }

Agora vou explicar o passo a passo do código acima:

  • As linhas 1 a 16 preenchem os campos dropdown usando os dados do arquivo GeoJSON trail_stops.
  • A linha 18 configura o botão calcular para chamar a função calculateDistance (linhas 20 a 33).
  • Nas linhas 21-26, obtemos os marcadores "de"/"para" e usando o featuremap, obtemos a latitude e a longitude para criar dois objetos turf.point. O aviso turf.point é criado especificando a longtiude (valor x) primeiro.
  • A linha 27 calcula a distância e a linha 28 registra-a no console.
  • A linha 29 converte de quilômetros em milhas.
  • As linhas 31 a 32 definem o texto para a div distanceResult.
  • Por último calcula a distância e nos retorna o resultado em quilômetros e milhas, conforme a imagem abaixo:



4. O Código

Para obter o código completo, clique aqui.

Categories: OSGeo Planet

CARTO Blog: The Spring 2019 Data Science & LI Event Guide

OSGeo Planet - Mon, 2019-04-08 10:00
Looking for insightful speakers presenting the latest developments in Location Intelligence and Spatial Data Science? Want workshops of tools and technologies that can help...
Categories: OSGeo Planet

gvSIG Team: Plataforma municipal para la gestión de la información geográfica

OSGeo Planet - Sat, 2019-04-06 14:50

Os dejamos con un vídeo de presentación de la Suite gvSIG aplicada a gestión municipal; seguro que os da muchas ideas de los múltiples usos que pueden tener las soluciones gvSIG para optimizar la gestión municipal.

Relacionado con esto, tenéis un conjunto de presentaciones de casos reales en el siguiente enlace: ¡Aquí mismo!

Y nunca está de más recordaros que tenéis disponible un curso gratuito (con certificación opcional) para aprender a trabajar con la Suite gvSIG en la Administración Local. Un curso que ya han realizado miles de usuarios. ¿Te animás?

Enlace al curso: ¡Me ánimo!

Categories: OSGeo Planet

gvSIG Team: Recording of presentations given at 4th gvSIG Festival are now available

OSGeo Planet - Fri, 2019-04-05 18:35

Recording of the 4th gvSIG Festival presentations is already available. The gvSIG Festival is the virtual conference about gvSIG that was held on April 17 and 18, in which this year we wanted to give special visibility to women who work in the world of geomatics.

If you could not follow the live presentations you can now watch the recording of them, which are available on the gvSIG website.

During the festival there were a great variety of presentations, speaking about topics like cases studies about Geopaparazzi, about analysis of extreme events ​​​​​​​with the HortonMachine tools in gvSIG Desktop or how to get a diverse team to work with.

Don’t miss any of the presentations!

Categories: OSGeo Planet

gvSIG Team: Grabaciones del 4º gvSIG Festival ya disponibles

OSGeo Planet - Fri, 2019-04-05 18:28

Ya están disponibles las grabaciones del 4º gvSIG Festival, las jornadas virtuales sobre gvSIG que se celebraron los días 17 y 18 de abril en las que este año hemos querido dar especial visibilidad a las mujeres que trabajan en el mundo de la geomática.

Si no pudisteis seguir las ponencias en directo podéis ver ahora las grabaciones de las mismas, las cuales están disponibles en la web de gvSIG.

Entre los temas tratados en las presentaciones hubo casos de uso sobre gvSIG Mobile para inventario de mobiliario urbano, sobre gvSIG Desktop para situación de plantas fotovoltaicas, o temas como el grupo de Geochicas en Latinoamérica o cómo conseguir un equipo diverso para trabajar.

¡No os perdáis ninguna de las presentaciones!

Categories: OSGeo Planet

Fernando Quadro: Introdução ao Leaflet – Zoom

OSGeo Planet - Thu, 2019-04-04 10:30

Neste post vamos adicionar um botão de zoom para deslocar o mapa para um ponto na camada de trilhas.

1. Adicionando um dropdown e um botão

A primeira coisa a fazer é adicionar o elemento select e um botão ao HTML:

  <select id='zoombox'>   </select>   <input type="button" id="zoomTo" value="Zoom to point">

Vamos preencher as opções para o elemento select usando os dados do GeoJSON.

2. Criando um dicionário e preenchendo a caixa de seleção

Em seguida, vamos percorrer a camada GeoJSON e criar um dicionário que mapeia o nome para seus dados e, em seguida, adicionar cada um deles como uma opção a um elemento select:

  selectbox = document.getElementById('zoombox');   var featuremap = {};   for (var i = 0; i < trail_stops['features'].length ; i++){       feature = trail_stops['features'][i];       //console.log(feature['properties']['name']);       featuremap[feature['properties']['name']] = feature['properties'];       var opt = document.createElement('option');       opt.value = feature['properties']['name'];       opt.innerHTML = feature['properties']['name'];       selectbox.appendChild(opt);   }

Veja como é o funcionamento:

- A primeira linha obtém o elemento select no HTML.

- A terceira linha declara o dicionário para manter as opções da caixa de seleção.

- Nas linhas 5 a 12, percorremos cada recurso em nossa camada GeoJSON trail_stops e preenchemos o mapa de recursos, usando o nome como a chave (linha 8).

- Remova o comentário da linha 7 se quiser ver cada recurso exibido no console JavaScript.

- As linhas 9 a 12 configuram a caixa de seleção com cada nome.

3. Ligando o botão

Precisamos configurar o evento onclick e definir uma função em nosso arquivo JavaScript para fazer o trabalho real:

document.getElementById('zoomTo').onclick = zoomToTown; function zoomToTown(){     key = selectbox.value;     obj = featuremap[key];     map.setView([obj['prim_lat_d'], obj['prim_lon_1']], 9); }

Vou detalhar abaixo o que foi feito, para facilitar a sua compreensão:

- A linha 1 configura o evento onclick para chamar a função zoomToTown quando o botão é clicado.

- A linha 4 obtém o valor atual do dropdown e na linha 5, usamos para buscar o objeto.

- Usando os nomes de campo prim_lat_de, prim_lon_1, e a função map.setView para definir a visualização e o nível de zoom (15).

- O resultado nos dá o mapa com um dropdown e um botão abaixo dele. Selecione uma cidade na lista e clique no botão "Zoom to town" e o mapa será deslocado para o novo local.



4. O Código

Para obter o código completo, clique aqui.

Categories: OSGeo Planet

Cameron Shorter: Amplifying Google's Season of Docs

OSGeo Planet - Wed, 2019-04-03 18:03
Google has initiated a Season of Docs collaborative program aimed at improving open source documentation. It provides a great opportunity for us involved in open source and documentation to focus on big communication challenges.
Challenges
  • Vision: Does everyone know the characteristics of good open source documentation? Does anyone know? Let’s collate research and best practices into accessible guides and templates.
  • Targetted: Projects have a range of audiences with differing technical backgrounds, attention spans and information needs. A range of documentation types are needed. Each requires different levels of depth, specificity, currency, narrative, personalisation, examples, and more.
  • Empower everyone to contribute: Good documentation benefits from cross-disciplinary contributions: from developers, users, domain experts, teachers, technical writers, graphic artists, and translators. Ramp-up time is high for any group attempting to learn another’s skill-set. Open source documentation processes are typically set up by developers, for developers, and have a significant barrier-to-entry for others. How can we fix that?
  • Attract volunteers: How can we apply our knowledge of collaborative and volunteer communities to attract documentation teams? How can we help volunteers maximise the impact and effectiveness of their contributions?
  • Current and Sustainable: How can we sustainably keep documentation synchronised with rapidly evolving software? How do we help users find current material and archive outdated docs? How do we minimise maintenance?
What to focus on?To maximise value, I suggest promoting initiatives which:
  • Use and contribute to documentation best practices.
  • Use templates and guides for key documentation types to help cross-domain collaboration.
  • Attracts volunteers, from multiple user profiles.
  • Applies multi-directional mentoring.
  • Refines workflows and tools to reduce barriers-to-entry.
  • Focuses on a specific initiative which tests the bounds of these ideas for a specific project and captures lessons learned.
This might involve:
  • Auditing existing documentation.
  • Defining a writing strategy.
  • Developing or refining a specific documentation type for a project.
  • Mentoring a project’s community, increasing the initiative's sustainability.
  • Contributing to best practices.
If we can achieve this:
  • Writer contribution impact will be maximised,
  • Community writing will become more effective,
  • And documentation maintenance will become more sustainable.
Further ReadingGeneral:
Documentation Strategy:
Research into building open source communities:
Geospatial open source:
Categories: OSGeo Planet

QGIS Blog: Crowdfunding initiatives in spring 2019

OSGeo Planet - Tue, 2019-04-02 19:57

Currently there are a number of ongoing crowdfunding initiatives for improvements in QGIS that need your support:

1. Diagrams in print layouts, atlas and reports: the popular data plotly plugin for interactive, exploratory charts and diagrams should be enhanced to support embedding in print layouts, atlas serial prints and reports. Details can be found at the North Road campaign website. This is a joint effort of companies Faunalia and North Road. Funding goal: € 8’600 (1’780 collected as of April 2, 2019)

2. Cartography proposal: selective masking of symbol levels behind labels and map symbols. Inspired by the high-quality topographic maps of Swisstopo. Details can be found at the Oslandia campaign website. Funding goal: € 20’000 (8’000 collected as of April 2, 2019)

3. GeoPDF-Export: Export of georeferenced PDF files, with the possibility to measure, query coordinates, toggle map layers and query feature attributes. The project is partitioned into several work packages. This is a joint effort of Even Rouault and North Road on request of several Austrian local government agencies. For more details, please contact Johannes Kanonier of the Landesvermessungsamt Vorarlberg. Funding goal: € 30’800 (24’400 collected as of April 2, 2019)

4. SLYR: Converter for ESRI LYR and MXD-Files. Project is partitioned in several work packages for the conversion of ESRI styles to QGIS styles, MXD-Files into QGIS project files and ESRI layouts to QGIS layouts. Please find more details at the SLYR website of North Road.

Thank you for your support in making these projects a reality!

Categories: OSGeo Planet

Fernando Quadro: Introdução ao Leaflet – Coordenadas

OSGeo Planet - Tue, 2019-04-02 15:43

Neste post, faremos algumas coisas:

– Limpar a exibição da precisão de coordenadas em nossos pop-ups
– Adicionar as coordenadas atuais ao mapa enquanto o mouse se move

1. Exibição de precisão das coordenadas

O mapa atual exibe a latitude e longitude com sete casas decimais. Isso é mais do que precisamos ver ao exibir informações sobre locais:

Consertar isso é fácil usando a função JavaScript toFixed. Aqui está um trecho de código da camada de trilhas:

onEachFeature: function( feature, layer){ var townName = feature.properties.feature_na; var elevation = feature.properties.elev_in_m; var lat = feature.properties.prim_lat_d.toFixed(3); var lon = feature.properties.prim_lon_1.toFixed(3);

Observe que adicionamos toFixed(3) aos valores de latitude e longitude. Isso nos dá uma exibição melhor, sem alterar os dados em si. Se você for observador, você deve ter notado que nós já fizemos isso para a camada placer em nosso último post (parte 6), nós apenas não sinalizamos isso.

2. Exibindo coordenadas no mapa

Às vezes é bom saber onde você está no mundo. Para fazer isso, adicionaremos uma exibição das coordenadas do mapa que são atualizadas conforme movemos o mouse.

Para fazer isso, precisamos criar um div que seja filho do nosso div mapDIV. Também precisamos estilizá-lo para configurar sua localização:

var coordDIV = document.createElement('div'); coordDIV.id = 'mapCoordDIV'; coordDIV.style.position = 'absolute'; coordDIV.style.bottom = '0'; coordDIV.style.left = '0'; coordDIV.style.zIndex = '900'; document.getElementById('mapDIV').appendChild(coordDIV);

Isso configura nosso local de exibição no canto inferior esquerdo do mapa. O zIndex de 900 garante que seja exibido em cima de todo o resto.

Em seguida, precisamos configurar o evento para fazer a captura e exibição real das coordenadas à medida que o mouse se move.

// Setup the event to capture and display mouse movements map.on('mousemove', function(e){ var lat = e.latlng.lat.toFixed(3); var lon = e.latlng.lng.toFixed(3); document.getElementById('mapCoordDIV').innerHTML = lat + ' , ' + lon; });

Você pode ter notado um problema. A exibição de coordenadas ocupa o mesmo lugar que a barra de escalas. Isso ocorre porque, por padrão, o controle da barra de escala ocupa o canto inferior esquerdo do mapa. Vamos mover a tela de coordenadas ajustando as posições:

coordDIV.style.bottom = '1px'; coordDIV.style.left = '150px';

Com isso o coordDIV sobe 1 pixel e se desloca 150px à direita, e assim não está mais atingindo a barra de escala, mas a fonte não está totalmente legível, e podemos fazer alguns ajustes adicionando algumas configurações de estilo no coordDIV:

coordDIV.style.color = '#404040'; coordDIV.style.fontFamily = 'Georgia'; coordDIV.style.fontSize = '10pt'; coordDIV.style.backgroundColor = '#fff';

O comando acima faz uma série de coisas:

– Define a cor da fonte para um tom de cinza para que não seja tão intrusivo
– Altera a fonte para a Geórgia (apenas por diversão)
– Define o tamanho da fonte para 10 pt
– Altera a cor de fundo do div para branco para que apareça melhor no mapa

3. O Código

O código completo pode ser baixado aqui.

Categories: OSGeo Planet

Fernando Quadro: Introdução ao Leaflet – Geopackage

OSGeo Planet - Mon, 2019-04-01 10:30

Neste post vamos “trocar de marcha” e instalar o Leaflet localmente, depois adicionar uma camada de um arquivo GeoPackage.

1. Instalando o Leaflet

Até agora, estamos usando uma versão hospedada no servidor do Leaflet. Em outras palavras, cada vez que carregamos o mapa, é feita uma solicitação para buscar o CSS e o JavaScript do Leaflet.

<link rel="stylesheet" href="https://unpkg.com/leaflet@1.4.0/dist/leaflet.css"   integrity="sha512-puBpdR0798OZvTTbP4A8Ix/l+A4dHDD0DGqYW6RQ+9jxkRFclaxxQb/SJAWZfWAkuyeQUytO7+7N4QKrDh+drA=="   crossorigin=""/>    <script src="https://unpkg.com/leaflet@1.4.0/dist/leaflet.js"   integrity="sha512-QVftwZFqvtRNi0ZyCtsznlKSWOStnDORoefr1enyq5mVL4tmKB3S/EnC3rRJcxCPavG10IcrVGSmPh6Qw5lwrg=="   crossorigin=""></script>

Existem algumas maneiras de instalar o Leaflet : baixe-o do site ou instale-o npm. Em ambos os casos, você precisará mover os arquivos leaflet.js, leaflet.css e o diretório de images para o local apropriado para o seu site.

Uma vez instalado, o arquivo HTML precisa ser alterado para refletir a localização dos arquivos:

<link rel="stylesheet" href="/stylesheets/leaflet.css" /> <script src="/js/leaflet.js"></script>

2. Usando o Plugin

Para acessar as camadas do GeoPackage, precisamos usar o plugin leaflet-geopackage. Podemos usá-lo sem instalar como fizemos anteriormente com o Leaflet:

<script src="https://unpkg.com/@ngageoint/leaflet-geopackage@2.0.5/dist/leaflet-geopackage.min.js"></script>

3. Adicionando a camada GeoPackage

O código para adicionar e estilizar a camada é:

var placer = L.geoPackageFeatureLayer([], {   geoPackageUrl: 'code/points.gpkg',   layerName: 'points',   pointToLayer: function(feature, latlng){   return L.circleMarker(latlng, {radius: 5, stroke: false, fillColor: '#800000', fillOpacity: 0.6});   },   onEachFeature: function( feature, layer){   var name = feature.properties.name;     var lat = feature.properties.prim_lat_d;   var lon = feature.properties.prim_lon_1;   layer.bindPopup('Name: ' + name +      '<br/>Lat/Lon: ' + lat + ' , ' + lon);   layer.on('mouseover', function() {layer.openPopup();});   layer.on('mouseout', function() {layer.closePopup();});   }   });

A camada é criada especificando a URL (caminho) para o arquivo GeoPackage e fornecendo o nome da camada (points). O restante do código se parece muito com código visto no último post.

Na opção pointToLayer, estilizamos um pouco diferente, removendo o traço (contorno) do círculo e fornecendo uma cor vermelha escura com opacidade de 0,6.

Na opção onEachFeature é semelhante, com exceção dos nomes de campo usados ​​para o pop-up.

A camada pointsé adicionada à lista de superposições, mas inicialmente não é visível. Quando ativado no controle de camada, o mapa se parece com isto:



4. O Código

O código completo pode ser baixado clicando aqui.

Categories: OSGeo Planet

CARTO Blog: Airship 2.0 is here

OSGeo Planet - Mon, 2019-04-01 10:00
Today we are very happy to announce a new version of Airship, our front-end library for building Location Intelligence applications. In this version, we focused on bringing...
Categories: OSGeo Planet

GRASS GIS: New crowd funding campaign

OSGeo Planet - Thu, 2019-03-28 22:10
Join our crowd funding campaign !
Categories: OSGeo Planet

gvSIG Team: Towards gvSIG 2.5: Quick access to Snapping tools

OSGeo Planet - Thu, 2019-03-28 18:56

We show you another novelty of the new gvSIG Desktop version that will make the editing tasks easy through quick access to the Snapping or reference to objects configuration in a layer.

The window that allows you to configure the type of snapping (end point, medium point, near point …), and the tolerance in pixels, was inside the “Configuration” window in previous versions. In addition, if we wanted to activate or deactivate snapping we had to use a quick access key or use the command available at the “Edit” menu.

Thanks to the “Quick access to Snapping Tool” plugin we will be able to access the snapping options at any time and we can leave the floating window while editing. In this waywe can change the available options at any time.

In the next video we show how snapping worked so far, the plugin installation through the add-on manager, and how it works now.

Categories: OSGeo Planet

Marco Bernasocchi: QField 1.0 is here

OSGeo Planet - Thu, 2019-03-28 15:34
Let’s get straight to the point

It’s official, QField for QGIS 1.0 is out!

Get it while it’s hot on the Playstore (qfield.org/get) or on GitHub

We are incredibly pleased and proud of just having released such a jewel and are convinced that, thanks to all its features and conscious design choices, QField will make your field digitizing work much more efficient and pleasant.

Packed with loads of useful features like online and offline features digitizing, geometry and attributes editing, attribute search, powerful forms, theme switching, GPS support, camera integration and much more, QField is the powerful tool for those who need to edit on the go and would like to avoid standing in the swamp with a laptop or paper charts.

Let’s see what makes QField probably* the best mobile GIS in the world.

Work efficiently

QField focuses on efficiently getting GIS field work done and combines a minimal design with sophisticated technology to get data from the field to the office in a comfortable and easy way.

Fast and reactive

Thanks to the underlying QGIS engine and a lot of optimizations, QField is powerful and snappy. Even with complex projects, QField is a joy to work with.

Easy handling

Conscious design choices and a continuous focus on a minimal user interface drive QField’s development. This allows us to deliver a product wich is uncluttered and extremly user-friendly

Quickly digitise

Allowing a seamless digitizing experience is a paramount goal of QField. Thanks to a cleverly designed adaptive user interface and specific features like real-time attribute checks and snapping support, QField allows its users to be extremely time efficient.

Unmatched feature set

To be the best, you need to be clever but also skillful.

QField’s efficiency is matched only by its featureset that allows its users to make the most out of their fieldwork time.

Powerful cartography combined with full text search

The beauty of GIS is that maps are dynamic. Layers can individually be shown and hidden and information can be presented more or less prominently based on the task at hand. QField supports the endless styling possibilities offered by QGIS and thanks to a well placed theme switcher you can change the looks of the entire project with a single click. For even more customizability, QField allows hiding and showing layers by simply long-pressing on the layer name.

Furthermore, QField boasts a fully configurable attribute text search that will allow you to geolocate and edit that exact object you were looking for.

Geometry editing

Editing Geometries on the field is probably the most complex task an operator has to deal with. QField simplifies this process through an adaptive toolbar that appears only when necessary, snapping support and a crosshair digitizer.

Thanks to these enhancements, QField allows reducing the error rate significantly.

Support for high precision GNSS

Simple internal GPS accuracy might be enough for basic projects but cadastral surveying and other high accuracy digitizations have much higher requirements. QFields natively listens to the Android location services so it can take advantage of the best location provided by external devices.

Generate PDF

Thanks to QField’s native support for generating PDFs based on QGIS’s print layouts, your on the fly daily report map is just one click away.

Intuitive project chooser

When dealing with multiple projects, quickly being able to switch between them is key. QField comes with a beautiful file selector with favorite directories (long press on a folder to add it to the favorites and long press on the favorites list to remove it) and an automatic list of the last three opened projects that will save you heaps of time while looking for your projects.

Your data – Your decisions

QField does not impose any constraint on the data model, it is your data and you decide what they should look like and what values are acceptable. QField can enforce constraints for you and you can choose among various type of widgets to represent your data. QGIS will preconfigure some field types automatically, all you’ll have then to do is tweak the settings if you want and your project is ready for mobile prime time. Our documentation has all the information you need.

Extends your Geo Data Infrastructure seamlessly

QField uses QGIS to set up maps and forms so it automatically supports a wide variety of data formats. Thanks to this, you can comfortably prepare your project once and then deploy it everywhere. And since QGIS also has a server component, your project can be served on a WebGIS with the very same beautiful looks.

In fact you can see this exact infrastructure up and running under demo.qfield.org and with the “online_survey.qgs” project included in the QField demo projects.

Synchronize with WiFi, Cable or Network

You can synchronize your project and data (in case you are not using a centralized online database) using various methods thanks to our QFieldSync plugin.

Future cloud integration

In the near future we will add a cloud synchronization functionality, so that you will be able to seamlessly manage your project online and have them automatically deployed to your devices.

Installing and contributing

You can easily install QField using the Playstore (qfield.org/get), find out more on the documentation site (qfield.org), watch some demo videos on our channel (qfield.org/demo) and report problems to our issues tracking system (qfield.org/issues). Please note that the Playstore update can take some hours to roll out and if you had installed a version directly from GitHub, you might have to uninstall it to get the latest Playstore update.

QField, like QGIS, is an open source project. Everyone is welcome to contribute to making the product even better – whether it is with financial support, translation, documentation work, enthusiastic programming or visionary ideas.

We would like to thank our fantastic community for all the great translations, documentations, bug reports and general feedback they gave us. Thanks to all this, we were able to fix plenty of bugs, address performance issues and even add some super cool new features.

Development and deployment services

As masterminds behind QField and core contributor to QGIS, we are the perfect partner for your project. If you want to help us build a better QField or QGIS, or if you need any services related to the whole QGIS stack, don’t hesitate to contact us.

OPENGIS.ch

OPENGIS.ch helps you setting up your spatial data infrastructure based on seamlessly integrated desktop, web, and mobile components.
We support your team in planning, developing, deploying and running your infrastructure. Thanks to several senior geodata infrastructure experts, QGIS core developers and the makers of the mobile data acquisition solution QField, OPENGIS.ch has all it takes to make your project a success. OPENGIS.ch is known for its commitment to high-quality products and its continuous efforts to improve the open source ecosystem.

* We might be biased, but we do believe it

Categories: OSGeo Planet

Jackie Ng: Announcing: MapGuide Open Source 3.1.2

OSGeo Planet - Thu, 2019-03-28 12:42
I am pleased to announce the availability of MapGuide Open Source 3.1.2

The notable changes in this release are detailed below:

Updated Web Tier Components

MapGuide Open Source bundles updated web tier components:

  • Apache HTTPD 2.4.37
  • Tomcat 7.0.92
  • PHP 5.6.40
Since PHP 5.6 is now end-of-life, this is most likely the last release in the 3.1 branch as we work to bring PHP 7 support for the MapGuide API in the next major release.
Functional SHP FDO provider for 64-bit Linux
Over the new year, I had set out to solve one of the last remaining blockers that prevented us from having a functional 64-bit SHP FDO provider for 64-bit Linux.
I had speculated that the blocker is due to incorrect data size assumptions in the SHP spatial indexing code on 64-bit Linux which would throw off spatial index queries. Intensive debugging sessions proved this to be the case and I was finally able to land the long-awaited fixes which is now available with the SHP provider bundled with this release.
The proof that the provider was truly functional was being able to load a SHP-heavy dataset into a 64-bit MapGuide Server and being able to pan, zoom, select and buffer SHP features without any errors or features disappearing in and out at various zoom levels (due to previously out-of-whack SHP spatial index queries)

Experimental King.Oracle FDO provider for Linux (32 and 64-bit)
Since I got a major win with one Linux FDO blocker and was on a roll, I figured we can do a double-whammy with the other major Linux FDO blocker: The lack of a functional King.Oracle FDO provider on Linux.
For this one I had speculated that the problem was due to heavy usage of wchar_t for strings which (due to different size assumptions on Linux) meant that most strings going in and out of the provider on Linux were garbage, meaning the SQL queries we think we were sending to OCI for execution were completely scrambled.
Due to the lack of solid examples of using OCI with wchar_t strings on Linux, I figured the code as it currently stands will never work on Linux. So I took the page out of a reference implementation I knew to definitely work on Linux (the OCI driver for GDAL/OGR) and wholesale #ifdef'd the entire provider codebase to use narrow (char) strings for Linux and their expected OCI functions, while retaining wide (wchar_t) strings and current OCI function usage for Windows.
The ability to easily spin up an Oracle XE environment (well until recently at least) meant that I was able to quickly verify that switching to narrow strings on Linux was indeed the way to go. This also provided motivation for me to implement a basic (and repeatable) unit test suite for this provider, finally giving us an objective baseline level of validation and verification for this provider.
The end result of all this is that the King.Oracle provider now not only builds on Linux, but it now finally works!

However, I'm certain that there will be bugs in this provider for Linux waiting to be revealed, so the provider gets the "experimental" label. Use at your own risk/discretion. Please do report any issues you find.
OGR FDO Provider Improvements
The OGR provider has undergone many "quality of life" improvements:
  • We've cleaned up various correctness issues around provider behavior. For example, attempting to access invalid property names in an OGR feature reader will now throw instead of silently failing before.
  • The provider supports a new DefaultSchemaName property that lets you specify a default schema name other than OGRSchema
  • The provider also supports a new DataSourceEncoding property to allow you declare the encoding for an OGR data source where it cannot be inferred by default by the OGR library so that properties/names/etc with non-english characters are rendered properly.
Fusion ChangesOther Changes

Download/Release Notes
Categories: OSGeo Planet

Fernando Quadro: Introdução ao Leaflet – Trabalhando com Features

OSGeo Planet - Wed, 2019-03-27 17:48

Hoje vamos adicionar alguns pontos na rota que criamos nos últimos posts. O método para adicionar esses pontos será adicionar uma camada GeoJSON, adicionando um marcador e pop-up com algumas informações.

1. Os marcadores

Para os locais, usaremos marcadores de círculo. Para criar um único marcador, use:

var circle = L.circleMarker([-20.1438, -44.1301], { radius: 15 });

Um marcador de círculo é adicionado ao mapa como de costume:

circle.addTo(map);

Para adicioná-los aos nossos recursos GeoJSON, a sintaxe será um pouco diferente, já que estamos processando-os em um loop.

2. Adicionando a camada com marcadores de círculo e pop-up

Para adicionar os marcadores, percorremos o conjunto de dados usando a opção onEachFeature e também adicionamos um pop-up para exibir elevação, latitude e longitude:

var towns = L.geoJSON(trail_stops,            {pointToLayer: function(feature, latlng){               return L.circleMarker(latlng, {radius: 5, color: '#00008b',                                               fillOpacity: 0.5,                                             });           },             onEachFeature: function( feature, layer){                 var townName = feature.properties.feature_na;                 var elevation = feature.properties.elev_in_m;                 var lat = feature.properties.prim_lat_d;                 var lon = feature.properties.prim_lon_1;                 layer.bindPopup('Name: ' + townName +                                 '
Elevation: ' + elevation +                                 '
Lat/Lon: ' + lat + ' , ' + lon);                 layer.on('mouseover', function() {layer.openPopup();});                 layer.on('mouseout', function() {layer.closePopup();});             }           }); towns.addTo(map);

A camada GeoJSON é criada e, usamos a opção pointToLayer para criar um circleMarker para cada recurso.

Na sequencia, criamos variáveis ​​para conter os atributos do pop-up e, em seguida, vinculamos o pop-up ao recurso. Poderíamos ter usado as propriedades do recurso diretamente na instrução bindPopup, mas atribuí-las aos variables facilita um pouco a leitura do código.

Por fim, adicionamos os eventos do mouse para exibir e remover o pop-up no mouse e, em seguida, adicionamos a camada ao mapa.

O resultado é assim:

3. O Código

Veja o código JavaScript completo:

var map = L.map(document.getElementById('mapDIV'), {     center: [-20.1438, -44.1301],     zoom: 11     }); // Base maps var basetopo = L.tileLayer('https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/WMTS/tile/1.0.0/USGSTopo/default/default028mm/{z}/{y}/{x}.png', {}); var baserelief = L.tileLayer('https://tile.opentopomap.org/{z}/{x}/{y}.png', {}); basetopo.addTo(map); baserelief.addTo(map);       var thetrail = L.geoJSON(trail, {         color: '#800000',         weight: 3,         dashArray: '12 8 12',     });     thetrail.bindTooltip('Trilha Brumadinho')     thetrail.addTo(map); var towns = L.geoJSON(trail_stops,                        {pointToLayer: function(feature, latlng){                           return L.circleMarker(latlng, {radius: 5, color: '#00008b',                                                          fillOpacity: 0.5});                       },                       onEachFeature: function( feature, layer){                           var elevation = feature.properties.elev_in_m;                           var lat = feature.properties.prim_lat_d;                           var lon = feature.properties.prim_lon_1;                                                      layer.bindPopup('
Elevation: ' + elevation +                                          '
Lat/Lon: ' + lat + ' , ' + lon);                           layer.on('mouseover', function() {layer.openPopup();});                           layer.on('mouseout', function() {layer.closePopup();});                       }                      }); towns.addTo(map); var baselayers = {     'Shaded Relief': baserelief,     'National Map': basetopo }; var overlays = { 'The Trail': thetrail, 'Towns': towns }; L.control.layers(baselayers, overlays).addTo(map); // Add scalebar var scale = L.control.scale() scale.addTo(map) // Add attribution map.attributionControl.addAttribution('National Map Topo'); map.attributionControl.addAttribution('OpenTopoMap');

Abaixo está o HTML que configura o mapa e inclui o arquivo JavaScript (leaflet_day5.js), que contém o código descrito acima, criado para deixar o código mais legível.

<!DOCTYPE html> <head>   <link rel="stylesheet" href="https://unpkg.com/leaflet@1.4.0/dist/leaflet.css"   integrity="sha512-puBpdR0798OZvTTbP4A8Ix/l+A4dHDD0DGqYW6RQ+9jxkRFclaxxQb/SJAWZfWAkuyeQUytO7+7N4QKrDh+drA=="   crossorigin=""/>     <script src="https://unpkg.com/leaflet@1.4.0/dist/leaflet.js"   integrity="sha512-QVftwZFqvtRNi0ZyCtsznlKSWOStnDORoefr1enyq5mVL4tmKB3S/EnC3rRJcxCPavG10IcrVGSmPh6Qw5lwrg=="   crossorigin=""></script>   <script src="rails.geojson"></script>   <script src="trail_stops.geojson"></script> <style>     #mapDIV{         height: 700px;         width: 700px;         border: solid 1px black;     } </style> </head> <body>     <div id='mapDIV'></div>     <script src="leaflet_day5.js"></script> </body> </html>

Se você quiser baixar o código completo (HTML, JS, JSON) basta clicar aqui!

Categories: OSGeo Planet

Paul Ramsey: GeoJSON Features from PostGIS

OSGeo Planet - Wed, 2019-03-27 13:00

Every once in a while, someone comes to me and says:

Sure, it’s handy to use ST_AsGeoJSON to convert a geometry into a JSON equivalent, but all the web clients out there like to receive full GeoJSON Features and I end up writing boilerplate to convert database rows into GeoJSON. Also, the only solution I can find on the web is scary and complex. Why don’t you have a row_to_geojson function?

And the answer (still) is that working with rows is fiddly and I don’t really feel like it.

However! It turns out that, with the tools for JSON manipulation already in PostgreSQL and a little scripting it’s possible to make a passable function to do the work.

Start with a simple table.

DROP TABLE IF EXISTS mytable; CREATE TABLE mytable ( pk SERIAL PRIMARY KEY, name TEXT, size DOUBLE PRECISION, geom GEOMETRY ); INSERT INTO mytable (name, size, geom) VALUES ('Peter', 1.0, 'POINT(2 34)'), ('Paul', 2.0, 'POINT(5 67)');

You can convert any row into a JSON structure using the to_jsonb() function.

SELECT to_jsonb(mytable.*) FROM mytable; {"pk": 1, "geom": "010100000000000000000000400000000000004140", "name": "Peter", "size": 1} {"pk": 2, "geom": "010100000000000000000014400000000000C05040", "name": "Paul", "size": 2}

That’s actually all the information we need to create a GeoJSON feature, it just needs to be re-arranged. So let’s make a little utility function to re-arrange it.

CREATE OR REPLACE FUNCTION rowjsonb_to_geojson( rowjsonb JSONB, geom_column TEXT DEFAULT 'geom') RETURNS TEXT AS $$ DECLARE json_props jsonb; json_geom jsonb; json_type jsonb; BEGIN IF NOT rowjsonb ? geom_column THEN RAISE EXCEPTION 'geometry column ''%'' is missing', geom_column; END IF; json_geom := ST_AsGeoJSON((rowjsonb ->> geom_column)::geometry)::jsonb; json_geom := jsonb_build_object('geometry', json_geom); json_props := jsonb_build_object('properties', rowjsonb - geom_column); json_type := jsonb_build_object('type', 'Feature'); return (json_type || json_geom || json_props)::text; END; $$ LANGUAGE 'plpgsql' IMMUTABLE STRICT;

Voila! Now we can turn any relation into a proper GeoJSON “Feature” with just one(ish) function call.

SELECT rowjsonb_to_geojson(to_jsonb(mytable.*)) FROM mytable; {"type": "Feature", "geometry": {"type": "Point", "coordinates": [2, 34]}, "properties": {"pk": 1, "name": "Peter", "size": 1}} {"type": "Feature", "geometry": {"type": "Point", "coordinates": [5, 67]}, "properties": {"pk": 2, "name": "Paul", "size": 2}} Postscript

You might be wondering why I made my function take in a jsonb input instead of a record, for a perfect row_to_geojson analogue to row_to_json. The answer is, the PL/PgSQL planner caches types, including the materialized types of the record parameter, on the first evaluation, which makes it impossible to use the same function for multiple tables. This is “too bad (tm)” but fortunately it is an easy workaround to just change the input to jsonb using to_json() before calling our function.

Categories: OSGeo Planet

Stefano Costa: ArcheoFOSS: un saluto e buon viaggio

OSGeo Planet - Wed, 2019-03-27 07:44

Un mese fa, pochi giorni dopo essere rientrato dall’incontro FOSS4G-IT di Padova, ho mandato una email a un gruppetto di 8 persone che, presenti fisicamente o meno a Padova, hanno seguito da vicino le vicende di ArcheoFOSS negli ultimi tempi. Con questa email ho salutato ArcheoFOSS e adesso, sedimentati un po’ i pensieri, pubblico questo articolo con un augurio di buon viaggio.

L’edizione 2019 di ArcheoFOSS è stata ottima, sia dal punto di vista degli interventi sia come partecipazione numerica ai workshop. Ha funzionato abbastanza l’integrazione con gli amici di FOSS4G-IT, nonostante una certa ghettizzazione (aula lontana, niente streaming, niente computer pronto) di cui è rimasta traccia anche nei comunicati stampa conclusivi e nelle discussioni organizzative di coda. Non ho comunque potuto fare a meno di notare negli interventi un certo distacco tra chi presenta in modo occasionale e chi ha seguito negli anni un percorso collettivo di crescita, tra chi ha “usato l’open” e chi costruisce strumenti condivisi, conoscenza trasversale.

Gli incontri però non si chiudono con la fine dell’ultima presentazione in sala. Come abbiamo detto a Padova, con grande sforzo mio, di Saverio Giulio Malatesta e soprattutto di Piergiovanna Grossi sono quasi ultimati gli atti del 2018 che saranno pubblicati in un supplemento di Archeologia e Calcolatori grazie alla disponibilità di Paola Moscati e alla volontà di tanti autori di autotassarsi per contribuire alla pubblicazione del volume.

Ma veniamo al dunque.

Condivido una decisione che ho maturato serenamente negli ultimi 6-12 mesi, cioè quella di fare un passo indietro e “uscire” da ArcheoFOSS per la prima volta dal lontano 2006 a Grosseto (quando non avevamo ancora questo nome, ma uno molto più lungo). Questo non perché io non condivida lo spirito che anima questo gruppo di persone, che anzi credo di continuare a coltivare e diffondere. Né perché io sia “arrivato” a occupare una posizione in soprintendenza dove non ho più bisogno di ArcheoFOSS come biglietto da visita (non che sia mai successo…).

Vorrei metaforicamente uscire dalla porta dopo aver salutato, a differenza di tante altre persone che hanno fatto anche molto (penso a chi ha organizzato il workshop nelle edizioni 2006, 2010, 2011, 2012, 2013) senza poi avvisare in modo chiaro di non essere più a bordo.

Semplicemente, se così posso dire, mi manca il tempo per fare con entusiasmo e passione le cose indispensabili (organizzare il workshop, pubblicare gli atti, ma anche tenere il tutto vivo per 12 mesi l’anno, gestire il sito, il forum) e non ho le energie per farle nemmeno in modo approssimativo. Non è l’unico impegno di questo genere che ho deciso di chiudere (a breve, per gli affezionati, altri aggiornamenti).

ArcheoFOSS mi piace sempre moltissimo, anche se mi sembrano sempre più flebili l’anima quantitativa, quella metodologica, quella di rivendicazione che proprio nel 2006 erano un ingrediente fondamentale. Senza quelle, io penso che non si vada lontano. Penso anche che ArcheoFOSS troverebbe uno spazio più coerente a rapporto con realtà e incontri archeologici invece che recitando la parte “archeo” di un altro contenitore legato al software libero (perché così manca un confronto critico, una valutazione sulla bontà archeologica dei lavori presentati, e soprattutto la possibilità di incidere direttamente sulla pratica del settore). Questo ovviamente vale nella situazione attuale, in cui non ci sono risorse per organizzare un incontro autonomo.

Passando alle questioni pratiche, come avevo anticipato, ho chiuso il forum Discorsi su ArcheoFOSS lasciando in sola lettura i contenuti pubblici. Questo ha suscitato una “lettera aperta” da parte di Emanuel Demetrescu, che dopo averla condivisa con me ha voluto pubblicarla anche su Facebook, non so con quale riscontro.

Inoltre ho deciso che non farò parte del comitato scientifico per prossimi incontri.

Mi piacerebbe moltissimo partecipare in futuro ad ArcheoFOSS presentando quello che credo di continuare a fare (software libero, banche dati, formati aperti). Quando è iniziata questa avventura avevo 23 anni e adesso ne ho quasi 36: non esagero dicendo che ho imparato moltissimo dalle tante persone che ho avuto la fortuna di incontrare in questi anni, e ne sono pubblicamente e dichiaratamente riconoscente. Ci incontreremo ancora.

Nel frattempo, vi auguro buon viaggio.

Categories: OSGeo Planet
Syndicate content