Page 1 of 79 (1576 posts)

  • talks about »

Tags

Last update:
Tue Sep 1 05:00:09 2015

A Django site.

QGIS Planet

Registration open for QGIS hackfest in Gran Canaria, November 2015

Dear QGIS developers

Collage Las Palmas de Gran Canaria

We will be holding our 14th hackfest in Gran Canaria over November 5th – November 8th, 2015. You can read more about the plans for this meet up and register your intention to attend on the hackfest wikipage. This is a developer centric hackfest where we invite coders, documenters, testers, graphic artists, translators and anyone else who is interested in improving QGIS for the benefit of all our users. General users of QGIS are of course also welcome to join us, but we will not be holding any specific user-centric workshops or talks like we do at our user conferences.

The QGIS hackfests are an important aspect of the project, playing an key role in facilitating collaboration and planning within the community of developers and contributors who combine their efforts to put out three releases of QGIS each year. We rely on the goodwill and sponsorship of our grateful users and their host organisations to financially sustain the QGIS project. If you are in a position of influence, we ask you to please consider sponsoring QGIS to support this hackfest and other project related activities.

We would like to thank Pablo Fernández Moniz and his co-organisers from Universidad de las Palmas de Gran Canaria for organising the event. If you are able to support his event organisation activities in any way, please contact him at 

We look forward to seeing your all there!

The QGIS Team


UI theme support now core in QGIS

I enjoy using the dark UI theme for QGIS so much I figured why not make it a core feature. In the next version of QGIS if you head to the options screen you can now find a UI Theme option.

Options | General_037

The default dark theme is called Night Mapping for all those late night mapping jobs that you do, or if you just like dark UI themes.

QGIS b789fab_029

Selection_031

Selection_034

Something you will notice with this theme is the custom icons for the layer visibility. Pretty nifty! Here is how it is done

Creating new themes

To create a new theme simply make a new folder in .qgis2\themes\ with the name of the theme you want and create a style.qss file inside there. Check out the default themes for an example

Follow the Qt style sheet guides to see what can be styled.

Something I have added on top of the normal style sheets is variable support. Variables can be declared in a variables.qss file in the theme folder.

Here is an example of some variables:

@background: #323232
@text: #aaa
@selection: #507098
@menuback: #444
@highlight: #ffaa00

Now in style.qss we can do this:

QWidget
{
color: @text;
background-color: @background;
}

Great for not having to repeat your self or quick updating in a single place. When the theme is applied via the Options dialog or via the API it will replace the variables in style.qss using variables.qss. The result file is called style.qss.auto

Needs some tweaks

The default dark theme is a collection of stuff I have found around the net and stuff I have added myself. It’s far from prefect and I would love help to make it the best dark theme for QGIS. If you have another theme you think would make a good default one open a pull request on GitHub

Enjoy


Filed under: Open Source, qgis Tagged: qgis

Final GSoC report

What do I have completed this week?

  • Added a dedicated threadPool for the Processing Toolbox to run the algorithms.

  • Bugfix on the cancel option. Avoid connecting  the signals every time the algorithm runs. This was making the slots to be called multiple times when running and cancelling the algorithm several times.

Is there any blocking issue?

  • I wasn’t able to fix the issue with the cancel option when you have more than one algorithm running. The issue turned out to be more complicated than I first expected.


Mixing a bit of Excel into QGIS – conditional formatted table cells

I was using Excel the other day and used the conditional formatting rules to style some cells based on a condition. If you have never seen or used them they look like this:

They are pretty handy for a quick idea on the state of your data.  Looking at QGIS I thought to myself “Wait!? Why not do that in QGIS too. That would be pretty neat”.  And with that here it is, finally!. Conditional formatting rules for QGIS attribute table.

cells

icons

You can control the font style, color, background color, even custom icons based on QGIS symbols. The buttons at the top give you access to quick styles which you can tweak more with the other options.

The conditions are just normal QGIS expressions. Use the special variable @value to refer to the current cell value. As they are normal QGIS expressions you can reference the other fields in the expressions.

(Click the GIF for a better view)

table

So go nuts. I would love to hear any feedback if you use it. Try it out in the next nightly dev build.


Filed under: Open Source

Call for applications: QGIS API Documentation Improvement

Dear QGIS DevelopersIn the last few years we have been steadily improving the amount of funding we are able to accumulate in the QGIS project. Our goal in obtaining funding is always to ‘make QGIS better’. Up until now we have focussed funding on high profile aspects of the project: Funding regular hackfests, paying for bug fixing work prior to releases, funding infrastructure such as servers, domain name registrations etc.

