Python, R, Qt, peewee, bokeh, pandas, SQLite plus couple of sleepless nights and here you are a cute app for the environmental monitoring needs )))

Main window of the application |

"We will leave this world stupid and evil as we have found it upon our arrival." – Valtaire.

Tags: bokeh, environment, environmental monitoring, monitoring, pandas, Python, Qt, R, science, SQLite

0

Tags: Peewee, Python, SQLite, UUID

I wanted to have UUID fields in my Peewee-bsead models for the SQLite database. I quickly found ready-to-use code, but it lacked one important thing – automatic uuid generation. Here is the solution:

import uuid from peewee import Field class UIDField(Field): db_field = 'uid' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.default = uuid.uuid4 def db_value(self, value): return str(value) # convert UUID to str def python_value(self, value): return uuid.UUID(value) # convert str to UUID

Recently I did a QGIS scripting job and here is the feedback from an extremely satisfied customer:

It was fantastic to work with Yury. He provided an excellent product, that went far beyond what I was expecting. I will certainly be contacting Yury in the future for any jobs that relate to GIS and python scripting. Communication was excellent and his ability to understand the job requirement was very impressive. A+++

Guys, if you are in need of geoprocessing tool for your project – don’t hesitate to contact me 😉

This is probably my shortest post ever.

All my QGIS processing scripts (R and Python) and models that I already blogged about, plus some extra are now available at GitHub.

This is strange, but I was unable to find instruction about importing QGIS layers into PostGIS database with PyQGIS API. The PyQGIS cookbook has the example of exporting layers as .shp-files via QgsVectorFileWriter.writeAsVectorFormat() function and says that the other other OGR-supported formats are available to use in this function as well. PostGIS is supported by OGR so people got confused and try to use this function to import data to the PostGIS with no success and have to write generic import functions.

After of couple of hours of searching the internet for the solution I gave up and decided to find the answer the hard way: started to search through the source code for the *DB Manager* plugin that has this nice “import layer” feature. It took about 20 minuets to trace down the function that was in charge of the import and it was QgsVectorLayerImport.importLayer(). But the quest wasn’t over yet! The documentation says nothing about provider names that are accepted by this function. “PostgreSQL” would be the obvious name for the provider as it is the name for the *PostgeSQL* provider in OGR, but it is not the case. I had to go through the source code of *DB Manager* again and luckily in comments (and there are quite a few of them in *DB Manager*: I didn’t find a single doc-string there) the author wrote that it is “postgres” for the *PostgreSQL*.

Now here is the very basic example code of importing QGIS layer into PostGIS:

uri = "dbname='test' host=localhost port=5432 user='user' password='password' key=gid type=POINT table=\"public\".\"test\" (geom) sql=" crs = None # layer - QGIS vector layer error = QgsVectorLayerImport.importLayer(layer, uri, "postgres", crs, False, False) if error[0] != 0: iface.messageBar().pushMessage(u'Error', error[1], QgsMessageBar.CRITICAL, 5)

Tags: Delauney, GIS, Graph, NetworkX, Python, science

For my own project I needed to create a graph based on a Delauney triangulation using NetworkX python library. And a special condition was that all the edges must be unique. Points for triangulation stored in a .shp-file.I was lucky enough to find this tread on Delauney triangulation using NetworkX graphs. I made a nice function out of it for point NetworkX graphs processing. This function preserves nodes attributes (which are lost after triangulation) and calculates lengths of the edges. It can be further improved (and most likely will be) but even at the current state it is very handy.

Example of use:

import networkx as nx import scipy.spatial import matplotlib.pyplot as plt path = '/directory/' f_path = path + 'filename.shp' G = nx.read_shp(f_path) GD = createTINgraph(G, show = True)

Code for the function:

