Last Updated: Monday February 06, 2012

Last Change : Wednesday February 01, 2012

<H3>Monday February 06, 2012</H3>

Last Updated: Monday February 06, 2012

Last Change : Wednesday February 01, 2012

support). QGIS just needs the libpq client library, so unless you want to

If you are wanting to build QGIS as a 64-bit application, you will need to

time, but Qwt is statically linked into PyQwt, and QGIS can't use it. So, we

(minimum GRASS version as stated in the QGIS requirements, substitute the GRASS

The QGIS Mapserver feature requires fastcgi support. This is included in

QGIS. The way to handle this is to bundle Qt inside the QGIS application. You

can do this now or wait to see if there are immediate crashes when running QGIS.

It's also a good idea to bundle Qt if you need to copy QGIS to other Macs (where

<h1>Heatmap Plugin Help</h1>

<p>Heatmap Plugin creates a heatmap raster for the input point vector layer. The heatmap is generated based on the number of points in a given location. The higher the number of points, the higher will be the corresponding pixel(s) value in the raster.</p>

<h2>The Dialog Parameters</h2>

<h3>Input Point Vector</h3>

<p>The input is always a vector layer of point type. All the point vector layers that are currently loaded in the window are automatically populated in the input layer drop-down list. Click the Dropdown button and select the required layer.</p>

<h3>Output Ratser</h3>

<p>The output raster location and filename can be set by clicking the <label>...</label> button next to the output raster textbox.<br/>

<b>Note:</b>The file format is automatically added depending upon the output format selected, if not explicitly given.</p>

<h3>Output Format</h3>

<p>All the file creation supporting GDAL formats are available in the drop down list. Click and select the required output format for your file.<br/>

<b>Note:</b> GeoTiff and ERDAS Imagine .img formats are recommended. Some formats makes the application crash. Kindly stick to the recommended formats until the crash issue is resolved or Use other formats if you know about its GDAL support completely.</p>

<h3>Heatmap Point Attributes</h3>

<h4>Buffer Radius</h4>

<p>The buffer radius specifies the number of <b>pixels or cells</b> around a point where the heat(influence) of the point will be felt. Smaller values give you clear distinction between points and bigger values gives you nicely merged heatmap regions. This is the spatial parameter of the heat region of a point.<br/>

<b>Note:</b> The value is always a whole number.</p>

<h4>Decay Ratio</h4>

<p>The decay ratio defines amount of heat(influence) that should reach the outermost pixel in the Buffer Radius. It is the direct measure of the outer most value.<br/>

<b>Example:</b> If Buffer Ratio is set as 0 and Radius as 10, then the centre pixel of a point will have value and the pixel away by a distance of 10 units will have the value 0, a pixel which is 5 units away will have a value of 0.5 and so on. Here distance is measure not by pixel count rather using sqrt( xOffset^2 + yOffset^2 ), so you always get a circular heat region.</p>

<h2>Further Details</h2>

<p>Contact the author through aruntheguy at gmail dot com</p>

SUBDIRS (heatmap)

SET (heatmap_SRCS

heatmap.cpp

heatmapgui.cpp

)

SET (heatmap_UIS heatmapguibase.ui)

SET (heatmap_MOC_HDRS

heatmap.h

heatmapgui.h

)

SET (heatmap_RCCS heatmap.qrc)

QT4_WRAP_UI (heatmap_UIS_H ${heatmap_UIS})

QT4_WRAP_CPP (heatmap_MOC_SRCS ${heatmap_MOC_HDRS})

QT4_ADD_RESOURCES(heatmap_RCC_SRCS ${heatmap_RCCS})

ADD_LIBRARY (heatmapplugin MODULE ${heatmap_SRCS} ${heatmap_MOC_SRCS} ${heatmap_RCC_SRCS} ${heatmap_UIS_H})

INCLUDE_DIRECTORIES(

${CMAKE_CURRENT_BINARY_DIR}

${GEOS_INCLUDE_DIR}

${GDAL_INCLUDE_DIR}

../../core

../../core/raster

../../gui

../../analysis/raster

..

)

TARGET_LINK_LIBRARIES(heatmapplugin

qgis_core

qgis_gui

)

INSTALL(TARGETS heatmapplugin

RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}

LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})

Welcome to your automatically generated plugin!

-------------------------------------------------------------

This is just a starting point. You now need to modify the code to make it do

something useful....read on for a more information to get yourself started.