With improved funding levels we now have the opportunity to also start addressing some of the many less obvious components of QGIS that badly need attention, but often don’t attract volunteers. In our July 2015 PSC meeting it was agreed that we would start this initiative by funding one or more developers to improve the python documentation in QGIS. Here, briefly, is the vision:

Lets take our inspiration from Qt. As a foundational library for QGIS, I have always loved the fact that Qt4 is so well documented. Take a look at this for example – http://doc.qt.io/qt-4.8/qlabel.html#details

The Qt4 documentation provides a readable narrative explaining the purpose (with images and illustrations if needed) of each class. It also provides a code snippet, which in many cases you can simply cut and paste into your code and then tweak to get started.

As a PyQGIS programmer you have two main resources: The QGIS Python cookbook and the QGIS C++ API documentation. The cookbook is an excellent resource, but it is hard to keep it synchronised with the code base – so examples often run the risk of being out of date, or don’t leverage new functionality that makes its way into the code base. The C++ documentation is good in terms of coverage, but it often lacks detail and as a python programmer you may find it a bit off putting since the text is littered with examples using pointers. Also, the C++ documentation isn’t always a one to one match for python users, and doesn’t explain python specific behaviour such as how ownership is passed around with returning objects.

Wouldn’t it be nice if the C++ API documentation also included the content that is in the python cookbook? And wouldn’t it be nice if the C++ documentation became the C++ *and* Python API documentation – catering for users of both programming languages and providing for a single point of reference and maintenance? Even better the python documentation would live right in the C++ code, so that anytime someone touches the code base they can easily maintain the documentation without needing to jump through a lot of hoops.

For this funded effort we are thus seeking one or more individuals to lay the foundation for this work:

  • establish norms and guidelines for improving the doxygen API docs so that each documented resource can include both python and C++ documentation.
  • port the cookbook content over to the API documentation
  • create doxygen pages to provide a starting point for python programmers to be able to carry out common activities they need
  • populate the API docs with Python examples and improved descriptions
  • do these in a nice clear and concise writing style, again taking inspiration from the fine work that Qt has done
  • perhaps do something really smart to generate docs from the SIP API and incorporate it into our doxygen doctree?

If you think this is something you are able to do, please contact the QGIS PSC using this form and let us know!

Click here to apply here if you are interested in this work


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)


QGIS Welcome Page

Whenever you start QGIS you basically do it because? Right, because you need to do GIS work. Ah, how I love rhetorical questions to start a post. And most of the time one continues to work on a QGIS project which

Twelfth GSoC report – Multithreading on Processing

What do I have completed this week?

  • I have finished the cancel option in order to stop the execution of non-QGIS algorithms. It’s important to remember that as well as the QGIS algorithms the cancel option do not cover all the non-QGIS algorithms and this implementation only covers GDAL and SAGA algorithms. However this option can be easily replicated to the othersthird party algorithms.

  • I have changed the python console to use the QThreadPool.

  • I have been testing and debugging the multithreading implementation looking for unexpected behaviours or incorrect results.

  • Core refactoring.

What am I going to achieve for the next week?

  • Write documentation for the multithreading implementation.

  • Code cleaning and refactoring.

  • Search for problems in the multithreading implementation and correct them.

Is there any blocking issue?

  • No.


QGIS UI themes plugin

Scrap that idea. Seems there is already a  plugin to do this called Load QSS.  I’m not going to duplicate effort. Use that one and we can all make it better.

Want to have a dark theme, or even your own custom theme, for QGIS?  No worries. The UI Theme plugin has your back. Grab it from the plugin installer.  

Change the theme using Plugins -> UI Themes -> Theme It!

theme

Just select a theme and the interface will change styles.  Here is the dark theme called “Much Dark. Such Goth” :)

dark

I will let you try the “Oh my eyes” theme.

Themes can be added by creating a {name}.css file in plugin folder themes folder and edited __init__.pyfile to list the theme.  I’m working on this to make it better but I wrote this in about half an hour so it’s not all there yet.

The active themes is saved in the settings and restored on QGIS load.

If you make a cool theme feel free to make a pull request or ticket so it can be added to the plugin for others to use.  There is heaps that can be done with the Qt stylesheets so go nuts and make something cool.

Note: It’s a work in progress and things might not always look right.


Filed under: Open Source

Syntactic sugar for PyQGIS

PyQGIS now supports a nice new addition for handling edit sessions in layers. This way, changes get committed automatically at the end of a successful (python) edit session.

with edit(layer):
    do your changes here()
See more ›

Using TimeManager for WMS-T layers

This is a guest post by Karolina Alexiou (aka carolinux), Anita’s collaborator on the Time Manager plugin.