import networkx as nx import scipy.spatial import matplotlib.pyplot as plt def createTINgraph(point_graph, show = False, calculate_distance = True): ''' Creates a graph based on Delaney triangulation @param point_graph: either a graph made by read_shp() from another NetworkX's point graph @param show: whether or not resulting graph should be shown, boolean @param calculate_distance: whether length of edges should be calculated @return - a graph made from a Delauney triangulation @Copyright notice: this code is an improved (by Yury V. Ryabov, 2014, riabovvv@gmail.com) version of Tom's code taken from this discussion https://groups.google.com/forum/#!topic/networkx-discuss/D7fMmuzVBAw ''' TIN = scipy.spatial.Delaunay(point_graph) edges = set() # for each Delaunay triangle for n in xrange(TIN.nsimplex): # for each edge of the triangle # sort the vertices # (sorting avoids duplicated edges being added to the set) # and add to the edges set edge = sorted([TIN.vertices[n,0], TIN.vertices[n,1]]) edges.add((edge[0], edge[1])) edge = sorted([TIN.vertices[n,0], TIN.vertices[n,2]]) edges.add((edge[0], edge[1])) edge = sorted([TIN.vertices[n,1], TIN.vertices[n,2]]) edges.add((edge[0], edge[1])) # make a graph based on the Delaunay triangulation edges graph = nx.Graph(list(edges)) #add nodes attributes to the TIN graph from the original points original_nodes = point_graph.nodes(data = True) for n in xrange(len(original_nodes)): XY = original_nodes[n][0] # X and Y tuple - coordinates of the original points graph.node[n]['XY'] = XY # add other attributes original_attributes = original_nodes[n][1] for i in original_attributes.iteritems(): # for tuple i = (key, value) graph.node[n][i[0]] = i[1] # calculate Euclidian length of edges and write it as edges attribute if calculate_distance: edges = graph.edges() for i in xrange(len(edges)): edge = edges[i] node_1 = edge[0] node_2 = edge[1] x1, y1 = graph.node[node_1]['XY'] x2, y2 = graph.node[node_2]['XY'] dist = sqrt( pow( (x2 - x1), 2 ) + pow( (y2 - y1), 2 ) ) dist = round(dist, 2) graph.edge[node_1][node_2]['distance'] = dist # plot graph if show: pointIDXY = dict(zip(range(len(point_graph)), point_graph)) nx.draw(graph, pointIDXY) plt.show() return graph

Tags: Dota 2, pseudo random, Python

Here is an interesting post about 6.81 patch influence on heroes win rate in Dota 2. One point caught my attention: a drastic change in Axe win rate: from 52% to 48%; see image below.

Axe’s win rate before and after 6.81 patch (29-th of April) |

The only change Axe get in this patch was implementation of the preudo random approach for the determination of Counter Helix skill triggering instead of random. As was guessed in the article:

“…where you manage to Berserker’s Call several enemies, you only have 3.2 seconds of being unconditionally hit by the enemy. In this time frame, the amount of successful Counter Helixes that use PRD is probably lower than with a true random. Hence the decrease in damage output and Win Rate.”

Ok, nice guess! Lets test it!

Import needed modules

import random import numpy from tabulate import tabulate import collections <div> <div style="text-align: justify;"> Lets create functions to calculate number of Counter Helix PROCs for given number of hits using random and pseudo random approaches. First one will be using random approach (notice that random.randrange() actually generates pseudo random set of values)</div> <br /> def randHelixProc(hits): ''' checks if Counter Helix PROCs (chance = 17%) using random approach @param hits: number of times Axe was hit @return procs: number of times Counter Helix PROCs ''' procs = 0 for i in xrange(hits): chance = random.randrange(1, 101) if chance < 18: procs += 1 else: continue return procs

I don't know how exactly pseudo random PROCs are designed for Axe or for Dota 2 in general, but they say that the probability of the pseudo random event in Dota 2 in it initial state has lower chance to proc than the stated probability for the event and each time the event is not triggered when it could the chance for this event to occur is increased. Lets say some event triggers with the 50% chance. Suggested pseudo random approach can be realised with 3 consecutive checks that have different chances: 0%, 50% and 100% (average is 50%). When event finally triggers it reset chance for the event to initial value (0% in this case) and it all starts over again.