Documentation:

-------------------------------------------------------------

You really need to read the QGIS API Documentation now at:

http://qgis.org/api/

In particular look at the following classes:

QGisInterface : http://qgis.org/api/classQgisInterface.html

QgsMapCanvas : http://qgis.org/api/classQgsMapCanvas.html

QgsMapTool : http://qgis.org/api/classQgsMapTool.html

QgisPlugin : http://qgis.org/api/classQgisPlugin.html

QGisInterface is an abstract base class (ABC) that specifies what publicly

available features of QGIS are exposed to third party code and plugins. An

instance of the QgisInterface is passed to the plugin when it loads. Please

consult the QGIS development team if there is functionality required in the

QGisInterface that is not available.

QgsPlugin is an ABC that defines required behaviour your plugin must provide.

See below for more details.

What are all the files in my generated plugin directory for?

-------------------------------------------------------------

CMakeLists.txt

This is the generated CMake file that builds the plugin. You should add you

application specific dependencies and source files to this file.

heatmap.h

heatmap.cpp

This is the class that provides the 'glue' between your custom application

logic and the QGIS application. You will see that a number of methods are

already implemented for you - including some examples of how to add a raster or

vector layer to the main application map canvas. This class is a concrete

implementation of QgisPlugin (which defines required behaviour for a plugin).

In particular, a plugin has a number of static methods and members so that the

QgsPluginManager and plugin loader logic can identify each plugin, create an

appropriate menu entry for it etc. Note there is nothing stopping you creating

multiple toolbar icons and menu entries for a single plugin. By default though

a single menu entry and toolbar button is created and its pre-configured to

call the run() method in this class when selected. This default implementation

provided for you by the plugin builder is well documented, so please refer to

the code for further advice.

heatmapgui.ui

This is a Qt designer 'ui' file. It defines the look of the default plugin

dialog without implementing any application logic. You can modify this form to

suite your needs or completely remove it if your plugin does not need to

display a user form (e.g. for custom MapTools).

heatmapgui.cpp

heatmapgui.h

This is the concrete class where application logic for the above mentioned

dialog should go. The world is your oyster here really....

heatmap.qrc

This is the Qt4 resources file for your plugin. The Makefile generated for your

plugin is all set up to compile the resource file so all you need to do is add

your additional icons etc using the simple xml file format. Note the namespace

used for all your resources e.g. (":/Heatmap/"). It is important to use

this prefix for all your resources. We suggest you include any other images and

run time data in this resurce file too.

heatmap.png

This is the icon that will be used for your plugin menu entry and toolbar icon.

Simply replace this icon with your own icon to make your plugin disctinctive

from the rest.

README

This file contains the documentation you are reading now!

Getting developer help:

-------------------------------------------------------------

For Questions and Comments regarding the plugin builder template and creating

your features in QGIS using the plugin interface please contact us via:

* the QGIS developers mailing list, or