As of version 2.1.5, TimeManager provides some support for stepping through WMS-T layers, a format about which Anita has written  in the past.  From the official definition, the OpenGIS® Web Map Service Interface Standard (WMS) provides a simple HTTP interface for requesting geo-registered map images from one or more distributed geospatial databases. A WMS request defines the geographic layer(s) and area of interest to be processed. The response to the request is one or more geo-registered map images (returned as JPEG, PNG, etc) that can be displayed in a browser application. QGIS can display those images as a raster layer. The WMS-T standard allows the user of the service to set a time boundary in addition to a geographical boundary with their HTTP request.

We are going to add the following url as the web map provider service: http://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r-t.cgi

From QGIS, go to Layer>Add Layer>Add WMS/WMST Layer and add a new server and connect to it. For the service we have chosen, we only need to specify a name and the url.

Select the top level layer, in our case named nexrad_base_reflect and click Add. Now you have added the layer to your QGIS project.

To add it to TimeManager as well, add it as a raster with the settings from the screenshot below. Start time and end time have the values 2005-08-29:03:10:00Z and 2005-08-30:03:10:00Z respectively, which is a period which overlaps with hurricane Katrina. Now, the WMS-T standard uses a handful of different time formats, and at this time, the plugin requires you to know this format and input the start and end values in this format. If there’s interest to sponsor this feature, in the future we may get the format directly from the web service description. The web service description is an XML document (see here for an example) which, among other information, contains a section that defines the format, default time and granularity of the time dimension.

add_raster

If we set the time step to 2 hours and click play, we will see that TimeManager renders each interval by querying the web map service for it, as you can see in this short video.

Querying the web service and waiting for the response takes some time. So, the plugin requires some patience for looking at this particular layer format in interactive mode. If we export the frames, however, we can get a nice result. This is an animation showing hurricane Katrina progressing over a 30 minute interval.

whoosh

If you want to sponsor further development of the Time Manager plugin, you can arrange a session with me – Karolina Alexiou – via Codementor.


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.


Point release QGIS 2.8.3 ‘Wien’ is ready!

We are very pleased to announce the point release of QGIS 2.8.3 ‘Wien’. Wien is German for ‘Vienna’ – host city to our developer meet up in November 2009 and again in March 2014.

As point release it contains no new features, but 150 changes to fix bugs (see https://github.com/qgis/QGIS/compare/final-2_8_2…final-2_8_3 for a full list).

Even when only fixes 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/). Please consult the existing and closed issues there before filing any new ones.

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.

Thanks

We would like to thank the developers, documenters, testers and all the many folks out there who volunteer their time and effort (or fund people to do so).

From the QGIS community we hope you enjoy this release! If you wish to donate time, money or otherwise get involved in making QGIS more awesome, please wander along to http://qgis.org and lend a hand!

Finally we would like to thank our official sponsors for the invaluable financial support they provide to this project:

