Page 3 of 83 (1655 posts)

  • talks about »

Tags

Last update:
Sat Feb 13 01:00:06 2016

A Django site.

QGIS Planet

Introducing the QGIS Board

Transition
The QGIS PSC (Project Steering Committee) is in transition to becoming a Board. We are registering the project as a Swiss ‘Verein‘ (Association) which will be known as QGIS.ORG and will function as a not-for-profit company, serving the interests of the QGIS project.  The motivation for the transition to a legal entity is described in QGIS QEP (QGIS Enhancement Proposal) #16. The board will be constituted of the same members of the PSC but will gain the executive responsibilities required of our Verein statutes.

New chair and vice-chair

Our long time project founder, Gary Sherman, has stepped down from his role as project chair. I (Tim Sutton) have been elected by the QGIS PSC as Gary Sherman’s replacement by the incoming Board. In addition Paolo Cavallini has been elected as vice chair. Gary will continue to serve as an active voting member of the Board, and will maintain life-long honorary membership on the board.

A special note of thanks

In a world where proprietary GIS software licenses cost many times more than the annual income of most of its citizens, free access to spatial visualisation and analysis tools through QGIS (and its constituent projects such as GRASS, GEOS and GDAL) is a profoundly disruptive force for good.

QGIS is a available to anyone with a reasonably modern computer. It makes the wise utilisation of the earth’s scarce resources and the ability to take care of its citizen’s civic and humanitarian needs based on sound spatial decision-making, that much more possible for a huge swathe of society which would otherwise have been disenfranchised.

Even in developed societies where finance is not necessarily the limiting factor, we cannot underestimate the impact of a software platform that is a freely extensible and shared body of knowledge. QGIS is a platform that enhances the ability of governments and private organisations to deliver services that deeply enrich the lives of their citizens and customers.

Gary’s selfless contribution of the QGIS source code has thus had a far reaching affect on many people’s lives – including my own. Under Gary’s stewardship, the project has evolved from a very basic simple GIS data browser that ran on one platform and could only work with PostGIS data, to a fully-fledged production-ready GIS that can be used on the desktop, in your own custom applications and to serve web maps and services.

Gary has been and will remain an inspirational figure to all of us in the QGIS project – the project he started 13 years ago in 2002. We look forward to his continued involvement on the Board.

Going forward

Our goal as the QGIS.ORG Board is to continue the work started by Gary and to position QGIS as the de facto desktop GIS application, capable of providing a wide range of functionality and richness of features, so that it is no longer necessary to use proprietary GIS software to understand and manage our world.

We are looking for funders for the QGIS.ORG non-profit company. As a foundation project to many humanitarian, municipal, government, NGO, conservation and industry related FOSS tools, we would like to secure funding for the core QGIS project to hire full-time staff so that we can improve the quality and functionality of QGIS for all our users.

To date we have subsisted mainly on micro donations and small-scale sponsorships for which we are very grateful (keep them coming!). This has been very useful but has never take us to the point where we can employ staff full-time to work solely for the good of the project. We would like to establish a team of full-time developers, documentation writers etc.….so we have quite a mountain to climb!

Over the coming months we will be actively seeking out new sources of funding to support these goals, whilst never losing sight of our core principles of Open Governance, Open Source and Open Community. We hope you will join us and support us in this exciting new chapter of the QGIS project!

Your Board

  • Tim Sutton (Chair)
  • Paolo Cavallini (vice-Chair)
  • Andreas Neumann (Treasurer)
  • Gary Sherman (life time honorary member)
  • Anita Graser
  • Otto Dassau
  • Richard Duivenvoorde
  • Marco Hugentobler
  • Jürgen Fischer

timsutton

Tim Sutton
Incoming QGIS Board Chair


Multiple format map series using QGIS 2.6 – Part 2

EN | PT