* IRC (#qgis on freenode.net)

QGIS is distributed under the Gnu Public License. If you create a useful plugin

please consider contributing it back to the community.

Have fun and thank you for choosing QGIS.

The QGIS Team

2007

#include "gdal_priv.h"

#include "cpl_string.h"

#include "cpl_conv.h"

#include <qgisinterface.h>

#include <qgisgui.h>

#include "heatmap.h"

#include "heatmapgui.h"

#include "qgsgeometry.h"

#include "qgsvectorlayer.h"

#include "qgsvectordataprovider.h"

#include <QAction>

#include <QToolBar>

#include <QMessageBox>

#include <QFileInfo>

#include <QProgressDialog>

#define NO_DATA -9999

static const QString sName = QObject::tr( "Heatmap" );

static const QString sDescription = QObject::tr( "Creates a Heatmap raster for the input point vector" );

static const QString sCategory = QObject::tr( "Raster" );

static const QString sPluginVersion = QObject::tr( "Version 0.1" );

static const QgisPlugin::PLUGINTYPE sPluginType = QgisPlugin::UI;

static const QString sPluginIcon = ":/heatmap/heatmap.png";

Heatmap::Heatmap( QgisInterface * theQgisInterface ):

QgisPlugin( sName, sDescription, sCategory, sPluginVersion, sPluginType ),

mQGisIface( theQgisInterface )

{

}

Heatmap::~Heatmap()

{

}

void Heatmap::initGui()

{

// Create the action for tool

mQActionPointer = new QAction( QIcon( ":/heatmap/heatmap.png" ), tr( "Heatmap" ), this );

// Set the what's this text

mQActionPointer->setWhatsThis( tr( "Creats a heatmap raster for the input point vector." ) );

// Connect the action to the run

connect( mQActionPointer, SIGNAL( triggered() ), this, SLOT( run() ) );

// Add the icon to the toolbar

mQGisIface->addToolBarIcon( mQActionPointer );

mQGisIface->addPluginToRasterMenu( tr( "&Heatmap" ), mQActionPointer );

}

void Heatmap::help()

{

//implement me!

}

void Heatmap::run()

{

HeatmapGui *myPluginGui = new HeatmapGui( mQGisIface->mainWindow(), QgisGui::ModalDialogFlags );

myPluginGui->setAttribute( Qt::WA_DeleteOnClose );

// Connect the createRaster signal to createRaster Slot

connect( myPluginGui, SIGNAL( createRaster( QgsVectorLayer*, int, float, QString, QString ) ),

this, SLOT( createRaster( QgsVectorLayer*, int, float, QString, QString ) ) );

myPluginGui->show();

}

void Heatmap::unload()

{

// remove the GUI

mQGisIface->removePluginMenu( "&Heatmap", mQActionPointer );

mQGisIface->removeToolBarIcon( mQActionPointer );

delete mQActionPointer;

}

void Heatmap::createRaster( QgsVectorLayer* theVectorLayer, int theBuffer, float theDecay, QString theOutputFilename, QString theOutputFormat )

{

// generic variables

int xSize, ySize;

double xResolution, yResolution;

double rasterX, rasterY;

// Getting the rasterdataset in place

GDALAllRegister();

GDALDataset *emptyDataset;

GDALDriver *myDriver;

myDriver = GetGDALDriverManager()->GetDriverByName( theOutputFormat.toUtf8() );

if( myDriver == NULL )

{

QMessageBox::information( 0, tr("Error in GDAL Driver!"), tr("Cannot open the driver for the format specified") );

return;

}

// bounding box info

QgsRectangle myBBox = theVectorLayer->extent();

// fixing a base width of 500 px/cells

xSize = 500;

xResolution = myBBox.width()/xSize;

yResolution = xResolution;

ySize = myBBox.height()/yResolution;

// add extra extend to cover the corner points' heat region

xSize = xSize + ( theBuffer * 2 ) + 10 ;

ySize = ySize + ( theBuffer * 2 ) + 10 ;

// Define the new lat,lon for the buffered raster area

rasterX = myBBox.xMinimum() - ( theBuffer + 5 ) * xResolution;

rasterY = myBBox.yMinimum() - ( theBuffer + 5 ) * yResolution;

double geoTransform[6] = { rasterX, xResolution, 0, rasterY, 0, yResolution };

emptyDataset = myDriver->Create( theOutputFilename.toUtf8(), xSize, ySize, 1, GDT_Float32, NULL );

emptyDataset->SetGeoTransform( geoTransform );

GDALRasterBand *poBand;

poBand = emptyDataset->GetRasterBand(1);

poBand->SetNoDataValue( NO_DATA );

float* line = ( float * ) CPLMalloc( sizeof( float ) * xSize );

std::fill_n( line, xSize, NO_DATA );

// Write the empty raster

for ( int i = 0; i < ySize ; i += 1 )

{

poBand->RasterIO( GF_Write, 0, 0, xSize, 1, line, xSize, 1, GDT_Float32, 0, 0 );

}

CPLFree( line );

//close the dataset

GDALClose( (GDALDatasetH) emptyDataset );

// open the raster in GA_Update mode

GDALDataset *heatmapDS;

heatmapDS = ( GDALDataset * ) GDALOpen( theOutputFilename.toUtf8(), GA_Update );

if( !heatmapDS )

{

QMessageBox::information( 0, tr("Error in Updating Raster!"), tr("Couldnot open the created raster for updation. The Heatmap was not generated.") );

return;

}

poBand = heatmapDS->GetRasterBand( 1 );

// Get the data buffer ready

int blockSize = 2 * theBuffer + 1; // block SIDE would have been more appropriate

// Open the vector features

QgsVectorDataProvider* myVectorProvider = theVectorLayer->dataProvider();

if( !myVectorProvider )

{

QMessageBox::information( 0, tr( "Error in Point Layer!"), tr("Couldnot identify the vector data provider.") );

return;

}

QgsAttributeList dummyList;

myVectorProvider->select( dummyList );

int totalFeatures = myVectorProvider->featureCount();

int counter = 0;

QProgressDialog p( "Creating Heatmap ... ", "Abort", 0, totalFeatures );

p.setWindowModality(Qt::WindowModal);

QgsFeature myFeature;

while( myVectorProvider->nextFeature( myFeature ) )

{

counter += 1;

p.setValue( counter );

if( p.wasCanceled() )

{

QMessageBox::information( 0, tr("Heatmap Generation Aborted!"), tr("QGIS will now load the partially-computed raster.") );

break;

}

QgsGeometry* myPointGeometry;

myPointGeometry = myFeature.geometry();

// convert the geometry to point

QgsPoint myPoint;

myPoint = myPointGeometry->asPoint();

// avoiding any empty points or out of extent points

if( ( myPoint.x() < rasterX ) || ( myPoint.y() < rasterY ) )

{

continue;

}

// calculate the pixel position

unsigned int xPosition, yPosition;

xPosition = (( myPoint.x() - rasterX )/ xResolution ) - theBuffer;

yPosition = (( myPoint.y() - rasterY )/ yResolution ) - theBuffer;

// get the data

float *dataBuffer = ( float * ) CPLMalloc( sizeof( float ) * blockSize * blockSize );

poBand->RasterIO( GF_Read, xPosition, yPosition, blockSize, blockSize, dataBuffer, blockSize, blockSize, GDT_Float32, 0, 0 );

for( int xp = 0; xp <= theBuffer; xp += 1 )

{

for( int yp = 0; yp <= theBuffer; yp += 1 )

{

float distance = sqrt( pow( xp, 2 ) + pow( yp, 2 ) );

float pixelValue = 1 - ( (1-theDecay) * distance / theBuffer );

// clearing anamolies along the axes

if( xp == 0 && yp == 0 )

{

pixelValue /= 4;

}

else if( xp == 0 || yp == 0 )

{

pixelValue /= 2;

}

if( distance <= theBuffer )

{

int pos[4];

pos[0] = ( theBuffer + xp ) * blockSize + ( theBuffer + yp );

pos[1] = ( theBuffer + xp ) * blockSize + ( theBuffer - yp );

pos[2] = ( theBuffer - xp ) * blockSize + ( theBuffer + yp );

pos[3] = ( theBuffer - xp ) * blockSize + ( theBuffer - yp );

for( int p = 0; p < 4; p += 1 )

{

if( dataBuffer[ pos[p] ] == NO_DATA )

{

dataBuffer[ pos[p] ] = 0;

}

dataBuffer[ pos[p] ] += pixelValue;

}

}

}

}

poBand->RasterIO( GF_Write, xPosition, yPosition, blockSize, blockSize, dataBuffer, blockSize, blockSize, GDT_Float32, 0, 0 );

CPLFree( dataBuffer );

}

//Finally close the dataset

GDALClose( (GDALDatasetH) heatmapDS );

// Open the file in QGIS window

mQGisIface->addRasterLayer( theOutputFilename, QFileInfo( theOutputFilename ).baseName() );

}

QGISEXTERN QgisPlugin * classFactory( QgisInterface * theQgisInterfacePointer )

{

return new Heatmap( theQgisInterfacePointer );

}

QGISEXTERN QString name()

{

return sName;

}

QGISEXTERN QString description()

{

return sDescription;

}

QGISEXTERN QString category()

{

return sCategory;

}

QGISEXTERN int type()

{

return sPluginType;

}

QGISEXTERN QString version()

{

return sPluginVersion;

}

QGISEXTERN QString icon()

{

return sPluginIcon;

}

QGISEXTERN void unload( QgisPlugin * thePluginPointer )

{

delete thePluginPointer;

}

#ifndef Heatmap_H

#define Heatmap_H

#include <QObject>

#include "../qgisplugin.h"

#include "qgsvectorlayer.h"

class QAction;

class QToolBar;

class QgisInterface;

class Heatmap: public QObject, public QgisPlugin

{

Q_OBJECT

public:

// MANDATORY PLUGIN METHODS FOLLOW

/**

Heatmap( QgisInterface * theInterface );

//! Destructor

virtual ~Heatmap();

public slots:

//! init the gui

virtual void initGui();

//! Show the dialog box

void run();

//! unload the plugin

void unload();

//! show the help document