When it comes to webmapping there are thousands of possible markers you can choose from but when it comes to markers depending on the data, which is inside the shapefile, possibilities are more limited. In leaflet you can define different icons according to the attributes of your data by defining the icon url in an attribute. Let me show you, how to use the data in each feature to create a custom icon like a piechart marker using R.

Piecharts as markers in QGIS. Cool, huh?

For this you will need R installed. Especially if you’re new to R I highly recommend RStudio. It has a great GUI and it’s platform independent.

Getting data into R

To enable R reading shapefiles we will need to load additional libraries into R. Therefore we are using the gdal bindings to R:

setwd("~/r_pie")# set the working directory with your files inside:
install.packages("sp") #will be needed to load rgdal
library("sp")
install.packages("rgdal") #here's rgdal
library("rgdal") #enable it for your workflow

Now let’s have look at the Shapefile itself which will be exported:

ogrListLayers("places.shp")
shape<-readOGR("places.shp", layer="places") #will load the shapefile to your dataset.
data<-shape@data
view(data)

Create piecharts and store everything

As we are now having the data stored in an extra variable we can do “crazy stuff” and having a simple loop over the data and create a piechart for every entry according to the variables in columns 9 to 13:

for (i in 1:dim(data)[1]){ #will use every line of the attribute table
  svg(paste(,"/plots",i,".svg", sep = ""), bg="transparent") #creates an svg file were we will "print into"
  pie(t(data[i,9:13]), init.angle = 90, col=c("red","blue","yellow", "green", "grey"), labels=NA) #this will create the pie chart itself with five collors as we have five columns
  dev.off()
}

What we need to do now? Change the attribute table an add a new column with the pathes we just used to store the svgs.

for (i in 1:dim(data)[1]){
  shape$icon_exp[i] <- paste(getwd(),"/plots",i,".svg", sep = "") #will populate a new attribute with the paths
}
writeOGR(shape, "places", driver="ESRI Shapefile", layer="places") 

Now load it into QGIS and export it via QGIS2leaf… The icons are a bit small, but you can easily change this by looking at the code in line 47:

iconSize:     [24, 24],
iconAnchor:   [12, 12]
popupAnchor:  [0, -14] 

Increase values as you like and it could look like this:

piecharts as markers

The post Create custom markers with R for your webmap appeared first on Digital Geography.

I’ve been experimenting with very short QGIS tips on YouTube, and if you like them I’ll continue to create them. They may or may not reveal something extraordinary, and if you have an idea of something worth creating a short video on, leave a comment or send me an e-mail, tweet, or whatever.

The clips will mostly not be more than 2 – 3 minutes long, even if I will create longer clips as well, but those will not be called “quick tips”.

You can check out the first ones in a playlist of mine: Link to YouTube

As an example I’ve also included one of the clips here below.

My interests vary and focus can quickly turn from one area to another. Right now I’ve found these short videos interesting and I will most likely create some more. If you encourage me there may be a lot more, otherwise my focus will likely shift towards something new in a not so distant future. But for now I think this is fun!

The post Quick QGIS Tips on YouTube appeared first on Digital Geography.

Trash is Trash

This seems a bit like a minor change but the old symbol to remove entries from your attribute table was not really convenient and might have led to several “lost data problems” in former times. QGIS would like to minify misconception of this. It£s clear now how to throw away your information:

Postgis can perform even better

Former use of PostGIS in QGIS was based somehow on the shp2pgsql command. With QGIS 2.8 the Suisse army knife of geotools ogr2ogr will take it’s place and provide better performance when it comes to feeding your postgis database with features. Here is the result of a test from Faunalia GIS :

Adding “-D” for shp2pgsql or “–config PG_USE_COPY YES” for ogr2ogr means a huge improvement is speed: ogr2ogr takes 0.8 seconds to process the small dataset [10mb] and 2.21 minutes the process the big dataset [1.3GB]. Shp2pgsql/psql take respectively 24 seconds and 1.56 minutes.

Heavy Rotation

You can rotate the whole map now in the main project window. That’s it:

Embedded Heat Map Style

The creation of heatmaps was always a part of an analysis and reuired the creation of raster files which were plotted over your points. In QGIS 2.8 you will have the point representation as a heat map as one of the style options. So no fancy calculation in the background needed. But be carefull as the visiual conception of such a heat map is always intense and might imply conclusions you don’t wanted with your map. But still it’s an elegant way to indicate places of high informatioon concentration…:

The post QGIS 2.8: A Preview appeared first on Digital Geography.

Yesterday I received the mail from Anita Graser’s blog about the best 10 articles on QGIS planet. Therefore I decided to have a look on our own top ten list of most read articles this year. And I have to admit: It’s not the open source world who leads this list…The whole list only shows English articles disregarding our job page which is the most read page on this blog (sidenote: you can post your job offer for free )

#10 – #5