def pseudoRandHelixProc(hits): ''' checks if Counter Helix PROCs (chance = 17%) using pseudo random approach @param hits: number of times Axe was hit @return procs: number of times Counter Helix PROCs ''' treshold = 0 prob_list = [2, 5, 9, 14, 23, 47] # ~17% on average procs = 0 for i in xrange(hits): chance = random.randrange(1, 101) try: success = prob_list[treshold] except: success = prob_list[5] if chance >= success: treshold += 1 else: procs += 1 treshold = 0 return procs

Check if the chances for PROCs are the same for the both functions. We should have 1700 procs of Counter Helix for 10000 attacs on Axe. Launch 100 simulations of 10000 hits for each function and compute average procs for random and pseudo random approaches.

rhelix_list = [] for i in xrange(100): value = randHelixProc(10000) rhelix_list.append(value) numpy.mean(rhelix_list) >>>1702.79 p_rhelix_list = [] for i in xrange(100): value = pseudoRandHelixProc(10000) p_rhelix_list.append(value) numpy.mean(p_rhelix_list) >>>1702.3

Output difference is negligible for random and pseudo random implementations.

Now its time to create a simulation function.

def simulation(times, hits): ''' Computes average number of PROCs for given hits for random and pseudo random approaches and difference between them. @param times: number of times simulation will run @param hits: number of hits to simulate @return: average difference in pocs between random and pseudo random approaches; table of simul results ''' # create lists of results diff_list = [] rand_mean_list = [] p_rand_mean_list = [] # run simulation for hit in xrange(1, hits + 1): rand_list = [] pseudo_rand_list = [] for t in xrange(times): rand = randHelixProc(hit) p_rand = pseudoRandHelixProc(hit) rand_list.append(rand) pseudo_rand_list.append(p_rand) # compute statistics and populate lists of results rand_mean = numpy.mean(rand_list) rand_mean_list.append(rand_mean) p_rand_mean = numpy.mean(pseudo_rand_list) p_rand_mean_list.append(p_rand_mean) diff = rand_mean - p_rand_mean diff = round(diff, 2) diff_list.append(diff) # print average difference in PROCs total_diff = sum(diff_list) l = len(diff_list) print 'average difference:', total_diff/l print '#######################################################################################################' # create table output for simulation results out_dict = {} out_dict['(1) cumulative hits'] = range(1, l + 1) out_dict['(2) random mean PROCs'] = rand_mean_list out_dict['(3) pseudo random mean PROCs'] = p_rand_mean_list out_dict['(4) difference'] = diff_list out_dict = collections.OrderedDict(sorted(out_dict.items())) print tabulate(out_dict, headers = 'keys', tablefmt="orgtbl")

Lets run 100 simulations of 100 consecutive hits. Of course it is possible to run 10000 hits but it is unnecessary since every time the Counter Helix is triggered we jump back to the first row from the table below (result of the simulation). As was already mentioned:

"[if] ...you manage to Berserker's Call several enemies, you only have 3.2 seconds of being unconditionally hit by the enemy"

If Axe was able to catch 3 enemies, together they will hit him about 9-12 times. This means that with the pseudo random approach he will spin 0.3-0.4 times less than with random approach. It will cause him to deal ~(205*0.35)*3 = 215,25 (or 71.75 per hero) less damage in engagement.

So the hypothesis was true - pseudo random approach caused the decrease in damage output on the short time interval even if total number of PROCs during the game stayed the same.