In my last post, I have tried to show how I used QGIS 2.6 to create a map series where the page’s orientation adapted to the shape of the atlas features. This method is useful when the final scale of the maps is irrelevant, or when the size of the atlas elements is  similar, allowing one to use a fixed scale. On the other hand, when using a fixed scale is mandatory and the features size are too different, it is needed to change the size of the paper. In this second part ot the post, I will try to show how I came to a solution for that.

As a base, I used the map created in the previous post, from which I did a duplicate. To exemplify the method, I tried to create a map series at 1:2.000.000 scale. Since I was going to change both width and height of the paper, I did not need to set an orientation, and therefore, I deactivated the data defined properties of the orientation option:

ith some maths with the map scale, the size of the atlas feature and the already defined margins, I came up with the following expressions to use, respectively,  in width and height:

((bounds_width( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1 + 10
((bounds_height( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1 + 30

Allow me to clarify. (bounds_width( $atlasgeometry ) / 2000000.0) is the atlas feature’s width in meters when represented at 1:2.000.000. This is multiplied by 1000 to convert it to millimeters (the composer’s settings units). In order to keep the atlas feature not to close to the margin, I have decided to add 10% of margin around it, hence the multiplication by 1.1. To finish I add the map margins value that were already set in the previous post (i.e.,20 mm, 5 mm, 10 mm, 5 mm)

As one can see from the previous image, after setting the expressions in the paper width and height options, it’s size already changed according to the size of the atlas features. But, as expected, all the itens stubbornly kept their positions.For that reason, it has been necessary to change the size and position expressions for each of then.

Starting by the map item size, the expressions to use in width and height were not difficult to understand since they would be the paper size without the margins size:

((bounds_width( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1
((bounds_height( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1

Screenshot from 2014-11-16 23:07:43

To position the items correctly, all was needed was to replace the “CASE WHEN … THEN … END” statement by the expressions defined before. For instance, the expressions used in the X and Y options for the legend position:

(CASE WHEN  bounds_width(  $atlasgeometry ) >=  bounds_height( $atlasgeometry) THEN 297 ELSE 210 END) - 7
(CASE WHEN  bounds_width(  $atlasgeometry ) >=  bounds_height( $atlasgeometry) THEN 210 ELSE 297 END) - 12

Became, respectively:

(((bounds_width( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1 + 10) - 7
(((bounds_height( $atlasgeometry ) / 2000000.0) * 1000.0) * 1.1 + 30) - 12

Screenshot from 2014-11-16 23:22:40

Changing the expressions of the X and Y position options for the remaining composer’s items I have reached the final layout.

alaska_region_Kenai Peninsula

Once again, printing/exporting all (25) maps was only one click away.

mosaico_regioes_fixed

Since QGIS allows exporting the composer as georeferenced images, opening all maps in QGIS I got this interesting result.

Screenshot from 2014-11-17 00:02:38

As one can see by the results, using this method, we can get some quite strange formats. That is why in the 3rd and last post of this article, I will try to show how to create a fixed scale map series using standard paper formats (A4, A3, A2, A1 e A0).

Disclaimer: I’m not an English native speaker, therefore I apologize for any errors, and I will thank any advice on how to improve the text.


QGIS Crowdfunding project: 2.5D Rendering of buildings/polygons

QGIS already supports various different renderers, such as
categorized, rule-based, point-displacement, 25d_renderingheatmap, etc. This allows for advanced cartographic representations. In addition, there are plugins available, such as “qgis2threejs” or “QGIS Globe”, which allow to view and export QGIS data in the third dimension. While these plugins are very useful, they also have limitations: they are not fully integrated with the QGIS styling mechanisms and can’t be integrated in the QGIS print composer for  high-quality printing.

This crowd funding project aims to extend QGIS renderers with oblique views. The third dimension of the polygon is controlled by an attribute or expression and global angles. The representations can be combined with other QGIS styling options, such as symbol levels, layer effects, categories and rules. Applications are rendering buildings according to their actual heights (similar to Google maps 2.5d rendering) or thematic maps where the polygons are extruded according to an attribute to be represented.

This project is primarily financed by ADUGA and the regional council of Picardy in France. However, of the 20k Euros, 5k are still missing, to fully implement the project.

Thank you for helping us out by contributing to this crowd funding campaign over at OpenGIS.


QGIS Crowdfunding: 2.5D Rendering

2.5D rendering

QGIS Podcast Episode 11

The Official QGIS Podcast is back! In this episode we discuss the QGIS User Survey, the release of QGIS 2.12, highlight an interesting QGIS based study and much more!

Download the mp3 directly here.

Show notes are available:  QGIS Podcast Episode 11 Show notes.

You can subscribe to the podcast using our podcast RSS feed.


Announcing the release of QGIS 2.12

3648539707d0789903fdfedac3705584f12fa6ac
This week we have more great news from Jürgen Fischer, our release manager:

“QGIS is a user friendly Open Source Geographic Information System that runs on Linux, Unix, Mac OSX, and Windows.

We are very pleased to announce the release of QGIS 2.12 ‘Lyon’. Lyon was the host city to our developer meet up in April 2012.

Latest Release

This is another regular release following our four monthly schedule.  It again brings many nice new features to QGIS.

Please also note that we’re constantly keeping our long term release QGIS 2.8 ‘Wien’ in good shape to better suit more conservative production setups.

New Features in QGIS 2.12 ‘Lyon’

QGIS 2.12 includes many great new features, tweaks and enhancements to make the
most popular Free desktop GIS even more feature filled and useful.  Visit the visual changelog that highlights some of the new additions.

Whenever new features are added to software they introduce the possibility of new bugs – if you encounter any problems with this release, please file a ticket on the QGIS Bug Tracker (http://hub.qgis.org).

The source code and binaries for Windows, Debian and Ubuntu are already available via the large download link on our home page: http://qgis.org.  More packages will follow as soon as the package maintainers finish their work. Please revisit the page if your platform is not available yet.”


test

Spatialite and lost styles

In this blog I will explain how to recover styles that are included in a SpatiaLite database but are lost after renaming or moving the SpatiaLite database to another location. It will show how to use the QGIS Field Calculator to change the contents of de field f_table_catalog in the table layer_styles so it directs … Continue reading Spatialite and lost styles

QGIS Server binding news

With QGIS 2.12 the new Python bindings for QGIS server are now available and the server can be invoked directly from a python scripts with just a few lines of code:

 

from qgis.server import QgsServer
my_query_string = "map=/projects/my_project.qgs&SERVICE=WMS&request=GetCapabilities"
headers, body =  QgsServer().handleRequest(my_query_string)

 

Embedding QGIS in a Python web application

Embedding QGIS Server in a web application is now not only possible but really very easy, for example, a Django view:

# QGIS server view

from django.http import HttpResponse
from django.views.generic import View
from qgis.server import *


class OGC(View):
    """Pass a GET request to QGIS Server and return the response"""

    def __init__(self):
        self.server = QgsServer()        

    def get(self, request, *args, **kwargs):
        """Pass a GET request to QGIS Server and return the response"""
        headers, body = self.server.handleRequest(request.GET.urlencode())
        response = HttpResponse(body)
        # Parse headers
        for header in headers.split('\n'):
            if header:
                k, v = header.split(': ', 1)
                response[k] = v
        return response

 

Using server plugins

 

Of course Python server plugins can be plugged in easily, see the example below:

 


# QGIS server view

from django.http import HttpResponse
from django.views.generic import View
from qgis.server import *
from qgis.core import *



class OGC(View):
    """Pass a GET request to QGIS Server and return the response"""

    def __init__(self):
        self.server = QgsServer()
        # Call init to create serverInterface
        self.server.init()
        serverIface = self.server.serverInterface()

        class Filter1(QgsServerFilter):
            def responseComplete(self):
                QgsMessageLog.logMessage("Filter1.responseComplete", "Server", QgsMessageLog.INFO )
                request = self.serverInterface().requestHandler()
                if request.parameter('REQUEST') == 'HELLO':
                    request.clearHeaders()
                    request.setHeader('Content-type', 'text/plain')
                    request.clearBody()
                    request.appendBody('Hello from SimpleServer!')

            def requestReady(self):
                QgsMessageLog.logMessage("Filter1.requestReady")

        self.filter = Filter1(serverIface)
        serverIface.registerFilter(self.filter)


    def get(self, request, *args, **kwargs):
        """Pass a GET request to QGIS Server and return the response"""
        headers, body = self.server.handleRequest(request.GET.urlencode())
        response = HttpResponse(body)
        # Parse headers
        for header in headers.split('\n'):
            if header:
                k, v = header.split(': ', 1)
                response[k] = v
        return response


 

Enjoy QGIS Server with Python!

4th QGIS UK user group meeting in Edinburgh

4th QGIS UK user group EdinburghOK. Here it is. The official call for offers of speaking, running a workshop, doing a lightning talk, generally helping, and sponsoring the 4th QGIS UK user group meeting in Scotland on 16th November. Tom Armitage has booked the Informatics Forum in Crichton Street for us again.

Tickets are available here: http://www.eventbrite.com/e/uk-qgis-user-group-scotland-tickets-19194628651

I am open to suggestions from you, the users, about how the day is organised but I imagine something that has a few talks, a workshop session and a good lunch break would tick most boxes.  So get in touch and let’s make it happen.

Use the contact form on the About Us page to get in touch or via twitter @mixedbredie.

Sponsored by OS thinkWhere EDINA


Rule-based Labelling in QGIS 2.12

The new QGIS 2.12 (Lyon) will be out soon!

In this release, we have revamped the labelling engine and made it more flexible in-line with the rest of vector styling.

In this release, we have:

  • Revamped the labelling engine
  • Added support for mutually exclusive layer tree groups
  • Developed raster alignment tool

Read on for a how new rule-based labeling engine works…

For users

In previous versions of QGIS, users can select a field value or use an expression as labels for a vector layer. In QGIS 2.12, users can additionally define rules to label vector layers. Rule-based labelling works in the similar way as “Style”. A list of rules will be defined by users and they will be applied from top-to-bottom.

Field based labelling (Click to enlarge)

Rule based labelling (Click to enlarge)

To achieve the same effect in the earlier versions of QGIS, users should add a complex expression.The example below shows the expression used in earlier versions of QGIS:

CASE WHEN length( "htmlname" ) > 13 AND strpos("htmlname",' ') > 6 THEN replace("htmlname",' ',' ') WHEN length( "htmlname" ) > 20 AND "htmlname" LIKE '%Golf Course' THEN regexp_replace("htmlname",'Golf Course',' Golf Course') WHEN length( "htmlname" ) > 20 AND "htmlname" LIKE '%Nature Reserve' THEN regexp_replace("htmlname",'Nature Reserve',' Nature Reserve') WHEN length( "htmlname" ) > 20 AND "htmlname" LIKE '%Church Of England%' THEN regexp_replace("htmlname",'Church Of England',' Church Of England ') WHEN length( "htmlname" ) > 13 AND "htmlname" LIKE '% Of The %' THEN regexp_replace("htmlname",'Of The','Of The ') WHEN length( "htmlname" ) > 13 AND "htmlname" LIKE '% of %' AND "fontcolour" <> 2 AND "fontcolour" <> 4 THEN regexp_replace("htmlname",' of ',' of ') WHEN "htmlname" LIKE '%/%' THEN regexp_replace("htmlname",'/','/ ') WHEN length( "htmlname" ) > 30 THEN replace("htmlname",' ',' ') ELSE "htmlname" END

As you can see, without rule-based labelling users have to define each case and the labelling text. Additionally, with the cumbersome task of defining each case, users are limited to using specific labelling formats (e.g. font color, font size, visibility range, etc). With the new labelling engine, users can define their labels similarly to styles – in fact they can copy the rules from styling tabs and use it within the new labelling section!

Examples of label rules (Click to enlarge)

For developers

In order to facilitate addition of rule-based labelling, some internal changes were made to the QGIS labelling engine interface. The labelling is now driven by the new class QgsLabelingEngineV2 which may have several label providers associated with it. The label providers are objects derived from QgsAbstractLabelProvider and they are responsible for:

  1. providing “label features” that define properties of each label and geometry of the feature they represent; and

  2. drawing of labels at the positions determined by the engine.

Currently there are label provider implementations for diagrams, simple labelling and rule-based labelling.

The existing labelling engine (QgsPalLabeling class) is now built on top of the new labelling engine and works as a wrapper for it so that existing code that uses QgsPalLabeling still works.

As of now, the API for the new labelling engine is not considered as complete and therefore not available in Python. The idea is to make it easier to use, more polished and better prepared for the future use cases. It will be likely finished during the 2.14 release cycle and some changes may need to be postponed to QGIS 3.0 where backwards incompatible API changes will be allowed (as of now, QGIS 3.0 is being intensively discussed on QGIS developer mailing list).

Funding

This rule-based labeling has been funded by Tuscany Region (Italy). Special thanks also to the QGIS developers for their help with bug fixing.

Dica para ajustar posição de símbolos em QGIS | Hack to adjust map symbols location in QGIS

De quando em vez aparecem-me zonas com demasiado símbolos no mesmo local, e pensei como seria fantástico se os pudesse arrastar para um local mais conveniente sem ter de alterar as suas geometrias, tal como é possível fazer com as etiquetas. Esse pensamento deu-me a ideia base para a dica que vou demonstrar.

Now and then I get too many map symbols (points) in the same place, and I thought how nice it would be if we could drag n’ drop them around without messing with their geometries position, just like we do with labels. That thought gave me an idea for a cool hack.

Escolha a sua camada de pontos e comece por criar dois novos campos chamados symbX e symbY (Tipo: Decimal; Tamanho: 20; precisão: 5). No separador “Estilo” das propriedades da camada, defina para cada nível do seu símbolo o seguinte: Escolher “unidade do mapa” como a unidade para as opções de afastamento; Usar a seguinte expressão na opção afastamento das propriedades definidas por dados.

Choose your point layer and start by creating two new fields called symbX and symbY (Type: Decimal number; Size: 20; Precision: 5). Now go the layer properties and in the Style tab edit your symbol. For each level of your symbol select “map units” as the offset units, and set the following expression in the offset data define properties option:


CASE WHEN symbX IS NOT NULL AND symbY IS NOT NULL THEN
    tostring($x - symbX) + ',' + tostring($y - symbY)
ELSE
    '0,0'
END

Screenshot from 2015-02-22 18:18:43

Tenha atenção que, se as coordenadas do seu mapa tiver valores negativos, será necessário uma pequena alteração ao código. E. g., se tiver valores negativos em X deverá usar-se  antes a expressão “tostring(symbX -$x)”.

Beware that if your coordinates have negative values you need to adapt the code. E.g., If you have negative values in X you should use “tostring(symbX -$x)” instead.

De forma temporária coloque etiquetas na sua camada usando um texto pequeno (eu usei o ‘+’ (sinal de mais) centrado e com um buffer branco) e defina as coordenadas X e Y dos propriedades definidadas por dados usando os campos symbX e symbY,

Now, temporarly  label your layer with a small convenient text (I used a centered ‘+’ (plus sign) with a white buffer) and set its coordinates to data defined using the symbX and symbY Fields.

Screenshot from 2015-02-22 22:42:07

A partir desse momento, quando usar a ferramenta de mover etiquetas, não só alterará a posição da etiqueta, mas também a do próprio símbolo! Fantástico, não?

From this point on, when you use the move label tool, not only the label position change but also the actual symbol! Pretty cool, isn’t it?

anim

Note que as geometria dos elementos não são alteradas durante o processo. Para além disso, lembre-se que neste caso também poderá adicionar linhas de guia para ligar os símbolos à posição original do ponto.

Notice that the features geometries are not changed during the process. Also, remember that in this case you can also add leading lines to connect the symbols to the original position of the points.


Calcular coordenadas do centroide de polígonos | Calculate polygon centroid’s coordinates

Tive necessidade de, numa camada de polígonos, adicionar colunas à tabela de atributos com as coordenadas dos centroides das geometria. Cheguei às seguintes expressões para calcular as coordenadas X e Y, respectivamente:

I had the need to add columns with the coordinates of polygons centroids. I came up with the following expressions to calculate X e Y, respectively:

xmin(centroid($geometry))
ymin(centroid($geometry))

A expressão parece bastante banal, mas ainda demorei a perceber que, não existindo funções x(geometry) e y(geometry), podia usar as funções xmin() e ymin() para obter as coordenadas dos centroides dos polígonos. Uma vez que esta não foi a primeira vez que precisei de usar estas expressões, fica agora o registo para não me voltar a esquecer.

The expression seems quite simple, but it toke me some time before I realize that, not having a x(geometry) and y(geometry) functions, I could use the xmin() and ymin() to get the coordinates of the polygons centroids. Since this wasn’t the first time I had to use this expressions, this post will work as a reminder for the future.


Eleventh GSoC report – Multithreading on Processing

What do I have completed this week?

  • During this week I have changed the multithreading implementation to use the QThreadPool to allow thread recycling and avoid thread creation costs every time we want to run an algorithm. This new implementation adds some flexibility to the multithread support and avoid unexpected behaviours in different machines. The number of threads in the QThreadPool is initialised accordingly to the number of cores in the PC and may happen that the QT is not able to detect the number of cores. In this case we will only have one thread in the thread pool, which can be occupied with something else. I’m trying to detect when there is no available threads on the ThreadPool and increase the number of threads if necessary.

What am I going to achieve for the next week?

  • Start working on a test suite for the multithreading to ensure the correct behaviour of the multithreading implementation. The test suite must check if the worker thread is starting, check if signals are triggering the functions when it is supposed to and verify if the cancel option is working properly.

  • Figure out how to stop the execution of a non-QGIS algorithm.

Is there any blocking issue?

  • I have spotted some issues when testing the code in a different machine (with Linux Mint 17) that may have to do with thread unavailability.  Therefore, I decided to postpone the current tasks and focus on changing the multithreading implementation in order to correct this kind of unexpected behaviours.


Ninth GSoC Report – Multithreading on Processing

What do I have completed this week?

  • Solved an issue that makes QGIS crash when the main thread doesn’t wait for the worker thread to start.
  • I spent most of the time looking up some tutorials about unit testing on QGIS and trying to configure python paths to run the processing tests.

What am I going to achieve for the next week?

  • This week I’ll change back to the multithreading implementation in order to add the cancel option to stop the algorithm execution. I will be working on a mechanism to stop the execution on QGIS algorithm.

Is there any blocking issue?

  • This week my mentor proposed to start working on a suite test and I changed the plan to start working on a unit test to ensure the correct behaviour of the multithreading implementation. At the end of the week we discussed about asking the community to test the new implementation and report the issues if there is any.

Eighth GSoC Report – Multithreading on Processing

What do I have completed this week?

  • Created a mechanism to hold the result of the algorithm taking into account that there can be several algorithms running at the same time. The results are stored in a global variable called algResults. This variable is accessible via python console (e.g. “processing.algResults”).

algResults

  • The signals are connected in a different way in order to close the dialog and quit the thread when the algorithm is finished.
  • I have updated my fork and merged my work into the master branch.
  • Added the runalgIterating method to the AlgorithmExecutor with some changes to support the signals to set the progress
  • AlgorithmDialog refactored.
  • I have been searching for a solution to stop the algorithm execution and I think that is possible to create a sort of checkpoints inside the algorithm to check if we want to stop the execution and raise an exception to stop the thread event loop.

What am I going to achieve for the next week?

  • Allow the user to cancel the execution when running the runalgIterating.
  • Solve the problem with QGIS dependencies on Ubuntu and test the refactored algorithms.
  • Continue working on the algorithm iterating.

Is there any blocking issue?

  • I had to postpone the tests due to some problems installing QGIS dependencies on Ubuntu.
  • Didn’t had time to implement a solution to stop the execution of the algorithm.

Tenth GSoC report – Multithreading on Processing

What do I have completed this week?

  • During this week I worked on a mechanism to stop the algorithm execution on QGIS algorithms. The approach used to cancel the execution explores python exceptions and QT signals to stop the algorithm from the main thread without having to wait in order to stop the execution and terminate the worker thread. I have used signals to trigger an exception inside the algorithm and stop the execution from the main thread. Since there is a significant amount of algorithms, the mechanism had to be implemented in just two of the QGIS algorithms. This implementation can be further replicated  towards the remaining  QGIS algorithms.

What am I going to achieve for the next week?

  • Start working on a test suite for the multithreading to ensure the correct behaviour of the multithreading implementation. The test suite must check if the worker thread is starting, check if signals are triggering the functions when it is supposed to and verify if the cancel option is working properly.

  • Figure out how to stop the execution of a non-QGIS algorithm.

Is there any blocking issue?

  • No blocking issues

Parallel execution of QGIS algorithms

This is just an example of the advantage provided by the multithreading on the Toolbox. As each algorithm is running in a separate thread, this allows us to run more than one algorithm at the same time.

 

I’m polishing the implementation and trying to find some major problems in the current implementation.  It has some minor bugs that can be easily solved by adding a parameter to the  cancel signal (e.g. when you have two algorithms running and try to cancel one of them, the signal emitted will cancel two algorithms instead of just one)


Seventh Report

What do I have completed this week?

  • Processing refactored in order to create a non-blocking implementation of the python console. The algorithm is processed in another thread asynchronously and the result is printed to the python console when the execution is finished.
  • AlgorithmDialog refactored to create a non-blocking dialog interface with a button to cancel the execution.
  • R algorithms refactored to support the progress signal.

What am I going to achieve for the next week?

  • Create a mechanism to hold the result of the algorithm taking into account that there can be several algorithms running at the same time.
  • Figure out a way to stop the execution of the algorithm. In third-party algorithms it can not be possible to just interrupt the thread loop and quit the thread. The only available option is to discard the result because the algorithms don’t have any kind of check-point that allows to verify once in while if we want to stop the execution. Kill the thread during the execution can be dangerous and it is not a good option.
  • Test the refactored algorithms.

Is there any blocking issue?

  • It took more time than I expect to create a non-blocking interface.
  • Quitting the thread execution turned out to be far more complicated due to the fact that the algorithms don’t provide any mechanism to allow quitting the thread loop during the execution.

Sixth Report

What do I have completed this week?

  • Solved the issue with SAGA algorithms that makes the Toolbox crash.
  • Refactored Grass/Grass7 and OTB algorithms to work with signals.
  • Bug fixes.

What am I going to achieve for the next week?

  • Test Grass/Grass7 and OTB algorithms.
  • Add an option to cancel the execution of the algorithm and kill the thread.
  • Code refactoring.
  • Start implementing the runalgIterating.

Is there any blocking issue?

  • I had a very busy week due to my university deadlines.
  • An issue with my SAGA installation made me think that something was wrong with my implementation and made me lose some time.
  • The issue with the SAGA installation also prevented me from testing the algorithms.

  • <<
  • Page 3 of 83 ( 1655 posts )
  • >>

Back to Top

Sponsors