If so, you’ve been using QGIS a long time…
- OGR and PostGIS support
- No raster support
- Three widgets on the Symbology tab
- No symbology in the legend
But you could use it handily on a 640x480 display.
]]>
If so, you’ve been using QGIS a long time…
But you could use it handily on a 640x480 display.
]]>
Version 0.6 of Script Runner has been released and includes these changes:
For a basic introduction to Script Runner see this post: Script Runner: A Plugin to Run Python Scripts in QGIS
To run a script, you must add it to Script Runner using the Add Script tool on
the toolbar. Select the script from the file dialog to add it to a list in the left panel. The list of scripts
is persisted between uses of QGIS.
To run a script, select it from your list of scripts and click the Run tool. Output from the script will be displayed in the Script Runner console
You can remove a script by selecting it from the list and clicking the Remove Script tool. This just removes it from the list; it does nothing to the script
file on disk.
Clicking the Info tool will populate
the Info and Source tabs in the panel on the right. The Info tab contains the
docstring from your module and then a list of the classes, methods, and
functions found in the script. Having a proper docstring at the head of your
script will help you determine the purpose of script.
At version 0.6 the Info tool is only needed if you have disabled automatic display of info/source (see Preferences).
You can view the source of the script on the Source tab. This allows you to quickly confirm that you are using the right script and it does what you think it will.
Version 0.6 implements a number of new features.
You can pass arguments to your script using keywords. Your run_script function must have two arguments:
1
| |
Running your script is done using the Run script with arguments tool. This prompts you to enter your argument(s) in a key=value format:
All strings must be quoted and multiple arguments should be separated by a comma.
When your script is run, the arguments are contained in args, which is a Python dict. In the example above, you could access them like this:
1 2 | |
Scripts that accept keyword arguments are displayed in the list with two asterisks appended to their name:
See Passing Arguments for a complete example.
All print statements in your script will be directed to the Script Runner console. In addition, any tracebacks from exceptions will be displayed there, as well as in a popup dialog.
Printing messages to the console can be useful for both development and status updates in long running scripts. You can clear the console using the Clear Console tool. There is also an option in Preferences to clear the console each time a script is run.
You can choose to log everything that goes to the output console to disk. Use the Preferences dialog to setup the directory where the scriptrunner.log will be written.
You can open the selected script in an external editor by right-clicking on it and choosing Edit script in external editor from the popup menu. The default system editor for .py files will be used to open the script. In Preferences, you can specify a different editor by entering the full path to the executable.
The Preferences dialog allows you to set the following options:
Here are three script examples: a simple script that has only a run_script function, one that uses a Python class, and one that passes keyword arguments.
This simple script contains only a run_script function:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | |
When executed by Script Runner, the script removes any layers currently
on the map, then loads the world_borders shapefile, sets its fill color to
red, and updates the map canvas and the legend. The
run_script function does all the work. You could expand this script by
adding additional functions that are called from run_script.
This script uses a class that is initialized from the run_script function to load some layers:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | |
In this example, the run_script function creates an instance (ldr) of a
class named Loader that is defined in the same source file. It then calls a
method in the Loader class named load_shapefiles to do something
useful—in this case, load all the shapefiles in a specified directory.
This script illustrates passing an argument (a path) to load all shapefiles in a directory:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | |
Lines 29 and 30 illustrate using the passed argument to print a message to the console and call the method to add the shapefiles to the map.
The script examples are minimalistic—they don’t do error checking in a number of places, such as checking to see if a QgsVectorLayer is valid or if needed arguments were actually passed to the script. Don’t take the scripts as examples of complete, solid code.
Comments on this post are welcome, as are bug reports. The link to the bug tracker for Script Runner can be found in the About box, along with the link to the code repository and my email address.
]]>While working on an update to the Plugin Builder, I encountered a small problem. The Plugin Builder displays the version number in the title bar of its main window. After bumping the version number to 1.8.4 in all the requisite places, it still showed 1.8.3 when testing.
Using grep on all the source files revealed no instance of 1.8.3 in any file.
The title of this post has probably already given you the answer—I had on old version of the plugin in my Python path. The old plugin was getting picked up first when QGIS loaded.
Here’s what happened:
I previously had the old version in my plugin directory (~/.qgis/python/plugins), but moved it up one level so I could test the new one. It turns out this directory is also in the Python path when you load QGIS, a fact that escaped my attention. Using the Python Console in QGIS to display the path revealed the problem. Once I moved the version 1.8.3 plugin out of the way, my new version happily loaded.
The other pitfall you can encounter is if you use the QGIS_PLUGINPATH environment variable during your development. This allows you to specify another directory QGIS will also search for plugins. If you have multiple versions of the same plugin in any of these directories you may be setting yourself up for conflict.
The moral of the story:
Don’t stash old plugins in .qgis/python or you may send yourself down the wrong path…
]]>The AAS sponsorship is yet another indication that QGIS is a mature and stable project which continues to provide innovative open source GIS software.
The QGIS Project Steering Committee (PSC) wishes to thank AAS for their continuing commitment. These funds will help further the development of QGIS, in part by allowing face to face developer meetings and code sprints (also known as hackfests).
The QGIS project has always relied on volunteers and community involvement. If your organization would like to become a sponsor, please contact the Finances and Marketing Manager: cavallini[at]faunalia.it.
For more information on sponsorship levels, please see the QGIS Sponsorship page.
]]>Slowly it began to attract attention—not all of it positive. Some questioned why I was starting a new open source GIS project when there were others I could join. Others were interested in signing up to help. In those early days, getting one or two messages a week on the one and only mailing list was exciting. It was a slow start, but as more people joined the project, QGIS began to grow exponentially.
Over the years, we added support for additional vector formats, rasters, on the fly projection, map composition, Python scripting, and more features than I can possibly list.
Today QGIS is used all over the world, in a myriad of disciplines. If you find QGIS useful, please consider supporting the project through direct involvement or a sponsorship.
I founded QGIS; the community built it. Here’s to many more successful years as one of the leading open source GIS projects.
]]>To install any of these plugins:
This little plugin provides a way to attach metadata to a project. Things you might want to include in a note are:
This information can be helpful when sharing a project or when you forget what you did six months after the fact.
Here is a screenshot showing qNote in action:
To install the plugin:
You can control the visiblity of the qNote panel from the View->Panels menu.
The README for the plugin can be viewed on the qNote GitHub page.
]]>
The QGIS home page has links to all the documentation and
community resources. The navigation panel on the left has links to both the
Community resources and the manual.
To quickly see links to all the resources, click the Need Help? button on the home page. You’ll find links to:
GIS StackExchange allows you to ask questions and get answers from a wide range
of users and experts in the GIS realm. If you have a question specific to QGIS, tag it
with the qgis keyword, otherwise use an appropriate tag.
Since StackExchange is question-based, you should not ask multiple questions in a single posting.
Also, make sure you flag the question as answered once you receive a satisfactory response.
The QGIS project maintains a number of mailing lists. For most people, the two of interest are qgis-user and qgis-developer:
qgis-user: Use this list for discussion of QGIS in general, as well as specific questions regarding its installation and use.
qgis-developer: Used for discussion of development issues, plans, and features. If you plan to contribute code or patches to the project or write your own Python plugins, you’ll find this list useful.
If you just want to browse or search the mailing lists without subscribing, they are available on Nabble.
IRC (Internet Relay Chat) is a method of communication used widely by open source communities. On any given day you will find both developers, contributors, and users monitoring the #qgis channel on irc.freenode.net.
To use IRC, you’ll need a client application for your computer, tablet, or smartphone.
Here are a couple of guidelines for using the #qgis channel:
The QGIS IRC community is very friendly and helpful. Give it a try.
All of the web resources for the QGIS project are indexed by search engines. Searching for your specific question can often lead you to the answer you are looking for, whether it be in a blog, on a mailing list, or the QGIS web site itself.
In addition to your favorite search engine, try DuckDuckGo for more targeted search results.
If you need a good introduction to open source GIS applications, tools, and scripting, take a look at my book.
]]>If you have an thoughts on the closure, good, bad, or otherwise, please comment.
]]>
The Script Runner plugin allows you to add your scripts to a list so they are readily available. You can then run them to automate QGIS tasks and have full access to the PyQGIS API. In addition, you can view information about the classes, methods, and functions in your module as well as browse the source:
In order for your script to work with ScriptRunner it has to implement a single function as an entry point. Here is some additional information from the Help tab of the plugin:
In order for Script Runner to execute your script you must define a run_script function that accepts a single argument. This is the standard entry point used by Script Runner. A reference to the qgis.utils.iface object will be passed to your run_script function. You don’t have to use the iface object in your script but your run_script function must accept it as an argument.
Here is an example of a simple run_script function:
1
2
3
def run_script(iface):
ldr = Loader(iface)
ldr.load_shapefiles('/vmap0_shapefiles')
In this example, the run_script creates an instance (ldr) of a class named Loader that is defined in the same source file. It then calls a method in the Loader class named load_shapefiles to do something useful—in this case, load all the shapefiles in a specified directory.
Alternatively, you could choose not to use classes and just do everything within the run_script function, including having it call functions in the same script or others you might import. The important thing is to be sure you have defined a run_script function. If not, Script Runner won’t load your script.
To run a script, you must add it to Script Runner using the Add Script tool on the toolbar. This will add it to a list in the left panel. This list of scripts is persisted between uses of QGIS. You can remove a script using the Remove Script tool. This just removes it from the list; it does nothing to the script file on disk.
Once you have a script loaded, you can click the Script Info tool to populate the Info and Source tabs in the panel on the right. The Info tab contains the docstring from your module and then a list of the classes, methods, and functions found in the script. Having a proper docstring at the head of your script will help you determine the puprose of script.
You can view the source of the script on the Source tab. This allows you to quickly confirm that you are using the right script and it does what you think it will.
Click it and you are off and running.
]]>There are a couple of requirements to run a script in the console:
The script must be in your PYTHONPATH
Just like a QGIS plugin, the script needs a reference to qgis.utils.iface
By default, the Python path includes the .qgis/python directory. The location depends on your platform:
Windows: in your home directory under .qgis\python. For example, C:\Documents and Settings\gsherman.qgis\python
Linux and OS X: $HOME/.qgis/python
To see what is in your PYTHONPATH you can do the following in QGIS Python console:
1 2 | |
While you could use the .qgis\python directory for your custom scripts, a better way is to create a directory specifically for that purpose and add that directory to the PYTHONPATH environment variable. On Windows you can do this using the Environment Variables page in your system properties:
On Linux or OS X, you can add it to your .bash_profile, .profile, or other login script in your home directory:
export PYTHONPATH=$PYTHONPATH:/home/gsherman/qgis_scripts
With the environment set, we can create scripts to automate QGIS tasks and run them from the console. For this example, we will use a simple script to load all shapefiles in a specified directory. There are a couple of ways to do this:
Write a simple script with a function that accepts qgis.utils.iface as an argument, along with a path to the shapefiles
Create a Python class that uses an init method to store a reference to the iface object and then add methods to do the work
We will use the latter approach because it is more flexible and allows us to initialize once and then call methods without having to pass the iface object each time.
The script looks like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | |
To open the console use the Plugins->Python Console menu item.
The comment at the head of the script explains how to use it.
First we import the Loader class from the script file (named loader.py). This script resides in the qgis_scripts directory that is our PYTHONPATH.
1
| |
We then create an instance of Loader, passing it the reference to the iface object:
1
| |
This creates the Loader object and calls the init method to initialize things.
Once we have an instance of Loader we can load all the shapefiles in a directory by calling the load_shapefiles method, passing it the full path to the directory containing the shapefiles:
1
| |
The load_shapefiles method uses the path to get a list of all the shapefiles and then adds them to QGIS using addVectorLayer.
Here is the result, rendered in the random colors and order that the shapefiles were loaded:
When testing a script in the console you may need to reload it as you make changes. This can be done using reload and the name of the module. In our example, reload(loader) does the trick.
You can add more methods to your class to do additional tasks
You can create a “driver” script that accepts the iface object and then initializes additional classes to do more complex tasks
[1]. I have plans on the drawing board to implement this feature.
]]>Mathematical (+, -, *, /)
Trigonometric (sin, cos, tan, asin, acos, atan)
Comparison (<, >, =, <=, >=)
Logical (AND, OR)
To perform operations on a raster or rasters, they must be loaded in QGIS. The raster calculator is accessed from the Raster menu and brings up the dialog:
Let’s look a few examples.
Doing a simple calculation is easy. In this example we have a Digital Elevation Model (ancc6) loaded in QGIS. The DEM contains elevations for a 1:63,360 quadrangle in Alaska. The coordinate system is geographic and the elevation value in each cell is in meters. If we wanted to create a raster with elevation in feet, we can use these steps to create the expression:
Bring up the raster calculator
Double click on ancc6@1 in the raster bands list to add it to the expression
Double click the multiplication operator (*)
In the expression box, type in the conversion factor for meters to feet: 3.28
This gives us the following expression:
ancc6@1 * 3.28
To complete the process, we specify a name for the output raster and the format we want to use. When you click OK, the operation will be performed and the new raster created, giving us a GeoTIFF with cell values in feet. If you leave the Add result to project box checked the output raster will be added to QGIS once the calculations are done.
If you only want to operate on a portion of a raster, you can use the extent setting to limit the area included in the calculation.
Sometimes you might want to mask out part of a raster. An example might be one where you have elevations ranging from below sea level to mountain tops. If you are only interested in elevations above sea level, you can use the raster calculator to create a mask and apply it to your raster all in one step.
The expression looks like this:
(my_raster@1 >= 0) * my_raster@1
The first part of the expression in parentheses effectively says: for every cell greater than or equal to zero, set its value to 1, otherwise set it to 0. This creates the mask on the fly.
In the second part of the expression, we multiply our raster (my_raster@1) by the mask values. This sets every cell with an elevation less than zero to zero. When you click OK, the calculator will create a new raster with the mask applied.
Using the raster calculator and a mask we can visually simulate a rise in sea level. To do this we simply create the mask and overlay it on the DEM or perhaps a DRG (topographic) raster.
The expression to raise sea level by 100 meters is:
ancc6@1 > 100
The output raster contains cells with either a 0 (black) or 1 (while) value:
The black areas represent everything below an elevation of 100 meters, effectively illustrating a sea level rise. When we combine this with a suitable background we can demonstrate the results:
We added the DRG for the quadrangle and overlaid it with the mask layer. Setting the transparency to 70% allows the DRG to be seen, illustrating the effect of raising sea level.
The raster calculator is a powerful tool. Check it out and see how you might use it in your analysis and map making.
]]>The OpenLayers plugin is installed like all other Python plugins. From the the Plugins menu in QGIS, choose Fetch Python Plugins. This brings up the plugin installer. To find the plugin, enter openlayers in the Filter box, then select OpenLayers Plugin from the list. Once it’s highlighted, click the Install plugin button. This will download the plugin from the repository, install it, and load it into QGIS.
The OpenLayers Plugin uses your view extent to fetch the data from the service you choose. For this reason you should load at least one of your own layers first. Since each of the services are expecting a request in latitude/longitude your layer either has to be geographic or you must enable on the fly projection.
To add one of the services you have two choices; you can pick the service from the Plugins->OpenLayers plugin menu or you can use the OpenLayers Overview. The Overview opens a new panel that allows you to choose a service from a drop-down list. Click the Enable map checkbox to enable the drop-down list and preview the service you want to add. If you are happy with what you see, you can add it to the map by clicking the Add map button.
In the screenshot below we have enabled the Overview panel, added the world boundaries layer[1], zoomed to an area of interest, and added the Google terrain (physical) data:
You can add as many services as you want, previewing them using the OpenLayers Overview panel.
[1] You can get the world boundaries layer from the Geospatial Desktop sample data set.
]]>The Profile plugin is installed like all other Python plugins. From the the Plugins menu in QGIS, choose Fetch Python Plugins. This brings up the plugin installer. To find the plugin, enter profile in the Filter box, then select Profile from the list. Once it’s highlighted, click the Install plugin button. This will download the plugin from the repository, install it, and load it into QGIS.[1]
Here we have loaded the DEM as well as a raster (DRG) of the topography for the same quadrangle and zoomed in a bit to an area of interest:
The yellow line has been added to indicate where we will take the profile. While the Profile plugin allows you to interactively select the profile line it doesn’t display the line on the map.
To create a profile, first make sure the raster you want to profile is selected in the layer list, then activate the plugin from the Plugins toolbar by clicking on it. The cursor becomes a cross that you use to create the profile line: click at the start point, move to the end and click again. Once you have created the profile line, the plugin pops up the result:
The profile is taken from the northeast towards the southwest, based on where we clicked first. You can change the exaggeration of the profile by using the slider on the left. The X axis shows the distance along the profile line in map units and the Y axis shows the cell values from the raster—in this case, elevation in meters.
You can save the result as a PDF or SVG using the buttons at the bottom of the dialog.
The Statistics tab displays some information for the raster layer and the profile line:
If we had additional rasters loaded, we could use the Setup tab to add them to the profile analysis. This would display the results using the colors specified for each layer and we could compare them on the Profile tab.
This is just one of several QGIS plugins that deal with profiles. You can check out the rest of them using the Python Plugin installer.
[1] The Profile plugin requires the Python module for QWT5. If you don’t have this installed, a warning will be displayed during the installation process.
]]>Let’s take a look at some example data. Here we have some fictional wildlife tracking data for two moose. The tracking data is in shapefile format, but you can use any vector format supported by QGIS. The tracking data is symbolized by our two animals: Moose1 and Moose2:
The moose_tracks layer has an animal tracking id field (animal_tid) and a sequence field (id). This is all we need to convert the individual observations into a line feature that represents the animals path.
The Points to Paths plugin is installed like all other Python plugins. From the the Plugins menu in QGIS, choose Fetch Python Plugins. This brings up the plugin installer. To find the plugin, enter points to in the Filter box, then select Points to Paths from the list. Once it’s highlighted, click the Install plugin button. This will download the plugin from the repository, install it, and load it into QGIS.
Let’s convert the tracking data to paths. To get started, choose Plugins->Points to Paths from the menu or click on the Points to Paths tool on the Plugin toolbar. This brings up the PointsToPaths dialog box where we specify the paramaters needed to create the paths. Below is the completed dialog for our moose tracks:
The first drop-down box contains a list of the vector layers loaded in QGIS—in our case we have just one: moose_tracks. For the group field drop-down we chose the field that contains the tracking identifier for each animal. This determines which points will be selected and grouped to form an individual line. The point order field drop-down specifies the field that contains the ordering for the observations. In this case, the id field is incremented with each observation and can be used to construct the paths. We don’t have a date/time field in this data, but your observations may be sequenced in this way. The Python date format field allows you to specify a format string so the plugin can determine how to sequence your points based on date/time.
The last thing we need to specify is the output shapefile. You can do this by typing in the full path to a new shapefile or by using the Browse button.
With these options set, clicking the OK button will create the new shapefile containing the paths created from our point observations. Once the shapefile is created, the plugin gives you the option to add the new shapefile directly to QGIS.
The result of our simple example are shown below:
We symbolized the individual tracks using the Categorized renderer on the Style tab of the vector properties dialog. You can see we now have a track for each animal. The attribute table created by the plugin contains the following fields:
group - the name of the animal taken from the field we chose as the group field
begin - the value of the first point order field used to create the path
end - the value of the last point order field used to create the path
In our data, group contains the animal name, begin the value of the lowest id field for animal, and end contains the greatest id value. In a more typical data set, begin and end would contain the start and end date/time values for the observation. Labeling the observation points with our sequence field or date/time values would allow us to determine the direction of movement.
If you have point data that represent a movement of an object, this plugin is a great way to convert it into a path that can be used for visualization, analysis, or map composition.
]]>
Time Manager lets you browse spatial data that has a temporal component. Essentially this includes anything that changes location through time. Examples include:
Expanding on our last post about QGIS Users Around the World, we’ll use Time Manager to watch access to the QGIS Python plugin repository through time. If you refer to the previous post, you’ll see that all the IP addresses contacting the repository were extracted from the web server log and geocoded to get the approximate geographic coordinates. To use Time Manager all we need is the time for each access to the repository.
A important part (for our purpose) of the web server log entry looks like this:
192.168.1.2 - - [23/Oct/2011:21:17:54 +0000] "GET /repo/contributed HTTP/1.1" 200 256
Time Manager supports date/time in the following formats:
YYYY-MM-DD HH:MM:SS
YYYY-MM-DD HH:MM
YYYY-MM-DD
As you can see, this doesn’t work with the format in the web server log.
The geocoding process created a file containing IP address, country, city (where available), latitude and longitude. This file is used to create a Python dictionary to look up locations by IP address. Using this file and a bit of Python, the web server log entries were converted into a CSV file containing:
ip,date_time,country,latitude,longitude
192.168.1.2,2011-10-23 21:13:53,United States,61.2149,-149.258
192.168.1.2,2011-10-23 21:14:22,United States,61.2149,-149.258
192.168.1.2,2011-10-23 21:17:54,United States,61.2149,-149.258
192.168.1.2,2011-10-23 21:18:04,United States,61.2149,-149.258
...
The CSV file was first converted to a shapefile using the QGIS Delimited Text plugin. Performance with Time Manager was somewhat slow using a shapefile containing 134,171 locations. The shapefile was imported into a SpatiaLite database (you can do this using ogr2ogr or the SpatiaLite GUI).
To display the progression of access to the repository (and thus users of QGIS), we first have to have the Time Manager plugin installed.[1] Once installed, we enable it using the Plugin Manger.
As you can see from the screenshot above, Time Manager installs a new panel in QGIS that sits below the map canvas. You can set a number of options by clicking Settings; the most important being the layer to use in the visualization. For the QGIS users, we use the time_manager_req layer that was created from the web server logs. With the location and date/time data in the proper format, you can click the “Play” button to start the display. For each time interval, the plugin selects the appropriate entries and displays a frame for the duration specified in the settings.
You can use the time slider to move around or move the time interval forward or backward using the buttons on each end of the slider.
A really nice feature is the ability to export to video. At present this saves a PNG file and world file for each time interval. You can then use another software package to combine these to create a video animation of the time sequence. Once solution is to use mencoder[1]:
mencoder "mf://*.PNG" -mf fps=10 -o output.avi -ovc lavc -lavcopts vcodec=mpeg4
Putting all this together gives us the following visualization of QGIS user activity from October 23 through December 19, 2011:
You can see the “wave” of activity progress from east to west as the daylight hours come and go.
If you have spatial data with a date or time component, the Time Manager plugin provides a convenient way to visualize the temporal relationships.
]]>The analysis was done using the log files from the QGIS contributed repository:
The IP address of each entry that retrieved the plugin list from the server represents one or more users—these IPs were collected into a unique list
Using a Python script, each IP address in the log was geocoded to get the approximate latitude and longitude of the user
The IP address, country, latitude, and longitude were written to a CSV file
The CSV file was converted to a Spatialite layer to create the map of users
The map represents 35,603 unique IP addresses of users that accessed the repository between October 23, 2011 and December 17, 2011.
The geocoding process varies in precision—some IPs are located to the city level while others only return a general location for the country.
Some assumptions and observations:
Most (maybe all) users make use of Python plugins and therefore access the contributed repository at some point
Country-level points (blue) on the map represent more than one user
Some points represent organizations that use a single IP for all users accessing the Internet. These points will represent more than one user
Some users may access the repository from more than one IP address
So how many people use QGIS? At the very minimum, 35,000. We know that the downloads of just the Windows version exceeded 100,000. Given that there are 7,183 IP addresses that are generalized to a country location, we can safely assume that the number of actual users is much higher than that.
Considering the number of points that represent an organization and those that represent a country location, I think we can safely assume that the number of QGIS users easily exceeds 100,000 worldwide.
]]>While you can do all your work in one clone, this method has a couple of advantages, at the expense of a bit of disk space:
The basic steps are:
It’s simpler than it sounds—the following steps should work on any platform and assume you have already created your own clone of the QGIS repository on github.
First make a directory for development, change to it, and fetch a copy of your clone of QGIS from github (this will take a while):
gsherman@dork:~$ mkdir qgis_dev
gsherman@dork:~$ cd qgis_dev
gsherman@dork:~/qgis_dev$ git clone git@github.com:g-sherman/Quantum-GIS.git
Cloning into Quantum-GIS...
remote: Counting objects: 183812, done.
remote: Compressing objects: 100% (42255/42255), done.
remote: Total 183812 (delta 140627), reused 183281 (delta 140221)
Receiving objects: 100% (183812/183812), 240.80 MiB | 1.19 MiB/s, done.
Resolving deltas: 100% (140627/140627), done.
Now change to your new clone directory and add the upstream repository (the QGIS repo on github):
gsherman@dork:~/qgis_dev$ cd Quantum-GIS/
gsherman@dork:~/qgis_dev/Quantum-GIS$ git remote add upstream git@github.com:qgis/Quantum-GIS.git
We can then list our config to see that the remote was added:
gsherman@dork:~/qgis_dev/Quantum-GIS$ git config --list
core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*
remote.origin.url=git@github.com:g-sherman/Quantum-GIS.git
branch.master.remote=origin
branch.master.merge=refs/heads/master
remote.upstream.url=git@github.com:qgis/Quantum-GIS.git
remote.upstream.fetch=+refs/heads/*:refs/remotes/upstream/*
Then we do a fetch from the QGIS repo to make sure things are up to date:
gsherman@dork:~/qgis_dev/Quantum-GIS$ git fetch upstream
If your clone of the QGIS repository on github is not brand new, you should do a merge before proceeding:
gsherman@dork:~/qgis_dev/Quantum-GIS$ git merge upstream/master
Now we can create a new clone for the 1.7.2 branch using our local master:
gsherman@dork:~/qgis_dev/Quantum-GIS$ cd ..
gsherman@dork:~/qgis_dev$ git clone ./Quantum-GIS Quantum-GIS-1_7_2
Cloning into Quantum-GIS-1_7_2...
done.
Now we need to add the remote for the main QGIS repository:
gsherman@dork:~/qgis_dev$ cd Quantum-GIS-1_7_2/
gsherman@dork:~/qgis_dev/Quantum-GIS-1_7_2$ git remote add upstream git@github.com:qgis/Quantum-GIS.git
The next step is to fetch from upstream to make sure we have references to the branches:
gsherman@dork:~/qgis_dev/Quantum-GIS-1_7_2$ git fetch upstream
* [new branch] dev-threading -> upstream/dev-threading
* [new branch] master -> upstream/master
* [new branch] release-0_0_11 -> upstream/release-0_0_11
* [new branch] release-0_0_12 -> upstream/release-0_0_12
...
* [new branch] release-1_7_1 -> upstream/release-1_7_1
* [new branch] release-1_7_2 -> upstream/release-1_7_2
* [new branch] release-1_8 -> upstream/release-1_8
Now we create the branch to track the release of interest—in this case 1.7.2:
gsherman@dork:~/qgis_dev/Quantum-GIS-1_7_2$ git branch --track release-1_7_2 upstream/release-1_7_2
Branch release-1_7_2 set up to track remote branch release-1_7_2 from upstream.
The last step is to check out the branch which should go pretty quick:
gsherman@dork:~/qgis_dev/Quantum-GIS-1_7_2$ git checkout release-1_7_2
Checking out files: 100% (1809/1809), done.
Switched to branch 'release-1_7_2'
You are now ready to build the 1.7.2 release branch. Repeat the process for any other branches you want to track.
]]>Here is a short video showing how to create, compile, and install a new plugin.
For more information, see QGIS Workshop Documentation and the PyQGIS Cookbook.
]]>The search is case sensitive and will return a list of all matches. Not too smart but it will get you close to what you want.
See the link at http://irclogs.geoapt.com/qgis
]]>