average difference: 0.34 ####################################################################################################### | (1) cumulative hits | (2) random mean PROCs | (3) pseudo random mean PROCs | (4) difference | |-----------------------+-------------------------+--------------------------------+------------------| | 1 | 0.17 | 0 | 0.17 | | 2 | 0.45 | 0.09 | 0.36 | | 3 | 0.56 | 0.12 | 0.44 | | 4 | 0.71 | 0.26 | 0.45 | | 5 | 0.81 | 0.36 | 0.45 | | 6 | 1.06 | 0.75 | 0.31 | | 7 | 1.37 | 0.88 | 0.49 | | 8 | 1.35 | 0.97 | 0.38 | | 9 | 1.47 | 1.22 | 0.25 | | 10 | 1.64 | 1.33 | 0.31 | | 11 | 1.95 | 1.65 | 0.3 | | 12 | 2.1 | 1.68 | 0.42 | | 13 | 2.36 | 1.79 | 0.57 | | 14 | 2.56 | 2.16 | 0.4 | | 15 | 2.61 | 2.26 | 0.35 | | 16 | 2.61 | 2.37 | 0.24 | | 17 | 2.87 | 2.43 | 0.44 | | 18 | 2.77 | 2.83 | -0.06 | | 19 | 3.22 | 2.84 | 0.38 | | 20 | 3.03 | 2.84 | 0.19 | | 21 | 3.6 | 3.22 | 0.38 | | 22 | 3.71 | 3.32 | 0.39 | | 23 | 3.68 | 3.68 | 0 | | 24 | 3.93 | 3.72 | 0.21 | | 25 | 4.54 | 3.92 | 0.62 | | 26 | 4.65 | 4.04 | 0.61 | | 27 | 4.47 | 4.27 | 0.2 | | 28 | 4.83 | 4.39 | 0.44 | | 29 | 4.78 | 4.48 | 0.3 | | 30 | 4.93 | 4.8 | 0.13 | | 31 | 5.3 | 4.92 | 0.38 | | 32 | 5.1 | 5.04 | 0.06 | | 33 | 5.79 | 5.34 | 0.45 | | 34 | 5.82 | 5.54 | 0.28 | | 35 | 6.04 | 5.52 | 0.52 | | 36 | 5.67 | 5.7 | -0.03 | | 37 | 6.64 | 5.98 | 0.66 | | 38 | 6.4 | 6.03 | 0.37 | | 39 | 6.72 | 6.41 | 0.31 | | 40 | 7.07 | 6.46 | 0.61 | | 41 | 7.04 | 6.59 | 0.45 | | 42 | 7.18 | 6.81 | 0.37 | | 43 | 7.08 | 6.9 | 0.18 | | 44 | 7.61 | 7.09 | 0.52 | | 45 | 7.72 | 7.21 | 0.51 | | 46 | 7.73 | 7.66 | 0.07 | | 47 | 8 | 7.68 | 0.32 | | 48 | 8.41 | 7.7 | 0.71 | | 49 | 8.57 | 7.93 | 0.64 | | 50 | 8.54 | 8.11 | 0.43 | | 51 | 8.16 | 8.31 | -0.15 | | 52 | 9 | 8.4 | 0.6 | | 53 | 9.01 | 8.79 | 0.22 | | 54 | 8.98 | 8.88 | 0.1 | | 55 | 9.54 | 8.99 | 0.55 | | 56 | 9.4 | 9.13 | 0.27 | | 57 | 9.75 | 9.08 | 0.67 | | 58 | 10.1 | 9.42 | 0.68 | | 59 | 9.71 | 9.64 | 0.07 | | 60 | 10.31 | 9.87 | 0.44 | | 61 | 10.19 | 10.31 | -0.12 | | 62 | 10.29 | 10.21 | 0.08 | | 63 | 10.76 | 10.55 | 0.21 | | 64 | 10.82 | 10.48 | 0.34 | | 65 | 10.7 | 10.77 | -0.07 | | 66 | 11.27 | 10.94 | 0.33 | | 67 | 11.81 | 11.06 | 0.75 | | 68 | 11.54 | 11.34 | 0.2 | | 69 | 11.98 | 11.26 | 0.72 | | 70 | 12.26 | 11.66 | 0.6 | | 71 | 11.35 | 12.01 | -0.66 | | 72 | 12.03 | 11.64 | 0.39 | | 73 | 12.37 | 11.94 | 0.43 | | 74 | 12.74 | 12.16 | 0.58 | | 75 | 13.16 | 12.66 | 0.5 | | 76 | 12.77 | 12.59 | 0.18 | | 77 | 13.1 | 12.65 | 0.45 | | 78 | 13.2 | 12.95 | 0.25 | | 79 | 13.59 | 13.06 | 0.53 | | 80 | 13.32 | 13.27 | 0.05 | | 81 | 13.74 | 13.25 | 0.49 | | 82 | 13.98 | 13.47 | 0.51 | | 83 | 14.86 | 13.74 | 1.12 | | 84 | 14.53 | 13.8 | 0.73 | | 85 | 14.54 | 14.29 | 0.25 | | 86 | 14.49 | 14.22 | 0.27 | | 87 | 15.03 | 14.46 | 0.57 | | 88 | 15.49 | 14.55 | 0.94 | | 89 | 15.51 | 14.8 | 0.71 | | 90 | 15.58 | 15 | 0.58 | | 91 | 16.17 | 15.01 | 1.16 | | 92 | 14.89 | 15.43 | -0.54 | | 93 | 15.73 | 15.4 | 0.33 | | 94 | 16.16 | 15.67 | 0.49 | | 95 | 16.11 | 16.17 | -0.06 | | 96 | 16.03 | 16.17 | -0.14 | | 97 | 16.41 | 16.07 | 0.34 | | 98 | 17.26 | 16.27 | 0.99 | | 99 | 15.65 | 16.7 | -1.05 | | 100 | 16.15 | 16.96 | -0.81 |