I was surprised to see an install-something article on this list but with the release of QGIS 2.0 QGIS probably hit the road big time and there were many people who would like to try it out on their Ubuntu (#10). Two out of five articles covered the topics of D3. A great technology for webmapping and data visualisation created by Mike Bostock. Unfortunately Ralf seems to be very busy with other stuff and there were no newer tutorials on D3 on our page recently but maybe you will find some news on his blog (If you know D3 and want to write about, give us a “quick call”).

D3 line simplification tool

The other two articles covered some ArcGIS content. One of it was a widely discussed one about the performance of ArcGIS Server were I just translated an old article from 2012 which itself cited a paper. It was going crazy with this one. But the other one was a quite normal one on how to make a topographic map by our Russian author Andrew Klikunov. Unfortunately this was a one-hit wonder…

DEM classified with contours

3D visualisations with NVIZ and a description on how to create a leaflet based webmap with your data in QGIS had also an impact on our number of visitors.

#4

Let’s enter the upper part of the list. Number four is QGIS specific and described the process of joining data with vector data/features. This a somewhat day-to-day problem as spatial data is often just a hull for meaningful data and the attributes needs to be added and enhanced to create the map for the spatial objects you would like to show. In QGIS it’s quite easy but yet I think it’s not the everyday business especially  for non GIS-ers like journalists or teachers.

local areas in Germany imported in QGIS

#3

Once again: D3… This was our first article on D3 and it simply described the first steps in using D3 as a JavaScript framework. It had nothing to do with webmapping. But D3 means “Data Driven Documents” and so does this tutorial: show stuff you can do with any element:

D3 with some funky example

#2

The rating for this one so far is only 3 out of five stars but it seems to gain some attraction to our readers: How to georeference a map in QGIS. It is also an everyday task for persons working with GIS and it is not always as easy as in this case. Searching for ground control points, determining the correct projection of the image and using the best resampling technique isn’t the most easy task in QGIS. This article show you the steps from determining the projection of the scanned map, selecting the correct CRS in QGIS and using coordinate crosses from the map for a quick and dirty georeferenciation.

#1

Once again: Georeferenciation. But in this case we are using ArcGIS 10. Same steps like in QGIS: scanned image, coordinate crosses from the map choosing good resampling of pixel values and exporting the whole thing as a georeferenced image for ongoing analysis or publishing.

The Numbers

PageViews 2014

The post Posts 2014: our Top Ten List appeared first on Digital Geography.

Often the usage of GIS never touches the world of programming and I think a lot of GIS users today feel fine with using simple tools and try to avoid tools like Python for their daily work. Despite any prejudices regarding programming, Python can be a big help in your basic tasks and is a very easy scripting language to learn. So let us check out Python in ArcGIS and QGIS with a buffer analysis as an easy example. Nevertheless I recommend to take some coding lessons in Python using CodeAcademy.

Accessing Python in GIS

Access in QGIS

For QGIS simply go to Plugins –> Python Console and you will see a nice console in your QGIS working window. The console shouldn’t be the preferred way to work with Python. This should be a script you can write and were you can execute commands from:

QGIS: Python console with the script function tool marked in red.

The Python console itself has an input line in the main lower part and an output window in the upper main part. As QGIS provides an enhanced integration of Python the script editor will help you with a code-completion functionality like ArcGIS which will enables you to easily find possible functions and methods for your current “object”. Let’s make a simple first statement by writing

canvas = iface.mapCanvas()

After writing this in the input line you will have it already executed by hitting the Enter button. If you’re using the script editor you can store the script and run everything or you just select this line and use the right mouse button to select just to run this one line as it is selected. Now you have all your objects from your working canvas available in the variable called canvas. Of course the canvas has much more then just layers but let’s stick to current active one by using another command to interfere with your data in the project:

layer= iface.activelayer()

As you might expect all the layers are now stored in your variable allLayers.

Access in ArcGIS

The first real class used for Python in QGIS was called iface which is part of qgis.utils. In ArcGIS we have a similar situation as most of the functionality is part of arcpy. But let’s first check how to get there. You open the Python console in ArcGIS/ArcMAP via the main dialog Geoprocessing–>Python:

Opening the Python console in ArcGIS

Unfortunateley ArcGIS 10.3 does not provide a script editor like QGIS so you need to copy paste your syntax to another application, text editor or Python IDE. Also the ArcGIS Pzthon console show syntax suggestion and a help section to explain the syntax for a given arcpy command/class/function:

arcpy syntax suggestion for the describe function

arcpy help section

Of course we can get some information about our layers. Therefore we use the Describe function:

arcpy.Describe("places_few_2")

import pythonaddins
mxd = arcpy.mapping.MapDocument('current')
layer = pythonaddins.GetSelectedTOCLayerOrDataFrame()
layer.name

But it seems like the integration of Python into ArcGIS is orientated more towards ArcGIS whereas QGIS tends to utilize Python for QGIS workflows and therefore tries to make QGIS available for Python…

Using Python in GIS

As we have now enabled Python in ArcGIS or QGIS let’s create some buffers around some features.

QGIS itself has a great toolbox where you can access all the commands for raster and feature based analysis from a central hub. Those commands are also available in the Python console after importing the library of processing algorithms:

import processing
processing.alglist()

The second command will show you a list of all algorithms and commands available with QGIS (it’s more then 600…) which are grouped into algorithm-providers like GRASS, SAGA, R or of course QGIS. As we see from this list we will find a algorithm called qgis:fixeddistancebuffer which is the normal distance buffer on features with a given distance.

processing.alghelp('qgis:fixeddistancebuffer')

The above line whill show you the help section and some usage info for this function:

python console usage info for function buffer

So we can easily run this tool with this line in the python console:

processing.runalg("qgis:fixeddistancebuffer","layer-name-you-need",0.1,10,False,"Path-to-file-to-store")

If you’re unsure about some parameters in the the algorithm you can check with with the function (our algroithm has none):

processing.algoptions('qgis:fixeddistancebuffer')

In our example we can determine the layer name automatically by using layer.name() instead of “layer-name-you-need”. The next parameter defines the distance in units of the input feature (in our case it was degrees) and the “10” is the nmber of segments to use for a quarter of a circle (more is better but uses more vertices on the resulting polygon). In the end my python call for a selected layer would be:

import processing
layer = iface.activeLayer()
processing.runalg("qgis:fixeddistancebuffer",layer.name(),0.1,10,False,"C:/Users/ricckli/Desktop/buffer_test.shp")
vlayer = QgsVectorLayer('C:/Users/ricckli/Desktop/buffer_test.shp', "buffer", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(vlayer)

As in the first command (where we accessed all layers in the canvas) you can also iterate over all your layers. But this is another post…

The buffer function is listed as an Analysis function in the help section of ArcGIS. The content of the help is very convenient and you’ll probably find most of the stuff you need as well as usage suggestions and examples and many more:

ArcGIS help section for the buffer function

As we see the syntax need at least three parameters (you’ll notice optional parameters as they are marked):

• in_features: The name or the path of the features to create a buffer for
• out_feature_class: pick a name or a path for the shapefile
• buffer_distance_or_field: should be a field name or a value with a given unit like Meters or Feet or Decimal Degrees

arcpy.Buffer_analysis("places_few_2","C:/Users/ricckli/Desktop/buffer_test_arcpy.shp", "0.1 DecimalDegrees")

But be warned. The result seems to be different when defining a shapefile as output instead of a simple layer like in this code line:

arcpy.Buffer_analysis("places_few_2","buffer_test_arcpy", "0.1 DecimalDegrees")

In both cases the result will be added to your table of content and you can see it right away.

Ressources

QGIS

ArcGIS

The post Python in QGIS and ArcGIS: A Small Example appeared first on Digital Geography.

When working with raster datasets, it is hard to keep an overview of the raster files in use and their coverage. Most raster data providers may keep metadata in the filename itself, like path, row and a timestamp. But for more convenience, it is possible to create an index of your raster maps. This article will show you, how to accomplish this in QGIS or with the Terminal.

First of all, we need some raster layers. GDAL is capable of reading most of the common used remote sensing formats, so this should be no showstopper. Just load your data into QGIS. In the following screenshot, you can see two digital elevation model scenes.

Two DEM scenes loaded into QGIS

In the next step, go to “Raster” > “Miscellaneous” > “Tile Index”.

Opening GDALs Tile Index function.

In the Tile Index menu, you can now choose an input directory and eventually subdirectories for GDAL to look for raster datasets. If you have your datasets across different folder on your filesystem, you can even index each of them sequentially by running the programm several times and choosing the same index file. If the index file already exists, GDAL appends the new data instead of overwriting the old ones. Additionally, you can provide a name for the attribute holding the filesystem location in the shapefile to be created.

Create Tile Index

As soon as you created the Tile Index and loaded it into your project, you can see a polygon for each of the raster datasets that you indexed. For better visualization and overview, go to the layers style settings, disable the filling, and choose a contrasting color and increased width for the border.

A tile index layer in QGIS. The red lines mark the border of the raster datasets.

To get the most out of your newly created tile index, you can even set up labeling for the index polyons. For this purpose, go to the labeling settings of your index layer, activate labeling and choose “location” as labeling attribute. Additionally, I recommend applying a small buffer of e.g. white around the labels, for better readability. The result should look like this:

Finished Tile Index in QGIS. Red lines mark the dataset borders, labels indicate dataset filename and path on the filesystem.

Did you know that GDAL also offers a command line tool for this? If you like scripting your workflows or generally prefer the terminal over a GUI, you can create a Tile Index like this:

gdaltindex index.shp input_directory/*.tif

The post Create A Raster Layer Index With QGIS And GDAL appeared first on Digital Geography.

Creating a Line with Python

point_layer = qgis.utils.iface.mapCanvas().currentLayer()
point_layer_dp=point_layer.dataProvider() #we need this to extract the coordinate system
source_crs=point_layer_dp.crs() #so lets extract it
features = point_layer.getFeatures() #now determine each feature
vertexes = [] #here we will store the coordinates as I like arrays
for f in features:
	geom = f.geometry() #access to the geometry of a point
	point = geom.asPoint() #here we extract the coordinates as one point
	vertexes.append(point) #and store it in the array vertexes by appending the vertexes array

layer = QgsVectorLayer('LineString', 'connecting line', "memory") #this will create an in memory layer which is not stored on a HDD
layer.setCrs(source_crs) #we set the CRS to the one provided by the point layer
pr = layer.dataProvider() #once again we need the provider (should be shapefile/ESRI)
line = QgsFeature() #let's create an empty Feature which will be the box to put our segment(s) into
start_point = vertexes[0] #this is the start of the first segment
end_point = vertexes[1] #and the end of course
seg = [start_point, end_point] #so this is our whole segment
line.setGeometry(QgsGeometry.fromPolyline(seg)) #we will set the geometry of our so far empty feature from this array of points
pr.addFeatures([line]) #and add it to the layer
layer.updateExtents() #update it
QgsMapLayerRegistry.instance().addMapLayer(layer) #and put it on the map. Store it manually if you need to.

connection with line from one point to another

Custom CRS for a Real Great Circle/Arc

crs_new = QgsCoordinateReferenceSystem()
crs_new.createFromProj4("+proj=aeqd +lat_0=" + str(vertexes[0][1])+ " +lon_0=" + str(vertexes[0][0]) +" +x_0=0 +y_0=0 +a=6371000 +b=6371000 +units=m +no_defs") #which uses the Lat and Lon values of our starting point

crs_src = QgsCoordinateReferenceSystem(source_crs)
xform = QgsCoordinateTransform(crs_src, crs_new)
start_point_new = QgsPoint(0,0)
end_point_new = xform.transform(QgsPoint(vertexes[1]))
seg_new = [start_point_new, end_point_new]

crs_old = qgis.utils.iface.mapCanvas().mapRenderer().destinationCrs() #just store it for later 
qgis.utils.iface.mapCanvas().mapRenderer().setDestinationCrs(crs_new) #change current crs to fit with the desired one.
layer_new = QgsVectorLayer('LineString', 'line_new CRS', "memory") #once more...
layer_new.setCrs(crs_new) #and again
pr_new = layer_new.dataProvider() #yap, 2nd time
line_new = QgsFeature() #and...
line_new.setGeometry(QgsGeometry.fromPolyline(seg_new)) #and...
pr_new.addFeatures([line_new]) #okay now we get serious
layer_new.updateExtents() #whoha
QgsMapLayerRegistry.instance().addMapLayer(layer_new) #now we have a line with new coordinates
import processing #we need this library to use the QGIS processing tools
dens_layer = processing.runalg("qgis:densifygeometriesgivenaninterval",layer_new,'100000',None) #which densifies the line by new vertexes each 100 km
dens_layer=QgsVectorLayer(dens_layer.get('OUTPUT'), "densified_layer", "ogr") #and we would like to store the result in a new layer
QgsMapLayerRegistry.instance().addMapLayer(dens_layer) #which we put on the map
QgsMapLayerRegistry.instance().removeMapLayer(layer_new.id()) #we don't need the old one anymore
qgis.utils.iface.mapCanvas().mapRenderer().setDestinationCrs(crs_old) #and change back the CRS to the old one.

what a nice curve

Difficulties

crossing the date line…

crs_4326 = QgsCoordinateReferenceSystem(4326)
xform2 = QgsCoordinateTransform(crs_new, crs_4326)
layer_4326 = QgsVectorLayer('LineString', 'line_4326', "memory")
layer_4326.setCrs(crs_4326)
pr_4326 = layer_4326.dataProvider()
outFeat = QgsFeature()
for f in dens_layer.getFeatures():
	geom = f.geometry()
	geom.transform(xform2)
	outFeat.setGeometry(geom)
	outFeat.setAttributes(f.attributes())

pr_4326.addFeatures([outFeat])
layer_4326.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(layer_4326)
vertexes_merge = []
for f in layer_4326.getFeatures():
	line = f.geometry()
	for i in line.asPolyline():
		vertexes_merge.append(QgsPoint(i))

import math
breaks = []
for i in range(0,len(vertexes_merge)-1):
	if math.sqrt((vertexes_merge[i][0]-vertexes_merge[i+1][0])**2) > 2:
		breaks.append(i)

breaks.append(len(vertexes_merge)-1)
layer_merge = QgsVectorLayer('LineString', 'line', "memory")
layer_merge.setCrs(crs_4326)
pr_merge = layer_merge.dataProvider()
start = 0
for index in range(0,len(breaks)):
	end = breaks[index]
	line_merge = QgsFeature()
	line_merge.setGeometry(QgsGeometry.fromPolyline(vertexes_merge[start:end]))
	start = breaks[index] + 1
	pr_merge.addFeatures([line_merge])
	layer_merge.updateExtents()

QgsMapLayerRegistry.instance().addMapLayer(layer_merge)

splitted line to avoid bad rendering

The post Creating ARCs in QGIS: The Python Way appeared first on Digital Geography.

release plan for QGIS

• >1000 issues flagged by static analysis tools fixed
• new code commits and pull requests are now automatically tests against our testing framework.
• more responsive browser
• support for contextual WMS legend graphics
• custom prefixes for joins
• creation of memory layers in core
• field calc bar in attribute table
• dxf export improvements
• advanced digitizing tools
• improved snapping
• better simplify tool
• Qt5 support
• Bookmark import/export
• composer gui improvements
• grid improvements
• raster image fill type
• live heatmap renderer
• multiple styles per layer
• rotation of map canvas
• improved date defined symbology UI
• new algorithms in processing:
  • Regular points algorithm
  • Symetrical difference algorithm
  • Vector split algorithm
  • Vector grid algorithm
  • Hypsometric curves calculation algorithm
  • Split lines with lines
• expressions extentable with custom functions
• comments in expressions
• QGIS server improvements: better caching, layer style support, value relations, DescribeLayer, python plugins

• Measure dialog improvements
• Custom prefix for joins
• Python console improvements
• Raster image fill type (tiled images in polygons… WHOOHA!)

Download page with old QGIS 2.6.1… will be updated soon!

OSGEO4W setup installer with 2.8

The post Short Announcement: QGIS 2.8 Wien released appeared first on Digital Geography.

The Data

The whole process starts with the values for seven point location which could be potential weather stations or simple observation points. We have values for direction and speed of the wind for a single event. If you only have horizontal and vertical speeds (which seem to be a common thing for wind data) you can convert it to speed and directions using this source.

You can simply convert it into a shapefile by adding it as a csv layer and save it as a ESRI shapefile (download it here). After this comes the more less hardest task of interpolation of values for the vector field. As we are concentrated on the visuals instead the math behind interpolation I simply used the interpolation plugin. Ujaval has a nice tutorial on the usage of this plugin. I ended up with using a standard IDW (Inverse Distance Weighted) interpolation for both the speed and directional values. Of course this is over simplified and you can get your hands dirty with this. If you want to make it right you might read these articles:

• Luo, W., Taylor, M. C. and Parker, S. R. (2008), A comparison of spatial interpolation methods to estimate continuous wind speed surfaces using irregularly distributed data from England and Wales. Int. J. Climatol., 28: 947–959. doi: 10.1002/joc.1583 | PDF

• Gumiaux, C., Gapais, D., & Brun, J. P. (2003). Geostatistics applied to best-fit interpolation of orientation data. Tectonophysics, 376(3), 241-259. | PDF

Wind speed interpolation raster in QGIS

Regular spaced points

The Visualisation

Arrow as symbol

Marker dialog

Vector field for wind data

The post How to create a wind map in QGIS appeared first on Digital Geography.

To map excel data onto a print- or webmap is one of the most needed and chosen data preparations. Companies and scientists are often highly interested in located table datasets on maps. In this how to I’ll show you, that this job could be done with free and open source software like QGIS.

What do you need?

• a table with some data columns (one city- and street-row is necessary)
• excel or open office or libre office or something else
• QGIS (free open source GIS-software)
• 10 minutes

1. georeferencing your point data

In this step we create geographic coordinates (decimal x- and y-values) for our address-row of the input table dataset.

First we need to import our datatable into QGIS. I’ll use this test dataset.

Now follow these steps:
a. Save your excel datasheet as .csv (comma separated values) like this:

data.csv

city,street,customer,product,output$,buydate
NewYork,355 W 16th St,Peter Pan,shoes,50000,01.02.88
London,Whitehall Place,David Hasselhoff,guitar,10000,02.10.85
Berlin,Friedrichstraße 1,Michael Jackson,car,3200,02.10.80

b. Open QGIS

c. Install the mmqgis Plugin

d. Manage and Install Plugins

e. Install mmqgis

f. Geocode your table with mmqgis

g. Choose mmqgis’ geocoding feature

h. Set fields and define output directory

i. your geocoded table informations are now ready to be mapped

3. show it as map layer

For showing your new map features on top of a map you only have to import a webmap baselayer. The plugin “Open layer plugin” is very helpful in this case. Just install it in the extension manager like mmqgis Plugin described at point 3. After installing this plugin press “Web – Open Layers Plugin – MapQuest – MapQuest OSM” and gain the following map result.

Installation of OpenLayers plugin

Mapping result

4. export your map data as a print map

Now open the QGIS Map Compose, click on “Add a new map” and draw a rectangle on the white canvas. After that you’re ready to export the result as raster- or vector-pdf file.

Setting the map dimension on canvas

5. export your map data as a webmap

If you’re interested in creating a webmap, use our QGIS2leaf Plugin for an easy webmap creation. Install it from extension manager (“QGIS2leaf”). Start the plugin, “get layers” and export your first data driven web map with your own company data.

Export menu of QGIS2leaf

Your webmap result

Popups on the webmap

Help

You need professional help in creating proper and modern webmaps, which shows your business data – get in touch with us!

The post Map excel data for free – 5 steps to your own print- and webmap appeared first on Digital Geography.

The Plugin SCP

The Semi-Automatic Classification Plugin (SCP) is a free open source plugin for QGIS that allows for the semi-automatic classification (also supervised classification) of remote sensing images. Also, it provides several tools for the pre processing of images, the post processing of classifications, and the raster calculation.

Landsat and QGIS

The main plugin window: SCP

1. SCP: Classification – Here you can do your fancy classification steps and also download of data.
2. SCP: ROI creation – Here you define your Region of Interest.

Landsat 8 downloader with filled corner coordinates

Landsat preview in QGIS

folder with downloaded images

Summary

Further Information

The post Landsat in Love with QGIS: the newest coup from Luca appeared first on Digital Geography.

QGIS2leaf – Current Usage

• Berkeley University
• user ZROSS
• Italian city planner
• freewheelmaps
• LA Times
• docsScan.net
• …

QGIS2leaf: Capabilities

• embed of WMS/WFS layers
• legend creation for your webmap
• cluster functionality for points
• address search in your webmap
• labels on hover
• raster export (as png with opacity!!!) and opacity control
• auto locates on your device
• customizable and multiple basemap selection
• save and restore your export settings
• smaller geoJSON outputs

 QGIS2leaf: the Future

The post Happy B-Day QGIS2leaf appeared first on Digital Geography.

The relocator plugin

QgsVectorFileWriter.writeAsVectorFormat(layer,path,encoding,crs,type)

shutil.copyfile(src_path, dst_path)

for rank in root.iter('rank'):
	new_rank = int(rank.text) + 1
	rank.text = str(new_rank)
	rank.set('updated', 'yes')
tree.write('output.xml')

changing xml documents and removing paths

The relocator plugin in qgis plugin installer

The post share your qgis project: the relocator plugin appeared first on Digital Geography.

The First Insights: Tweets in QGIS

curl -k -d @locations.txt https://stream.twitter.com/1/statuses/filter.json -uuser:password > tweets.json

The one million tweet map

Tweets in QGIS- Prerequisites

• access token
• access token secret
• consumer key
• consumer key secret

Gathering Tweets

import tweepy
access_token = "231016902-6coaqCFPNCpQoLFxCKlEtSTqoSROgykF7BbsMj88"
access_token_secret = "R3p1kMK3o8V9gvtd4hiro4xU9wrRDq9mhZly5EfsboB1R"
consumer_key = "RiaBnLlTmu0e4rxKwEjF0hC1A"
consumer_secret = "lAclBkGTjeUa9RwzI0iIZYDijKTUkMjSxDy1opqd8C4ebHCNup"
key = tweepy.OAuthHandler(consumer_key, consumer_secret)
key.set_access_token(access_token, access_token_secret)

# here come the tweepy part:

class stream2lib(tweepy.StreamListener):
output = {}
def __init__(self, api=None):
api = tweepy.API(key)
self.api = api or API()
self.n = 0 #we will start with zero tweets
self.m = 10 #let's stop with 10 tweets
def on_status(self, status):
#we will parse the interesting information into a nice format
self.output[status.id] = {
'tweet':status.text.encode('utf8'), #text could have non utf8 characters, so change this!
'user':status.user.screen_name.encode('utf8'), #user name should be utf8 conform as well
'geo':status.geo, #this is the point location of the device
'localization':status.user.location, #user location as part of the user profile (normally set fixed per user)
'time_zone':status.user.time_zone, #quite
'time':status.timestamp_ms} #the timestamp given in ms since 01.01.1970
#we will only care about tweets with geo
if self.output[status.id]['geo']!=None:
self.n = self.n+1 #we found a geotweet. but that's always true when calling the command with "locations=[-x,-y,x,y]" as below
if self.n < self.m:
return True
else:
return False
stream = tweepy.streaming.Stream(key, stream2lib()) #initiate the stream
stream.filter(locations=[-180,-90,180,90]) #filter the stream for tweets in this "box"
tweetdic = stream2lib().output #copy it in a variable
print tweetdic #just to be sure 

Adding Tweets as Points to QGIS

vl = QgsVectorLayer("Point", "temporary_twitter_results", "memory")
pr = vl.dataProvider()

# changes are only possible when editing the layer
vl.startEditing()

pr.addAttributes([QgsField("user_name", QVariant.String),QgsField("localization", QVariant.String), QgsField("tweet", QVariant.String), QgsField("time", QVariant.String)])

for tweet in tweetdic:
    if tweetdic[tweet]['geo'] != None:
        fet = QgsFeature() #it's a new feature
        fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(tweetdic[tweet]['geo']['coordinates'][1],tweetdic[tweet]['geo']['coordinates'][0] ))) #use the coordinates for point location
        tweettime = datetime.datetime.utcfromtimestamp(float(tweetdic[tweet]['time'][:-3] + "." + tweetdic[tweet]['time'][11:13])).strftime('%Y-%m-%d %H:%M:%S:%f') #parse the time to fit YYYY-MM-DD HH:MM:SS:MS
        fet.setAttributes([tweetdic[tweet]['user'],tweetdic[tweet]['localization'],tweetdic[tweet]['tweet'],tweettime]) #set attributes of current tweet at current location
        pr.addFeatures([fet]) #and add the feature to the layer.

# commit to stop editing the layer
vl.commitChanges()
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(vl)

10’000 tweets in 3min ;-)

twitter2qgis/geotweet for qgis: a plugin

A Warning

• Mapping the global Twitter heartbeat

• Geography of Twitter networks

• Typical Twitter user is a young woman with an iPhone

• An Exhaustive Study of Twitter Users Across the World

The post The Geography of Tweets: Reading Tweets with QGIS appeared first on Digital Geography.

Current Solutions

• pgrouting
• roadgraph plugin
• points to route

pgrouting

pgrouting example from Anita’s blog

roadgraph plugin

points to route

Routing using GoogleMaps API

• You need a periodic update of your network layer
• acquire a network layer
• prob. install a postgres DB

1. log in at the Google dev page.
2. Create a new project.
3. Choose “Enable an API”.
4. Browse for the API and activate the following APIs: Directions API
5. Click on Credentials.
6. Click Create new Key for a new public key.
7. Select “Server Key”.
8. Click Create.

sudo pip install googlemaps

pip install googlemaps

import googlemaps
from datetime import datetime
now = datetime.now()
gmaps = googlemaps.Client(key="put YOUR key here!")
directions_result = gmaps.directions("Dessau, Germany", "Berlin, Germany",mode="driving",departure_time=now)
point_str = str(directions_result[0]["overview_polyline"]["points"])

Importing the route into QGIS

u’mak{HixkiAf@_\\bBeIzDqHbQyXzBgOe@uKcG{]_EiJOmDkAoAcMuHiBcDi@aFl@kQpAuWOcRZmHO}@wAeGoU_NmIaGe@qAl@wCdBqIaDaAmFYcTcIeETmFkCaAmB[oC_ExAe[nJiT|BaPbB}Ft@cI~DmIfBiNx@sOj@iNWcL_CwMgGaNcGaUgEmA}FeCs\\EkQeA}G}GeMoEqJwBqJwDeHyDy_@\\aaAhD}`ArDcQvNmYrDgTKiOiJqe@mMcs@}Cqr@iDgM{LgRiEqN{@oMcAuaBaAeqBhEkbBzAqZrPatAxCuTpATpBbC_@lDqAH_SmOyr@yk@kUkX}Qqa@{Qie@cSyg@qN_[iKsNcWgSsImDiuAoe@s{Ase@cTmImUuRaSe\\qTkm@iVir@cJu\\cKol@eVytAcXygAg]}sAsR}f@}mActBif@on@gWy[{KmTmRql@uKu]c\\udAwG_N_JsLoMgNiJkOqHuVcGaa@iF}QgIcOa\\uZuIqNgVws@eJgX{MuXeOgRyS_O{~@sh@sf@cZwRaPq_@u`@a}@msAqQc\\{Mi\\eUug@eq@}fAyPwXoIyQiUmr@oc@gsAyJuSaTuYav@o~@epAg{AsaA{kAyPuUkPu`@yJ_f@eMa{@i^abCgJq]{GiP_Yob@ig@as@yL_XwJm_@iPkiAkIs]cKgW{SuZi|@_aAoRySyb@we@ef@_i@wQoQwQyJuQcEuUOoUdFmR`J}y@la@cI~C{NvCyWAyWqF{d@{KkqAwZ}JeE}FaI{Hi_@yfAsyHcCsa@r@iuCLck@f@mTzBiRhO}w@tHif@\\eNs@uR_F}VmFiVeAuO`AkhAl@qi@|Aco@tBs_@{AoN}GuO_dAkm@kUaNgY}Yan@up@}J_UmH_^w^kmBaFoO{ImOqGsGiNuGyJeAmNDiiAx@gKo@cHcDyF_G_J{P{MiRoGgDsFaAy_@PmSBkHiAac@mUqN_MyFgMeDoOcTevAeCiLgKgWy]mc@au@_{@qGwCcIw@_S`C}ZbEoLdCsE~EsEnIuFpE}G\\uVyDkNmDoIcJ}[oc@op@o}@odA{vAkw@ifAwcA_pAij@ys@_l@ax@i^kh@kBcJ]sOkAmKsB_EgC]}C`@kEwEsFwDuKeAk[gQ}HyBqByACcAMmEbDo@`Do@pD{@L}G}@{_@uAie@mCuaAeBao@n@gCHkHkBmHgIcyClAaEKsE{AiCi@gKiEccB{@_[NqRdBwA~CAYgJ{AuOa@uNnDkAIcBq@mWWsJ{@HkC`@wC^w@@[wEk@oM}A_b@cMs_@’

coord_chunks = [[]]
for char in point_str:
	value = ord(char) - 63
	split_after = not (value & 0x20)
	value &= 0x1F
	coord_chunks[-1].append(value)
	if split_after:
		coord_chunks.append([])

del coord_chunks[-1]
coords = []
for coord_chunk in coord_chunks:
	coord = 0
	for i, chunk in enumerate(coord_chunk):
		coord |= chunk << (i * 5)
	if coord & 0x1:
		coord = ~coord #invert
	coord >>= 1
	coord /= 100000.0
	coords.append(coord)

points = []
prev_x = 0
prev_y = 0
for i in xrange(0, len(coords) - 1, 2):
	if coords[i] == 0 and coords[i + 1] == 0:
		continue
	prev_x += coords[i + 1]
	prev_y += coords[i]
	points.append((round(prev_x, 6), round(prev_y, 6)))

print points

from PyQt4.QtCore import QVariant
layer = QgsVectorLayer('LineString', 'route', "memory") 
pr = layer.dataProvider() 
pr.addAttributes([QgsField("attribution", QVariant.String)])
layer.updateFields()
fet = QgsFeature() 
seg=[]
for i in range(0,len(points)): 
	seg.append(QgsPoint(points[i][0],points[i][1])) 

fet.setGeometry(QgsGeometry.fromPolyline(seg)) 
fet.setAttributes(["route provided by google maps api"])
pr.addFeatures([fet])
layer.updateExtents() #update it 
QgsMapLayerRegistry.instance().addMapLayer(layer)

route given by GoogleMaps API in QGIS

Limitations

The post Routing in QGIS … with Google appeared first on Digital Geography.

Prerequisites for Routing with OSM: Coordinates

pl=qgis.utils.iface.activeLayer() #for your activated point shapefile
iterator = pl.getFeatures()
for feature in iterator:
    geom = feature.geometry()
    print geom.asPoint()

Routing with and Import from OSM

Oedheim	9.256506	49.240011
Modautal	8.72083	49.7606

http://openls.geog.uni-heidelberg.de/testing2015/route?Start=9.256506,49.240011&End=8.72083,49.7606&Via=&lang=de&distunit=KM&routepref=Fastest&avoidAreas=&useTMC=false&noMotorways=false&noTollways=false&instructions=false

XML response from openrouteservice.org

import requests
from xml.etree import ElementTree
url="http://openls.geog.uni-heidelberg.de/testing2015/route?Start=9.256506,49.240011&End=8.72083,49.7606&Via=&lang=de&distunit=KM&routepref=Fastest&avoidAreas=&useTMC=false&noMotorways=false&noTollways=false&instructions=false"
response = requests.get(url)
xml = ElementTree.fromstring(response.content)

Children are nested, and we can access specific child nodes by index: root[0][1].text

from PyQt4.QtCore import QVariant
layer = QgsVectorLayer('LineString', 'route_OSM', "memory") 
pr = layer.dataProvider() 
pr.addAttributes([QgsField("attribution", QVariant.String)])
layer.updateFields()
fet = QgsFeature() 
seg=[]
for i in range(0,len(xml[1][0][1][0])): 
    seg.append(QgsPoint(float(str.split(xml[1][0][1][0][i].text)[0]),float(str.split(xml[1][0][1][0][i].text)[1]))) 

fet.setGeometry(QgsGeometry.fromPolyline(seg)) 
fet.setAttributes(["route provided by openrouteservice.org"])
pr.addFeatures([fet])
layer.updateExtents() #update it 
QgsMapLayerRegistry.instance().addMapLayer(layer)

Google vs. OSM routing

Description: Through the OpenLS interface requests can be generated to the appropriate services without further query limitations. The offered API’s are only valid for ‘ one ‘ year. In case you plan a long-term use of the interfaces within your projects or high volume or for commercial applications , please contact openrouteservice AT geog.uni-heidelberg.de

The post Routing in QGIS… with OSM appeared first on Digital Geography.

QGIS 2.10 “PISA”: changelog

QGIS 2.10 “PISA” Splash Screen

• New zonal statistics features: The old build-in function only served a limited number of stats. This is providing way more freedom of choice.
• Improved geometry rotation tool: it’s easier than ever to rotate vector data when digitizing. Especially for the guys in the field of line documentation (gas/oil/water/electricity) this might be helpful.
• Layers with joins can now be filtered: I have to admit that I hate joins. I love it all in one file. But with this nice function you can apply a filter on the attributes of the “master” file.
• Visualise and modify the graduated renderer using a histogram: A nice and convenient way of altering your colour scheme according to the visual distribution of data.
• Live layer effects for layers and symbol layers: If you want to create stunning maps, this is definitely for you.

• Jürgen Fischer (norBIT) – Germany
• Matthias Kuhn (OpenGIS) – Switzerland
• Marco Hugentobler (Sourcepole AG) – Switzerland
• Sandro Mani (Sourcepole AG) – Switzerland
• Vincent Mora (Oslandia) – France
• Nyall Dawson – Australia

A question on usage/ development

The post Attention: QGIS 2.10 is coming! appeared first on Digital Geography.

Geo-Tagged Photos

ArcGIS

QGIS

images as mouse over in QGIS

• Geotag and import photos (needs exiftools installed )
• photo2kmz
• Photo2Shape (needs exiftools installed )
• ???

The post Show your Photos in QGIS and ArcGIS: a small example appeared first on Digital Geography.

The free and open source gis QGIS started an user survey on its online webpage. The project needs your input to get the best necessary community information for prioritising future adjustments and developments.

I use Qgis nearly every day and it’s astonishing how active the qgis community is. Short release cycles and a broad world of plugins makes qgis really interesting for many companies and students worldwide.

See what the QGIS survey asks and which top answers are.

As a QGIS user, I consider myself a…

Regular user 48.7 %

I use QGIS

Several times a week 38.7 %

How well does QGIS meet your needs as a general purpose GIS?

QGIS allows me to carry out most of my critical tasks, occasionally I need to use other software 65.2 %

What domain / industry do you work in?

private consulting company 34.5 %

Approximately how many people in your organisation use QGIS?

several answers

Which version of QGIS do you most regularly use?

NON LTR release 40.1 %

Which version of QGIS do you recommend to other users?

Current release 46.8 %

I currently use this QGIS version for my production work

QGIS 2.10 52.5 %

How often do you think LTR QGIS versions should be made?

Every year 58.5 %

How long do you think LTR (Long Term Release) versions of QGIS should be supported for?

2 years 40.3 %

How often do you think non LTR releases of QGIS should be made?

Every 4 months (current system) 41.1 %

How often do you use the QGIS documentation?

Occasionally 59.2 %

How frequently do you think documentation should be updated?

Rolling updates – documentation should be required to accompany all new features 42.8 %

When I get stuck using QGIS, I….

ask on stackoverflow 26.9 %

In terms of software development with QGIS, I…

Occasionally write python scripts and expressions 82.5 %

Take part in the user survey.

Here you get to the current answer statistics. In the following I’ll show you some stats from today in detail.

Current survey report.

The post The QGIS survey needs input! appeared first on Digital Geography.

But 2.14.1 will be

Top 5 QGIS Improvements

Open scripts in external editor

Export thumbnails from style manager

save a symbol used in qgis

Rule-based labeling

Rule based labels. Great!

rule editor

Digitising improvements

digitizing curves in QGIS

What else?

Recent projects short-cut in QGIS

SSL and authentication “error”

Your turn?

The post Short Announcement: my top 5 features of QGIS 2.12 appeared first on Digital Geography.