Gold Sponsor:
Asia Air Survey, Japan (http://www.asiaairsurvey.com/)

Silver Sponsors:
Sourcepole AG, Switzerland (http://www.sourcepole.com/)
Office of Public Works, Ireland, Ireland (http://www.opw.ie/)
AGH University of Science and Technology, Poland (http://www.agh.edu.pl/en)
State of Vorarlberg, Austria (http://www.vorarlberg.at/)

Bronze Sponsors:
Nicholas Pearson Associates, UK (http://www.npaconsult.co.uk/)
QGIS Poland, Poland (http://qgis-polska.org/)
http://www.terrelogiche.com, Italy (http://www.terrelogiche.com)>
http://www.geosynergy.com.au, Australia (http://www.geosynergy.com.au/)
Gaia3D, Inc., South Korea (http://www.gaia3d.com/)
Royal Borough of Windsor and Maidenhead, UK (http://www.rbwm.gov.uk/)
Chartwell Consultants Ltd., Canada (http://www.chartwell-consultants.com/)
Trage Wegen vzw, Belgium (http://www.tragewegen.be/)
GFI – Gesellschaft für Informationstechnologie mbH, Germany (http://www.gfi-gis.de/)
GKG Kassel,(Dr.-Ing. Claas Leiner), Germany (http://www.eschenlaub.de/)
GIS-Support, Poland (http://www.gis-support.com/)
ADLARES GmbH, Germany (http://www.adlares.com/)
http://www.molitec.it, Italy (http://www.molitec.it/)
http://www.argusoft.de, Germany (http://www.argusoft.de/)
Customer Analytics, USA (http://www.customeranalytics.com/)
Avioportolano Italia, Italy (http://www.avioportolano.it/)
Faculty of Geology, Geophysics and Environmental Protection,
AGH University of Science and Technology, Poland (http://www.wggios.agh.edu.pl/en)
Urbsol, Australia (http://www.urbsol.com.au/)
MappingGIS, Spain (http://www.mappinggis.com/>)
GIS3W, Italy (http://www.gis3w.it/)
Lutra Consulting, UK (http://www.lutraconsulting.co.uk/)

A current list of donors who have made financial contributions large and small to the project can be seen on our donors list (http://qgis.org/en/site/about/sponsorship.html#list-of-donors).

If you would like to become and official project sponsor, please visit our sponsorship page for details. Sponsoring QGIS helps us to fund our six monthly developer meetings, maintain project infrastructure and fund bug fixing efforts (http://qgis.org/en/site/about/sponsorship.html#sponsorship).

QGIS is Free software and you are under no obligation to pay anything to use it – in fact we want to encourage people far and wide to use it regardless of what your financial or social status is – we believe empowering people with spatial decision making tools will result in a better society for all of humanity.

Sponsoring QGIS helps us to fund our six monthly developer meetings, maintain project infrastructure and fund bug fixing efforts.

Happy QGISing!

Regards,

The QGIS Team!


Hat racks; or appreciating people for what they do.

The biggest thing with open source work is that it can be pretty thankless. There is a lot more that goes into a open source project then just some lines of code, there is events, documentation, API documentation, PR material, more documentation, websites, build setups, etc. It’s quite easy to just look at a project on GitHub, check out the graphs and see the top contributors and never think about it again. Because the code is all that matters right?

githubn

All hail Jürgen and Nyall!

Getting back to the point.  There is a lot of stuff that goes into an open source project that can go unnoticed and under appreciated.  Stuff that isn’t code is hard to track.  Do you know who maintains the QGIS website? What about who translates the UI? What about who ran the last dev meetings? These projects are non code related but are normally things that go unnoticed or under appreciated simply because it’s not a fancy chart in GitHub.  Making people feel welcome and appreciated in a project normally leads to a higher retention rate and a better overall feel for the project.  I remember when I was first thanked for the work I added to QGIS and how it made me feel, still here doing the same thing so it must have worked pretty well.

At PyCon AU 2015  Katie McLaughlin gave a talk about welcoming contributions to a project and being generally being nice to people. Not just being nice but actively thanking people for what they do and how it makes you feel. People generally put a lot of time into the projects they involve themselves in knowing you are appreciated makes you feel good.

Katie got the idea for the project from the talk and post titled A Place to Hang Your Hat by Leslie Hawthorn.  It seems like a silly title but read it and it will all make sense.

Her sub text makes the perfect summary:

On getting many good things done. And no one knows you’re doing any of it.

I’m not going to copy the post here but I will steal her tl;dr part:

  • If someone has volunteered to help your project, take the time to write a 2-3 sentence summary of what they did to help.
  • You can send it to them, along with a thank you note, or offer to post it on their LinkedIn profile. (Remember, users can approve recommendations before they’re added to their profile.)
  • Let’s spend some time celebrating our successes and all of our contributions! Let folks know you’re celebrating that success using #LABHR as a hashtag.
  • #LABHR stands for Let’s All Build a Hat Rack. For why its an awesome acronym, you have to read the post.

And here is the example post she makes:

Sample Recommendation

Deb Nicholson, Board Member, Open Hatch
While not strictly related to her work as an OpenHatch board members, Deb has given me invaluable counsel on fundraising for various non-profits I’ve been affiliated with. She’s also trained numerous community members on how to perform in-person advocacy for free and open source software projects, and software patent reform. As part of that training, she’s also convened numerous meetings and round tables to help people get things done in the open source world. She performs all this work with grace and patience for our sometimes difficult personalities. She’s brilliant and utterly unflappable. Cannot recommend her work highly enough.

So go ahead. Write something nice about someone and what they have done. Send it to them, blog about it, put it in Twitter, LinkedIn, etc.


Filed under: Open Source

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.

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.

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.

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.

Fifth Report

What do I have completed this week?

  • Solved the issue with the outputs.
  • Did some tests with QGIS algorithms which seems to be working fine.
  • Refactored all QGIS algorithms in order to remove the progress bar parameter and use the signal instead.
  • I have changed the Buffer used by QGIS algorithms: the Buffer is now a subclass of QObject. This new implementation allows the buffer to have a parent (the algorithm) and get access to the algorithm’s signal.
  • SagaUtils refactored in the same way I did with the Buffer.
  • SAGA algorithms refactored in order to use the signals instead of the progress parameter (Not finished yet)

What am I going to achieve for the next week?

  • Solve the issue with SAGA algorithms.
  • Code refactoring in order to improve the previous implementation on the AlgorithmDialog.
  • Refactor Grass/Grass7.
  • Bug fixes.

Is there any blocking issue?

There is an issue with SAGA algorithms that makes the Toolbar crash.


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

  • Page 1 of 79 ( 1576 posts )
  • >>

Back to Top

Sponsors