Tags: Python, QGIS, rasters

Script for unifying extent and resolution is able to work with multi-band rasters. Also I fixed an error that caused output rasters to have different resolutions in some cases.

Tags: GDAL, GIS, Processing, Python, QGIS, SEXTANTE

My post about modification of extent and resolution of rasters drew quite a bit of attention and I decided to make a small New Year’s present to the community and create a QGIS Processing script to automate the process.

The script was designed to be used within Processing module of QGIS. This script will make two rasters of your choice to have the same spatial extent and pixel resolution so you will be able to use them simultaneously in raster calculator. No interpolation will be made – new pixels will get predefined value. Here is a simple illustration of what it does:

Modifications to rasters A and B |

To use my humble gift simply download this archive and unpack files from ‘scripts‘ folder to your …/.qgis2/processing/scripts folder (or whatever folder you configured in Processing settings). At the next start of QGIS you will find a ‘Unify extent and resolution’ script in ‘Processing Toolbox’ in ‘Scripts’ under ‘Raster processing’ category:

If you launch it you will see this dialogue:

Main window |

Note that ‘Help’ is available:

Help tab |

Lets describe parameters. ‘raster 1‘and ‘raster 2‘are rasters that you want to unify. They must have the same CRS. Note that both output rasters will have the same pixel resolution as ‘raster 1′.

‘replace No Data values with’ will provide value to pixels that will be added to rasters and replace original No Data values with the value provided here. Note that in output rasters this value will not be saved as No Data value, but as a regular one. This is done to ease feature calculations that would include both of this rasters, but I’m open to suggestions and if you think that No Data attribute should be assigned I can add corresponding functionality.

Finally you mast provide a path to the folder where the output rasters will be stored in ‘output directory’ field. A ‘_unified’ postfix will be added to the derived rasters file names: ‘raster_1.tif’ -> ‘raster_1_unified.tif’

If CRSs of rasters won’t match each other (and you will bypass built-in check) or an invalid pass will be provided a warning message will pop up and the execution will be cancelled:

Example of the warning message |

When the execution is finished you will be notified and asked if rasters should be added to TOC:

Happy New Year!

P.S. I would like to thank Australian government for making the code they create an open source. Their kindness saved me a couple of hours.

Tags: GIS, Python, QGIS, rasters, SEXTANTE

I decided to make my script for counting unique values in raster more usable. Now you can use it via SEXTANTE in QGIS. Download script for SEXTANTE and extract archive to the folder that is is intended for your Python SEXTANTE scripts (for examlple ~./qgis2/processing/scripts). If you don’t know where this folder is located go Processing -> Options and configuration -> Scripts -> Scripts folder, see the screenshot:

Now restart QGIS and in SEXTNTE Toolbox go to Scripts. You will notice new group named Raster processing. There the script named Unique values count will be located:

Launch it and you will see its dialogue window:

Main window |

Note that Help is available:

Either single- or multi-band rasters are accepted for processing. After the raster is chosen (input field) one need to decide whether to round values for counting or not. If no rounding is needed – leave ‘round values to ndigits‘ field blank. Otherwise enter needed value there. Note that negative values are accepted – this will round values to ndigits before decimal point.

When the set up is finished hit the Run button. You will get something like this:

Result window |